WebSVN – wimsdev – Diff – /trunk/wims/src/Misc/checkmol/checkmolc.c

 #define fg_heterocycle  202
 #define fg_alpha_aminoacid  203
 #define fg_alpha_hydroxyacid  204
 typedef enum
-  { false = 0, true } boolean;
+  { isfalse = 0, istrue } boolean;
 typedef char str2[3];
 typedef char str3[4];
 } p_3d;
 typedef int chirpath_type[4];  /* new in v0.3f */
 #ifdef MAKE_SHARED_LIBRARY
-static boolean yet_initialized = false;
+static boolean yet_initialized = isfalse;
 #endif
 typedef struct connval_rec
+{
   /* new in v0.3j */
 static boolean
 file_exists (const char *fileName)
+{
   struct stat filestat;
-  return stat (fileName, &filestat) == 0 ? true : false;
+  return stat (fileName, &filestat) == 0 ? istrue : isfalse;
+}
 static void lblank (int cols, char *nstr)
+{
   /* inserts leading blanks up to a given number of total characters */
 static void init_globals ()
+{
   /*int i;*/
-  opt_verbose = false;
+  opt_verbose = isfalse;
-  opt_debug = false;
+  opt_debug = isfalse;
-  opt_exact = false;
+  opt_exact = isfalse;
-  opt_stdin = false;
+  opt_stdin = isfalse;
-  opt_text = false;
+  opt_text = isfalse;
-  opt_code = false;
+  opt_code = isfalse;
-  opt_bin = false;
+  opt_bin = isfalse;
-  opt_bitstring = false;
+  opt_bitstring = isfalse;
-  opt_molout = false;
+  opt_molout = isfalse;
-  opt_molstat = false;
+  opt_molstat = isfalse;
-  opt_molstat_X = false;
+  opt_molstat_X = isfalse;
-  opt_xmdlout = false;
+  opt_xmdlout = isfalse;
-  opt_strict = false; /* new in v0.2f */
+  opt_strict = isfalse; /* new in v0.2f */
-  opt_metalrings = false;  /* new in v0.3 */
+  opt_metalrings = isfalse;  /* new in v0.3 */
-  opt_geom = false;   /* new in v0.3d */
+  opt_geom = isfalse;   /* new in v0.3d */
-  opt_chiral = false; /* new in v0.3f */
+  opt_chiral = isfalse; /* new in v0.3f */
-  opt_fp = false;     /* new in v0.3m */
+  opt_fp = isfalse;     /* new in v0.3m */
-  opt_iso = false;    /* new in v0.3x */
+  opt_iso = isfalse;    /* new in v0.3x */
-  opt_chg = false;    /* new in v0.3x */
+  opt_chg = isfalse;    /* new in v0.3x */
-  opt_rad = false;    /* new in v0.3x */
+  opt_rad = isfalse;    /* new in v0.3x */
-  /*cm_mdlmolfile   := false; */
+  /*cm_mdlmolfile   := isfalse; */
-  found_arominfo = false;
+  found_arominfo = isfalse;
-  found_querymol = false;
+  found_querymol = isfalse;
-  ndl_querymol = false;
+  ndl_querymol = isfalse;
   opt_rs = rs_sar;    /* v0.3i */
   /*ringsearch_mode := rs_sar; */
-  rfile_is_open = false;/* new in v0.2g */
+  rfile_is_open = isfalse;/* new in v0.2g */
-  ez_search = false;    /* new in v0.3d */
+  ez_search = isfalse;    /* new in v0.3d */
-  rs_search = false;    /* new in v0.3f */
+  rs_search = isfalse;    /* new in v0.3f */
-  ez_flag = false;      /* new in v0.3f */
+  ez_flag = isfalse;      /* new in v0.3f */
-  chir_flag = false;    /* new in v0.3f */
+  chir_flag = isfalse;    /* new in v0.3f */
-  rs_strict = false;    /* new in v0.3j */
+  rs_strict = isfalse;    /* new in v0.3j */
   n_Ctot = 0;
   n_Otot = 0;
   n_Ntot = 0;      /* new in v0.3g */
   ndl_n_Ctot = 0;
   ndl_n_Otot = 0;
   ndl_n_Ntot = 0;   /* new in v0.3g */
   //for (i = 0; i < max_fg; i++)
-  //  fg[i] = false;
+  //  fg[i] = isfalse;
   memset (fg, 0, sizeof (fglist));
   /*try */
   molbuf = safe_malloc (sizeof (molbuftype));
   /*except
      on e:Eoutofmemory do
      begin
      writeln('Not enough memory');
      halt(4);
      end;
      end; */
-  ether_generic = false;  /* v0.3j */
+  ether_generic = isfalse;  /* v0.3j */
-  amine_generic = false;  /* v0.3j */
+  amine_generic = isfalse;  /* v0.3j */
-  hydroxy_generic = false;/* v0.3j */
+  hydroxy_generic = isfalse;/* v0.3j */
   fpformat = fpf_decimal; /* v0.3m */
   fpindex = 0;            /* v0.3m */
-  fp_exacthit = false;    /* v0.3m */
+  fp_exacthit = isfalse;    /* v0.3m */
-  fp_exactblock = false;  /* v0.3m */
+  fp_exactblock = isfalse;  /* v0.3m */
   tmfcode = 0;            /* v0.3m */
-  tmfmismatch = false;    /* v0.3m */
+  tmfmismatch = isfalse;    /* v0.3m */
-  auto_ssr = false;       /* v0.3n */
+  auto_ssr = isfalse;       /* v0.3n */
   recursion_depth = 0;
+}
 static inline void init_molstat (molstat_rec *mstat)
+{
   int i, FORLIM;
   if (n_atoms > 0) {
     FORLIM = n_atoms;
     for (i = 0; i < FORLIM; i++)
-      atom[i].tag = false;
+      atom[i].tag = isfalse;
+  }
+}
 #if 0
 static void set_atom_tags ()
   int i, FORLIM;
   if (n_atoms > 0){
     FORLIM = n_atoms;
     for (i = 0; i < FORLIM; i++)
-      atom[i].tag = true;
+      atom[i].tag = istrue;
+  }
+}
 #endif
 static void order_ringpath (int *r_path)
+{
+{
   int i;
   if (ndl_n_atoms > 0){
     for (i = 0; i < ndl_n_atoms; i++)
-      ndl_atom[i].tag = false;
+      ndl_atom[i].tag = isfalse;
+  }
+}
 static void set_ndl_atom_tags ()
+{
   int i;
   if (ndl_n_atoms > 0){
     for (i = 0; i < ndl_n_atoms; i++)
-     ndl_atom[i].tag = true;
+     ndl_atom[i].tag = istrue;
+  }
+}
 static int count_tagged_ndl_heavyatoms ()
+{
 var                         (* just a simple, distance-based estimation
   total_dist  : double;     (* instead of calculating the dihedral angle
   direct_dist : double;
   res         : boolean;
 begin
-  res := false;
+  res := isfalse;
   total_dist  := dist3d(p1,p2) + dist3d(p2,p3) + dist3d(p3,p4);
   direct_dist := dist3d(p1,p4);
-  if (direct_dist < 0.78 * total_dist) then res := true;  (* cutoff value of 0.78 was
+  if (direct_dist < 0.78 * total_dist) then res := istrue;  (* cutoff value of 0.78 was
   is_cis := res;                                          (* experimentally determined
 end;
 */
 /* function is_cis was replaced by a new one in v0.3h */
 static boolean is_cis (p_3d p1, p_3d p2, p_3d p3, p_3d p4)
+{
   /* new in v0.3h, uses the dihedral angle */
   double phi;
-  boolean res = false;
+  boolean res = isfalse;
   phi = torsion (p1, p2, p3, p4);
   if (fabs (phi) < M_PI / 2)
-    res = true;
+    res = istrue;
   return res;
+}
 /*====================== end of geometry functions ========================== */
   char parstr[256];
   char tmpstr[256];
   int l;
   *tmpstr = '\0';
-  opt_none = true;
+  opt_none = istrue;
   if (progmode == pmCheckMol) {
     for (p = 1; p < P_argc; p++) {
       strcpy(parstr, P_argv[p]);
       if (!strcmp(parstr, "-l")) {   /* new in v0.3l */
         list_molstat_codes();
             l++;
           if (strlen(tmpstr) > l + 2) {
             show_usage();
             _Escape(1);
+          }
-          opt_none = false;
+          opt_none = isfalse;
           if (strpos2(tmpstr, "M", 1) > 0)
-            opt_metalrings = true;
+            opt_metalrings = istrue;
           if (strpos2(tmpstr, "v", 1) > 0)
-            opt_verbose = true;
+            opt_verbose = istrue;
             /* p2c: checkmol.pas, line 1261:
             * Note: Turbo Pascal conditional compilation directive was ignored [218] */
             /*$IFDEF debug
             if (strpos2(tmpstr, "D", 1) > 0)
-              opt_debug = true;
+              opt_debug = istrue;
             $ENDIF*/
           if (strpos2(tmpstr, "e", 1) > 0)
-            opt_text = true;
+            opt_text = istrue;
           else {
             if (strpos2(tmpstr, "d", 1) > 0)
-              opt_text_de = true;
+              opt_text_de = istrue;
             else {
               if (strpos2(tmpstr, "c", 1) > 0)
-                opt_code = true;
+                opt_code = istrue;
               else {
                 if (strpos2(tmpstr, "b", 1) > 0)
-                  opt_bin = true;
+                  opt_bin = istrue;
                 else {
                   if (strpos2(tmpstr, "s", 1) > 0)
-                    opt_bitstring = true;
+                    opt_bitstring = istrue;
+                }
+              }
+            }
             if (strpos2(tmpstr, "x", 1) > 0)
-              opt_molstat = true;
+              opt_molstat = istrue;
             if (strpos2(tmpstr, "r", 1) > 0)
               opt_rs = rs_ssr;
             if (strpos2(tmpstr, "X", 1) > 0) {
-              opt_molstat = true;
+              opt_molstat = istrue;
-              opt_molstat_X = true;
+              opt_molstat_X = istrue;
+            }
             if (strpos2(tmpstr, "m", 1) > 0) {
-              opt_text = false;
+              opt_text = isfalse;
-              opt_text_de = false;
+              opt_text_de = isfalse;
-              opt_bin = false;
+              opt_bin = isfalse;
-              opt_bitstring = false;
+              opt_bitstring = isfalse;
-              opt_code = false;
+              opt_code = isfalse;
-              opt_molstat = false;
+              opt_molstat = isfalse;
-              opt_xmdlout = true;
+              opt_xmdlout = istrue;
+                  }
+          }
         strcpy(molfilename, tmpstr);
+      }
     } else {
       if (strpos2(parstr, "-", 1) == 1) {
         if (strlen(parstr) > 1) {
           show_usage();
           _Escape(1);
+        }
-        opt_stdin = true;
+        opt_stdin = istrue;
       } else {
-      opt_stdin = false;
+      opt_stdin = isfalse;
       strcpy(molfilename, parstr);
+      }
+        }
+    }
-    if (opt_text == false && opt_text_de == false && opt_code == false &&
+    if (opt_text == isfalse && opt_text_de == isfalse && opt_code == isfalse &&
-        opt_bin == false && opt_bitstring == false && opt_molstat == false &&
+        opt_bin == isfalse && opt_bitstring == isfalse && opt_molstat == isfalse &&
-        opt_molstat_X == false && opt_xmdlout == false)
+        opt_molstat_X == isfalse && opt_xmdlout == isfalse)
-      opt_none = true;
+      opt_none = istrue;
+  }
   if (progmode == pmMatchMol) {
     *ndl_molfilename = '\0';
     *molfilename = '\0';
     for (p = 1; p < P_argc; p++) {
         strcpy(parstr, P_argv[p]);
       if (p == 1) {
         if (strpos2(parstr, "-", 1) == 1) {
           if (strpos2(parstr, "v", 1) > 1)
-            opt_verbose = true;
+            opt_verbose = istrue;
             /* p2c: checkmol.pas, line 1329:
              * Note: Turbo Pascal conditional compilation directive was ignored [218] */
             /*$IFDEF debug
                 if (strpos2(parstr, "D", 1) > 1)
-                  opt_debug = true;
+                  opt_debug = istrue;
                $ENDIF*/
           if (strpos2(parstr, "x", 1) > 1)
-            opt_exact = true;
+            opt_exact = istrue;
           if (strpos2(parstr, "s", 1) > 1)   /* new in v0.2f */
-            opt_strict = true;
+            opt_strict = istrue;
           if (strpos2(parstr, "m", 1) > 1)
-           opt_molout = true;
+           opt_molout = istrue;
           if (strpos2(parstr, "r", 1) > 1)
             opt_rs = rs_ssr;
           if (strpos2(parstr, "M", 1) > 0)   /* new in v0.3 */
-            opt_metalrings = true;
+            opt_metalrings = istrue;
           if (strpos2(parstr, "g", 1) > 0)   /* new in v0.3d */
-            opt_geom = true;
+            opt_geom = istrue;
           if (strpos2(parstr, "G", 1) > 0)   /* new in v0.3f */
-            opt_chiral = true;
+            opt_chiral = istrue;
           if (strpos2(parstr, "f", 1) > 0) {   /* new in v0.3m */
-            opt_fp = true;
+            opt_fp = istrue;
           fpformat = fpf_boolean;
+        }
         if (strpos2(parstr, "F", 1) > 0) {   /* new in v0.3m */
-          opt_fp = true;
+          opt_fp = istrue;
           fpformat = fpf_decimal;
+        }
         if (strpos2(parstr, "h", 1) > 1) {
           show_usage();
           _Escape(0);
+    }
     if (p == P_argc - 1) {
       if (strcmp(parstr, "-"))
         strcpy(molfilename, parstr);
       else
-        opt_stdin = true;
+        opt_stdin = istrue;
+      }
+    }
     if (opt_geom)   /* v0.3d */
-      ez_search = true;
+      ez_search = istrue;
     if (opt_chiral)   /* v0.3f */
-      rs_search = true;
+      rs_search = istrue;
     if (opt_chiral && opt_strict && (opt_exact || opt_fp))
         /* new in v0.3j, v0.3m */
-      rs_strict = true;
+      rs_strict = istrue;
     if (opt_fp) {   /* v0.3m */
-        opt_molout = false;
+        opt_molout = isfalse;
-        opt_exact = false;
+        opt_exact = isfalse;
+    }
   }  /* progmode = pmMatchMol */
   ringsearch_mode = opt_rs;   /* v0.3i */
+}
 #endif
   char parstr[256];
   char tmpstr[256];
   short l;
   *tmpstr = '\0';
-  opt_none = true;
+  opt_none = istrue;
   *molfilename = '\0';
   *ndl_molfilename = '\0';
   if (progmode == pmCheckMol) {
     for (p = 1; p <= argc - 1; p++) {
             strcpy (parstr, argv[p]);
                         l++;
                       if (strlen (tmpstr) > l + 2) {
                         show_usage ();
                         exit (1);
+                      }
-                      opt_none = false;
+                      opt_none = isfalse;
                       if (strpos2 (tmpstr, "M", 1) > 0)
-                        opt_metalrings = true;
+                        opt_metalrings = istrue;
                       if (strpos2 (tmpstr, "v", 1) > 0)
-                        opt_verbose = true;
+                        opt_verbose = istrue;
                       /*{$IFDEF debug
-                         if pos('D',tmpstr)>0 then opt_debug       := true;
+                         if pos('D',tmpstr)>0 then opt_debug       := istrue;
                          {$ENDIF */
                       if (strpos2 (tmpstr, "e", 1) > 0)
-                        opt_text = true;
+                        opt_text = istrue;
                       else {
                         if (strpos2 (tmpstr, "d", 1) > 0)
-                                 opt_text_de = true;
+                                 opt_text_de = istrue;
                         else {
                                 if (strpos2 (tmpstr, "c", 1) > 0)
-                                  opt_code = true;
+                                  opt_code = istrue;
                                 else {
                                   if (strpos2 (tmpstr, "b", 1) > 0)
-                                    opt_bin = true;
+                                    opt_bin = istrue;
                                   else {
                                     if (strpos2 (tmpstr, "s", 1) > 0)
-                                      opt_bitstring = true;
+                                      opt_bitstring = istrue;
+                                  }
+                                }
+                              }
                         if (strpos2 (tmpstr, "x", 1) > 0)
-                                opt_molstat = true;
+                                opt_molstat = istrue;
                         if (strpos2 (tmpstr, "r", 1) > 0)
                                 opt_rs = rs_ssr;
                           /* if (strpos2 (tmpstr, "a", 1) > 0)
-                            opt_chg = true; */ /* 0.3x  */
+                            opt_chg = istrue; */ /* 0.3x  */
                         if (strpos2 (tmpstr, "X", 1) > 0) {
-                                opt_molstat = true;
+                                opt_molstat = istrue;
-                                opt_molstat_X = true;
+                                opt_molstat_X = istrue;
+                              }
                         if (strpos2 (tmpstr, "m", 1) > 0) {
-                                opt_text = false;
+                                opt_text = isfalse;
-                                opt_text_de = false;
+                                opt_text_de = isfalse;
-                                opt_bin = false;
+                                opt_bin = isfalse;
-                                opt_bitstring = false;
+                                opt_bitstring = isfalse;
-                                opt_code = false;
+                                opt_code = isfalse;
-                                opt_molstat = false;
+                                opt_molstat = isfalse;
-                                opt_xmdlout = true;
+                                opt_xmdlout = istrue;
+                              }
+                      }
                       strcpy (molfilename, tmpstr);
+              }
+            }
               if (strpos2 (parstr, "-", 1) == 1) {
                 if (strlen (parstr) > 1) {
                   show_usage ();
                   exit (1);
+                }
-                opt_stdin = true;
+                opt_stdin = istrue;
               } else {
-                      opt_stdin = false;
+                      opt_stdin = isfalse;
                       strcpy (molfilename, parstr);
+                    }
+            }
+          }
-    if (opt_text == false && opt_text_de == false && opt_code == false &&
+    if (opt_text == isfalse && opt_text_de == isfalse && opt_code == isfalse &&
-                opt_bin == false && opt_bitstring == false && opt_molstat == false
+                opt_bin == isfalse && opt_bitstring == isfalse && opt_molstat == isfalse
-                && opt_molstat_X == false && opt_xmdlout == false
+                && opt_molstat_X == isfalse && opt_xmdlout == isfalse
-                && opt_chg == false)
+                && opt_chg == isfalse)
-              opt_none = true;  /* 0.3x */
+              opt_none = istrue;        /* 0.3x */
+  }
   if (progmode == pmMatchMol) {
     for (p = 1; p <= argc - 1; p++) {
       strcpy (parstr, argv[p]);
       if (p == 1) {
         if (strpos2 (parstr, "-", 1) == 1) {
           if (strpos2 (parstr, "v", 1) > 1)
-            opt_verbose = true;
+            opt_verbose = istrue;
             /*{$IFDEF debug
-               if pos('D',parstr)>1 then opt_debug       := true;
+               if pos('D',parstr)>1 then opt_debug       := istrue;
                {$ENDIF */
           if (strpos2 (parstr, "x", 1) > 1)
-            opt_exact = true;
+            opt_exact = istrue;
           if (strpos2 (parstr, "s", 1) > 1)     /* new in v0.2f */
-            opt_strict = true;
+            opt_strict = istrue;
           if (strpos2 (parstr, "m", 1) > 1)
-            opt_molout = true;
+            opt_molout = istrue;
           if (strpos2 (parstr, "r", 1) > 1)
             opt_rs = rs_ssr;
           if (strpos2 (parstr, "a", 1) > 0)
-                    opt_chg = true;     /* 0.3x */
+                    opt_chg = istrue;   /* 0.3x */
           if (strpos2 (parstr, "i", 1) > 0)
-            opt_iso = true;     /* 0.3x */
+            opt_iso = istrue;   /* 0.3x */
           if (strpos2 (parstr, "d", 1) > 0)
-            opt_rad = true;     /* 0.3x */
+            opt_rad = istrue;   /* 0.3x */
           if (strpos2 (parstr, "M", 1) > 0)     /* new in v0.3 */
-            opt_metalrings = true;
+            opt_metalrings = istrue;
           if (strpos2 (parstr, "g", 1) > 0)     /* new in v0.3d */
-            opt_geom = true;
+            opt_geom = istrue;
           if (strpos2 (parstr, "G", 1) > 0)     /* new in v0.3f */
-            opt_chiral = true;
+            opt_chiral = istrue;
           if (strpos2 (parstr, "f", 1) > 0) {           /* new in v0.3m */
-            opt_fp = true;
+            opt_fp = istrue;
             fpformat = fpf_boolean;
+          }
           if (strpos2 (parstr, "F", 1) > 0) {           /* new in v0.3m */
-            opt_fp = true;
+            opt_fp = istrue;
             fpformat = fpf_decimal;
+          }
           if (strpos2 (parstr, "h", 1) > 1) {
             show_usage ();
             exit (0);
+              }
             if (p == argc - 1) {
               if (strcmp (parstr, "-"))
                 strcpy (molfilename, parstr);
               else
-                opt_stdin = true;
+                opt_stdin = istrue;
+            }
+          }
     if (opt_geom)               /* v0.3d */
-            ez_search = true;
+            ez_search = istrue;
     if (opt_chiral)             /* v0.3f */
-            rs_search = true;
+            rs_search = istrue;
     if (opt_chiral && opt_strict && (opt_exact || opt_fp))
             /* new in v0.3j, v0.3m  */
-            rs_strict = true;
+            rs_strict = istrue;
     if (opt_fp) {                       /* v0.3m */
-            opt_molout = false;
+            opt_molout = isfalse;
-            opt_exact = false;
+            opt_exact = isfalse;
+          }
   }                             /* progmode = pmMatchMol */
   ringsearch_mode = opt_rs;     /* v0.3i */
+}
 static char *get_filetype (char *Result, char *f)
+{
   char rline[256];
   char auxstr[256];
   int i;
-  boolean mdl1 = false;
+  boolean mdl1 = isfalse;
   int ri;
   int sepcount = 0;
   char STR1[256], STR6[256], STR7[256];
   strcpy (auxstr, "unknown");
               (strcmp (strsub (STR6, rline, 20, 5), "BONDS") == 0) &&
               (strcmp (strsub (STR7, rline, 33, 7), "CHARGES") == 0))
             strcpy (auxstr, "alchemy");
     if ((i == li + 3) && (strcmp (strsub (STR1, rline, 35, 5), "V2000") == 0))
             /* and (copy(rline,31,3)='999') */
-            mdl1 = true;
+            mdl1 = istrue;
     if ((i == li + 1) && (strcmp (strsub (STR1, rline, 3, 6), "-ISIS-") == 0))
-            mdl1 = true;
+            mdl1 = istrue;
     if ((i == li + 1) && (strcmp (strsub (STR1, rline, 3, 8), "WLViewer") == 0))
-            mdl1 = true;
+            mdl1 = istrue;
     if ((i == li + 1) && (strcmp (strsub (STR1, rline, 3, 8), "CheckMol") == 0))
-            mdl1 = true;
+            mdl1 = istrue;
     if ((i == li + 1) && (strcmp (strsub (STR1, rline, 3, 8), "CATALYST") == 0)) {
-            mdl1 = true;
+            mdl1 = istrue;
             strcpy (auxstr, "mdl");
+          }
     if (strpos2 (rline, "M  END", 1) == 1 || mdl1)
             strcpy (auxstr, "mdl");
     if (strpos2 (rline, "@<TRIPOS>MOLECULE", 1) > 0)
   str2 el;
   strcpy (el, atom[id - 1].element);
   if (!strcmp (el, "DU") || !strcmp (el, "LP"))
-    return false;
+    return isfalse;
   /*if (progmode == pmCheckMol && !strcmp (el, "H ")
      && atom[id - 1].nucleon_number < 2)
-     return false;               0.3x  */
+     return isfalse;               0.3x  */
   if (!strcmp (el, "H "))       /* 0.3 p */ {
     if (progmode == pmMatchMol && !opt_iso) {
-            return false;
+            return isfalse;
+          }
     else {
           if (atom[id - 1].nucleon_number < 2)
-            return false;
+            return isfalse;
+          }
+  }
-  return true;
+  return istrue;
+}
 static boolean ndl_alkene_C (int ba)
+{
   /* new in v0.3f */
-  boolean res = false;
+  boolean res = isfalse;
   int i, ba2, FORLIM;
   if (ndl_n_atoms <= 0 || ndl_n_bonds <= 0)
-    return false;
+    return isfalse;
   FORLIM = ndl_n_bonds;
   for (i = 0; i < FORLIM; i++) {
     if (ndl_bond[i].a1 == ba || ndl_bond[i].a2 == ba) {
             if (ndl_bond[i].a1 == ba)
               ba2 = ndl_bond[i].a2;
             else
               ba2 = ndl_bond[i].a1;
           if (!strcmp (ndl_atom[ba - 1].atype, "C2 ") &&
               !strcmp (ndl_atom[ba2 - 1].atype, "C2 ")
-              && ndl_bond[i].btype == 'D' && ndl_bond[i].arom == false)
+              && ndl_bond[i].btype == 'D' && ndl_bond[i].arom == isfalse)
-            res = true;
+            res = istrue;
+          }
+  }
   return res;
+}
 static boolean is_metal (int id)
+{
-  boolean r = false;
+  boolean r = isfalse;
   str2 el;
   strcpy (el, atom[id - 1].element);
   if (!strcmp (el, "LI") || !strcmp (el, "NA") || !strcmp (el, "K ") ||
       !strcmp (el, "RB") || !strcmp (el, "CS") || !strcmp (el, "BE") ||
       !strcmp (el, "AL") || !strcmp (el, "SN") || !strcmp (el, "PB") ||
       !strcmp (el, "SB") || !strcmp (el, "BI"))
   /* p2c: checkmol.pas, line 1577:
   * Note: Line breaker spent 0.0 seconds, 5000 tries on line 1686 [251] */
     /* etc. etc. */
-    r = true;
+    r = istrue;
   return r;
+}
 static int get_nvalences (char *a_el)
+{
     WITH->y = yval;
     WITH->z = zval;
     WITH->real_charge = chgval;
     if (is_heavyatom (n)) {
             n_heavyatoms++;
-            WITH->heavy = true;
+            WITH->heavy = istrue;
             if (is_metal (n))
-              WITH->metal = true;
+              WITH->metal = istrue;
+          }
     WITH->nvalences = get_nvalences (WITH->element);    /* v0.3m   */
+  }
   /*
      with atom^[n] do
      real_charge    := 0;
      Hexp           := 0;
      Htot           := 0;
      neighbor_count := 0;
      ring_count     := 0;
-     arom           := false;
+     arom           := isfalse;
-     stereo_care    := false;
+     stereo_care    := isfalse;
-     heavy          := false;
+     heavy          := isfalse;
-     metal          := false;
+     metal          := isfalse;
-     tag            := false;
+     tag            := isfalse;
      end;
    */
   FORLIM = n_bonds;
   for (n = 0; n < FORLIM; n++) {
     ri++;
     WITH1 = &bond[n];
     WITH1->a1 = a1val;
     WITH1->a2 = a2val;
     WITH1->btype = rline[19];
     WITH1->ring_count = 0;
-    WITH1->arom = false;
+    WITH1->arom = isfalse;
     WITH1->topo = btopo_any;
     WITH1->stereo = bstereo_any;
     WITH1->mdl_stereo = 0;      /* v0.3n */
     if (atom[a1val - 1].heavy && atom[a2val - 1].heavy)
             n_heavybonds++;
+  }
   memset (ring, 0, sizeof (ringlist));
   for (n = 0; n < max_rings; n++) {                             /* new in v0.3 */
     ringprop[n].size = 0;
-    ringprop[n].arom = false;
+    ringprop[n].arom = isfalse;
-    ringprop[n].envelope = false;
+    ringprop[n].envelope = isfalse;
+  }
   li = ri + 1;
+}
 static void read_mol2file (char *mfilename)
       real_charge    := 0;
       Hexp           := 0;
       Htot           := 0;
       neighbor_count := 0;
       ring_count     := 0;
-      arom           := false;
+      arom           := isfalse;
-      stereo_care    := false;
+      stereo_care    := isfalse;
-      heavy          := false;
+      heavy          := isfalse;
-      metal          := false;
+      metal          := isfalse;
-      tag            := false;
+      tag            := isfalse;
       end;
     */
     if (ri < molbufindex) {
             ri++;
             strcpy (rline, molbuf[ri - 1]);
     WITH->y = yval;
     WITH->z = zval;
     WITH->real_charge = chgval;
     if (is_heavyatom (n)) {
             n_heavyatoms++;
-            WITH->heavy = true;
+            WITH->heavy = istrue;
             if (is_metal (n))
-              WITH->metal = true;
+              WITH->metal = istrue;
+          }
     WITH->nvalences = get_nvalences (WITH->element);    /* v0.3m   */
+  }
   while ((ri < molbufindex) && (strpos2 (rline, "@<TRIPOS>BOND", 1) == 0)) {
     ri++;
     if (rline[17] == '3')
             WITH1->btype = 'T';
     if (rline[17] == 'a')
             WITH1->btype = 'A';
     WITH1->ring_count = 0;
-    WITH1->arom = false;
+    WITH1->arom = isfalse;
     WITH1->topo = btopo_any;
     WITH1->stereo = bstereo_any;
     WITH1->mdl_stereo = 0;      /* v0.3n */
     if (atom[a1val - 1].heavy && atom[a2val - 1].heavy)
             n_heavybonds++;
+  }
   memset (ring, 0, sizeof (ringlist));
   for (n = 0; n < max_rings; n++) {                             /* new in v0.3 */
     ringprop[n].size = 0;
-    ringprop[n].arom = false;
+    ringprop[n].arom = isfalse;
-    ringprop[n].envelope = false;
+    ringprop[n].envelope = isfalse;
+  }
   li = ri + 1;
+}
 static void read_charges (char *chgstring_)
     a_id = left_int (isotopestring);
     a_nucleon_number = left_int (isotopestring);
     if (a_id != 0 && a_nucleon_number != 0) {
             atom[a_id - 1].nucleon_number = a_nucleon_number;
             if (!strcmp (atom[a_id - 1].element, "H ")) {
-              atom[a_id - 1].heavy = true;
+              atom[a_id - 1].heavy = istrue;
               n_heavyatoms++;
               strcpy (atom[a_id - 1].atype, "DU ");
+            }
+          }
     //printf ("ISO %i, %i\n", a_id, a_nucleon_number);
   float xval, yval, zval, chgval;
   char a1str[256], a2str[256], elemstr[256];
   int a1val, a2val, ri, rc, bt, bs;
   int sepcount = 0;
   int i;                        /* v0.3j */
-  boolean clearcharges = true;  /* v0.3j */
+  boolean clearcharges = istrue;        /* v0.3j */
   char STR1[256];
   /*  int FORLIM;*/
   atom_rec *WITH;
   bond_rec *WITH1;
   /* v0.3j */
   if (n_atoms > 0)
     zap_molecule ();
-  /*cm_mdlmolfile := false; */
+  /*cm_mdlmolfile := isfalse; */
   *rline = '\0';
   ri = li;
   strcpy (molname, molbuf[ri - 1]);     /* line 1 */
   if (ri < molbufindex)         /* line 2 */
     ri++;
   strcpy (rline, molbuf[ri - 1]);
   if (strpos2 (rline, "CheckMol", 1) == 3) {
-    /*cm_mdlmolfile := true; */
+    /*cm_mdlmolfile := istrue; */
-    found_arominfo = true;
+    found_arominfo = istrue;
     tmfcode = 1;                /* v0.3m (begin) */
     code = 0;
     if ((strlen (rline) >= 39) && (strpos2 (rline, "TMF", 1) == 35)) {
       /* v0.3m; encoding of tweaklevel */
             strsub (tmpstr, rline, 38, 2);
             code = (sscanf (tmpstr, "%d", &tmfcode) == 0);
+          }
     if (code != 0 || tmfcode != tweaklevel)
-            tmfmismatch = true;
+            tmfmismatch = istrue;
     else
-            tmfmismatch = false;
+            tmfmismatch = isfalse;
       if ((strpos2 (rline, ":r0", 1) >= 40 && ringsearch_mode != rs_sar) ||
                 (strpos2 (rline, ":r1", 1) >= 40 && ringsearch_mode != rs_ssr))
-              tmfmismatch = true;
+              tmfmismatch = istrue;
-      if ((strpos2 (rline, ":m0", 1) >= 40 && opt_metalrings == true) ||
+      if ((strpos2 (rline, ":m0", 1) >= 40 && opt_metalrings == istrue) ||
-                (strpos2 (rline, ":m1", 1) >= 40 && opt_metalrings == false))
+                (strpos2 (rline, ":m1", 1) >= 40 && opt_metalrings == isfalse))
-              tmfmismatch = true;
+              tmfmismatch = istrue;
       /* p2c: checkmol.pas, line 2128:
        * Note: Turbo Pascal conditional compilation directive was ignored [218] */
             /*$IFDEF debug */
             //if (tmfmismatch)
             //printf ("\"tweaked\" molfile: version mismatch!\n");
       exit;
       end;
       end; */
       /* check for the chirality flag */
       if (strlen (rline) > 14 && rline[14] == '1')      /* new in v0.3f */
-        chir_flag = true;
+        chir_flag = istrue;
       n_heavyatoms = 0;
       n_heavybonds = 0;
       n_Ctot = 0;                       /* v0.3g */
       n_Otot = 0;                       /* v0.3g */
       n_Ntot = 0;                       /* v0.3g */
                 real_charge    := 0;
                 Hexp           := 0;
                 Htot           := 0;
                 neighbor_count := 0;
                 ring_count     := 0;
-                arom           := false;
+                arom           := isfalse;
-                stereo_care    := false;
+                stereo_care    := isfalse;
-                metal          := false;
+                metal          := isfalse;
-                heavy          := false;
+                heavy          := isfalse;
-                tag            := false;
+                tag            := isfalse;
                 end;
                 */
                 /* replaced by fillchar() after getmem() (see above); v0.3l */
                 ri++;
                 strcpy (rline, molbuf[ri - 1]);
                 WITH = &atom[v - 1];
                 strcpy (WITH->element, elemstr);
                 if (!strcmp (elemstr, "A ") || !strcmp (elemstr, "Q ") ||
                     !strcmp (elemstr, "X "))
                   /* 'X ' added in v0.3n */
-                  found_querymol = true;
+                  found_querymol = istrue;
                 strcpy (WITH->atype, newatomtype);
                 if (!strcmp (elemstr, "D ")) {
                   strcpy (WITH->element, "H ");
                 WITH->z = zval;
                 WITH->formal_charge = (long) floor (chgval + 0.5);
                 WITH->real_charge = 0.0;        /* v0.3j */
                 /* read aromaticity flag from CheckMol-tweaked MDL molfile */
                 if (strlen (rline) > 37 && rline[37] == '0') {
-                  WITH->arom = true;
+                  WITH->arom = istrue;
-                  found_arominfo = true;
+                  found_arominfo = istrue;
+                }
                 /* new in v0.3d: read stereo care flag */
                 if (strlen (rline) > 47 && rline[47] == '1')
-                  WITH->stereo_care = true;
+                  WITH->stereo_care = istrue;
                 if (is_heavyatom (n)) {
                   n_heavyatoms++;
-                  WITH->heavy = true;
+                  WITH->heavy = istrue;
                   if (is_metal (n))
-                          WITH->metal = true;
+                          WITH->metal = istrue;
+                }
                 WITH->nvalences = get_nvalences (WITH->element);
                 /* v0.3m                 */
+              }
       }                         /* if (n_atoms > 0)... */
                   WITH1->btype = 'd';
                 if (rline[8] == '8')    /* any */
                   WITH1->btype = 'a';
                 sprintf (STR1, "%c", WITH1->btype);
                 if (strpos2 ("lsda", STR1, 1) > 0)
-                  found_querymol = true;
+                  found_querymol = istrue;
-                WITH1->arom = false;
+                WITH1->arom = isfalse;
-                WITH1->q_arom = false;  /* 0.3p */
+                WITH1->q_arom = isfalse;        /* 0.3p */
                 /* read aromaticity flag from CheckMol-tweaked MDL molfile */
                 if (WITH1->btype == 'A' || rline[7] == '0') {
-                  WITH1->arom = true;
+                  WITH1->arom = istrue;
                   if (rline[7] == '0')
-                          found_arominfo = true;
+                          found_arominfo = istrue;
+                }
                 strsub (tmpstr, rline, 13, 3);
                 /* new in v0.3d: read ring_count from tweaked molfile */
                 code = (sscanf (tmpstr, "%d", &rc) == 0);
                 if (code != 0 || rc < 0 || progmode == pmCheckMol || tmfmismatch)
           WITH1->stereo = bstereo_any;
           if (WITH1->btype == 'D') {
             if (atom[WITH1->a1 - 1].stereo_care
                 && atom[WITH1->a2 - 1].stereo_care) {           /* this is the MDL-conformant encoding, */
               WITH1->stereo = bstereo_xyz;      /* for an alternative see below */
-              ez_flag = true;   /* v0.3f */
+              ez_flag = istrue; /* v0.3f */
+            }
                   else {                /* this extended feature is encoded by a leading zero */
                           strsub (tmpstr, rline, 10, 3);
                           /* new in v0.3d: read bond stereo specification; */
                           code = (sscanf (tmpstr, "%d", &bs) == 0);
                             WITH1->stereo = bstereo_xyz;
                           if (tmpstr[1] == '0')
                             WITH1->stereo = bstereo_xyz;
+                        }
+                }
-                /*if stereo <> bstereo_any then ez_search := true; */
+                /*if stereo <> bstereo_any then ez_search := istrue; */
                 if (WITH1->stereo != bstereo_any)       /* changed in v0.3f */
-                  ez_flag = true;
+                  ez_flag = istrue;
                 if (WITH1->btype == 'S' && strlen (rline) > 11 && rline[11] == '1')
                   WITH1->stereo = bstereo_up;
                 if (WITH1->btype == 'S' && strlen (rline) > 11 && rline[11] == '6')
                   WITH1->stereo = bstereo_down;
                 if (WITH1->btype == 'S' && strlen (rline) > 11 && rline[11] == '4')
               for (i = 0; i < n_atoms; i++)
                 atom[i].formal_charge = 0;
+            }
             read_charges (rline);
-            clearcharges = false;
+            clearcharges = isfalse;
             /* subsequent "M  CHG" lines must not clear previous values */
+          }
     if (strpos2 (rline, "M  ISO", 1) > 0)
             read_isotopes (rline);      /* 0.3x */
             read_radicals (rline);      /* 0.3x */
     if (strpos2 (rline, "$$$$", 1) > 0) {
             sepcount++;
             if (molbufindex > ri + 2)   /* we assume this is an SDF file */
-              mol_in_queue = true;
+              mol_in_queue = istrue;
+          }
+  }
   memset (ring, 0, sizeof (ringlist));
   for (n = 0; n < max_rings; n++) {                             /* new in v0.3 */
     ringprop[n].size = 0;
-    ringprop[n].arom = false;
+    ringprop[n].arom = isfalse;
-    ringprop[n].envelope = false;
+    ringprop[n].envelope = isfalse;
+  }
   li = ri + 1;
+}
 static void write_MDLmolfile ()
 /*============= chemical processing functions && procedures ============ */
 static boolean is_electroneg (char *a_el)
+{
   /* new in v0.3j */
-  boolean res = false;
+  boolean res = isfalse;
   if (!strcmp (a_el, "N "))
-    res = true;
+    res = istrue;
   if (!strcmp (a_el, "P "))
-    res = true;
+    res = istrue;
   if (!strcmp (a_el, "O "))
-    res = true;
+    res = istrue;
   if (!strcmp (a_el, "S "))
-    res = true;
+    res = istrue;
   if (!strcmp (a_el, "SE"))
-    res = true;
+    res = istrue;
   if (!strcmp (a_el, "TE"))
-    res = true;
+    res = istrue;
   if (!strcmp (a_el, "F "))
-    res = true;
+    res = istrue;
   if (!strcmp (a_el, "CL"))
-    res = true;
+    res = istrue;
   if (!strcmp (a_el, "BR"))
-    res = true;
+    res = istrue;
   if (!strcmp (a_el, "I "))
-    res = true;
+    res = istrue;
   if (!strcmp (a_el, "AT"))
-    res = true;
+    res = istrue;
   return res;
+}
 static void count_neighbors ()
+{
     if (!strcmp (atom[bond[i].a2 - 1].element, "H "))
             atom[bond[i].a1 - 1].Hexp++;
     /* plausibility check (new in v02.i) */
     if (atom[bond[i].a1 - 1].neighbor_count > max_neighbors ||
               atom[bond[i].a2 - 1].neighbor_count > max_neighbors) {
-            mol_OK = false;
+            mol_OK = isfalse;
             /*writeln('invalid molecule!'); */
+          }
+  }
+}
+}
 static boolean rc_identical (int rc_int)
+{
   if (rc_int == 0)
-    return true;
+    return istrue;
   else
-    return false;
+    return isfalse;
+}
 static boolean rc_1in2 (int rc_int)
+{
   if (rc_int & 1)
-    return true;
+    return istrue;
   else
-    return false;
+    return isfalse;
+}
 static boolean rc_2in1 (int rc_int)
+{
   rc_int /= 2;
   if (rc_int & 1)
-    return true;
+    return istrue;
   else
-    return false;
+    return isfalse;
+}
 #if 0
 static boolean rc_different (int rc_int)
+{
   rc_int /= 4;
   if (rc_int & 1)
-    return true;
+    return istrue;
   else
-    return false;
+    return isfalse;
+}
 #endif
 #if 0
 static boolean rc_independent (int rc_int)
+{
   rc_int /= 8;
   if (rc_int & 1)
-    return true;
+    return istrue;
   else
-    return false;
+    return isfalse;
+}
 #endif
 static boolean is_newring (int *n_path)
+{
   int i, j;
-  boolean nr = true;
+  boolean nr = istrue;
   boolean same_ring;
   ringpath_type tmp_path;
   int rc_result;
   boolean found_ring;
   int pl;                       /* new in v0.3 */
   int FORLIM;
   pl = path_length (n_path);    /* new in v0.3 */
   if (n_rings <= 0)
-    return true;
+    return istrue;
   switch (ringsearch_mode) {
     case rs_sar:
-      found_ring = false;
+      found_ring = isfalse;
       i = 0;
       while (i < n_rings && !found_ring) {
               i++;
               if (pl != ringprop[i - 1].size)   /* compare only rings of same size */
                 continue;
-              same_ring = true;
+              same_ring = istrue;
               for (j = 0; j < max_ringsize; j++) {
                 if (ring[i - 1][j] != n_path[j])
-                        same_ring = false;
+                        same_ring = isfalse;
+              }
               if (same_ring) {
-                nr = false;
+                nr = isfalse;
-                found_ring = true;
+                found_ring = istrue;
+              }
+            }
       break;
     case rs_ssr:
       for (i = 0; i < FORLIM; i++) {
               for (j = 0; j < max_ringsize; j++)
                 tmp_path[j] = ring[i][j];
               rc_result = ringcompare (n_path, tmp_path);
               if (rc_identical (rc_result))
-                nr = false;
+                nr = isfalse;
               if (rc_1in2 (rc_result)) {
               /* exchange existing ring by smaller one */
                 for (j = 0; j < max_ringsize; j++)
                         ring[i][j] = n_path[j];
                 /* update ring property record (new in v0.3) */
                 ringprop[i].size = pl;
-                nr = false;
+                nr = isfalse;
         /* p2c: checkmol.pas, line 2841:
         * Note: Turbo Pascal conditional compilation directive was ignored [218] */
               /*$IFDEF debug */
               /* debugoutput('replacing ring '+inttostr(i)+' by smaller one (ringsize: '+inttostr(path_length(n_path))+')'); */
               /*$ENDIF */
+        }
         if (rc_2in1 (rc_result)) {
                   /* new ring contains existing one, but is larger ==> discard */
-                nr = false;
+                nr = isfalse;
+              }
+            }
     break;
+  }
   return nr;
 static boolean is_ringpath (s_path) int *s_path;
+   {
    boolean Result;
    int i, j;
    neighbor_rec nb;
-   boolean rp = false;
+   boolean rp = isfalse;
    boolean new_atom;
    int a_last, pl;
    ringpath_type l_path;
    int FORLIM;
      return Result;
+    }
     for (i = 0; i < pl; i++)
       l_path[i] = s_path[i];
     /* check if the last atom is a metal and stop if opt_metalrings is not set (v0.3) */
-    if (opt_metalrings == false) {
+    if (opt_metalrings == isfalse) {
       if (atom[l_path[pl - 1] - 1].metal){
         /* p2c: checkmol.pas, line 2942:
         * Note: Turbo Pascal conditional compilation directive was ignored [218] */
         /*$IFDEF debug
         debugoutput ("skipping metal in ring search");
          $ENDIF */
-        return false;
+        return isfalse;
+      }
+    }
     /* check if ring is already closed */
     if (pl > 2 && l_path[pl - 1] == l_path[0]) {
     l_path[pl - 1] = 0;        /* remove last entry (redundant!) */
         /* p2c: checkmol.pas, line 2958:
         * Note: Turbo Pascal conditional compilation directive was ignored [218] */
         /*$IFDEF debug
         debugoutput ("maximum number of rings exceeded!");
         $ENDIF */
-        return false;
+        return isfalse;
+      }
       add_ring (l_path);
+    }
     /* p2c: checkmol.pas: Note: Eliminated unused assignment statement [338] */
-    return true;
+    return istrue;
+  }
   /* any other case: ring is not (yet) closed */
   a_last = l_path[pl - 1];
   get_neighbors (nb, a_last);
   if (atom[a_last - 1].neighbor_count <= 1)
-    return false;
+    return isfalse;
   if (n_rings >= max_rings)
     /* added in v0.2: check if max_rings is reached **/
   {                          /* if ring is not closed, continue searching */
-    return false;
+    return isfalse;
+  }
   FORLIM = atom[a_last - 1].neighbor_count;
   for (i = 0; i < FORLIM; i++) {
-    new_atom = true;
+    new_atom = istrue;
      for (j = 1; j < pl; j++) {
       if (nb[i] == l_path[j]) {                    /* v0.3k */
-       new_atom = false;
+       new_atom = isfalse;
        /* p2c: checkmol.pas, line 2982:
        * Warning: Expected a '(', found a semicolon [227] */
        /* p2c: checkmol.pas, line 2982:
        * Warning: Expected an expression, found a semicolon [227] */
        fflush (0);
     if (new_atom && pl < max_vringsize && n_rings < max_rings) {
       l_path[pl] = nb[i];
       if (pl < max_ringsize - 1)   /* just to be sure */
       l_path[pl + 1] = 0;
       if (is_ringpath (l_path))
-       rp = true;
+       rp = istrue;
+    }
+  }
   return rp;
+}
 #endif
 static boolean is_ringpath (int *s_path)
+{
   int i, j;
   neighbor_rec nb;
-  boolean rp = false;
+  boolean rp = isfalse;
   boolean new_atom;
   int a_last, pl;
   ringpath_type l_path;
   int FORLIM, pl_prev, pl_next, max_ringsize_dec;
   pl = path_length (s_path);
   if (pl < 1) {
     /* p2c: checkmol.pas, line 2524:
     * Note: Turbo Pascal conditional compilation directive was ignored [218] */
-      return false;
+      return isfalse;
+    }
   pl_prev = pl - 1;
   //memcpy (l_path, s_path, sizeof (ringpath_type));
   memcpy (l_path, s_path, pl * sizeof (int));
   /* check if the last atom is a metal and stop if opt_metalrings is not set (v0.3) */
-  if (opt_metalrings == false) {
+  if (opt_metalrings == isfalse) {
     if (atom[l_path[pl_prev] - 1].metal) {
     /* p2c: checkmol.pas, line 2538:
      * Note: Turbo Pascal conditional compilation directive was ignored [218] */
-          return false;
+          return isfalse;
+          }
+  }
   /* check if ring is already closed */
   if (pl > 2 && l_path[pl_prev] == l_path[0]) {
     l_path[pl_prev] = 0;        /* remove last entry (redundant!) */
     order_ringpath (l_path);
     if (is_newring (l_path)) {
             if (n_rings >= max_rings) {
         /* p2c: checkmol.pas, line 2554:
         * Note: Turbo Pascal conditional compilation directive was ignored [218] */
-              return false;
+              return isfalse;
+            }
             add_ring (l_path);
+          }
     /* p2c: checkmol.pas: Note: Eliminated unused assignment statement [338] */
-      return true;
+      return istrue;
+  }
   /* any other case: ring is not (yet) closed */
   a_last = l_path[pl_prev];
   get_neighbors (nb, a_last);
   if (atom[a_last - 1].neighbor_count <= 1)
-    return false;
+    return isfalse;
   if (n_rings >= max_rings)
     /* added in v0.2: check if max_rings is reached */ {                                /* if ring is not closed, continue searching */
-    return false;
+    return isfalse;
+  }
   FORLIM = atom[a_last - 1].neighbor_count;
   pl_next = pl + 1;
   max_ringsize_dec = max_ringsize - 1;
   for (i = 0; i < FORLIM; i++) {
-    new_atom = true;
+    new_atom = istrue;
     for (j = 1; j < pl; j++) {
             if (nb[i] == l_path[j]) {
-              new_atom = false;
+              new_atom = isfalse;
               break;
+            }
+          }
     /* added in v0.1a: check if max_rings not yet reached */
     /* added in v0.2:  limit ring size to max_vringsize instead of max_ringsize */
               if (opt_verbose)
 #endif
                     printf ("Warning: max. number of ringpath recursions (%i) reached\n",
                     max_ringpath_recursion_depth);
               n_rings = max_rings;
-              return false;
+              return isfalse;
+            }
             /*printf("%i\n",recursion_depth);
             fflush(stdout);*/
             if (is_ringpath (l_path))
-              rp = true;
+              rp = istrue;
-            /*return true;*/
+            /*return istrue;*/
+          }
+  }
   return rp;
+}
 static boolean is_ringbond (int b_id)
+{
   int i, ra1, ra2;
   neighbor_rec nb;
   ringpath_type search_path;
-  boolean rb = false;
+  boolean rb = isfalse;
   int FORLIM;
   recursion_depth = 0;
   ra1 = bond[b_id - 1].a1;
   ra2 = bond[b_id - 1].a2;
   memset (nb, 0, sizeof (neighbor_rec));
   memset (search_path, 0, sizeof (ringpath_type));
   get_neighbors (nb, ra2);
   if (atom[ra2 - 1].neighbor_count <= 1 || atom[ra1 - 1].neighbor_count <= 1)
-    return false;
+    return isfalse;
   search_path[0] = ra1;
   search_path[1] = ra2;
   FORLIM = atom[ra2 - 1].neighbor_count;
   for (i = 0; i < FORLIM; i++) {
     if (nb[i] != ra1 && atom[nb[i] - 1].heavy) {
             search_path[2] = nb[i];
             if (is_ringpath (search_path))
-              rb = true;
+              rb = istrue;
-            //return true;
+            //return istrue;
+          }
+  }
   return rb;
+}
+}
 static boolean is_oxo_C (int id)
+{
   int i;
-  boolean r = false;
+  boolean r = isfalse;
   neighbor_rec nb;
   int FORLIM;
   memset (nb, 0, sizeof (neighbor_rec));
   if (id < 1 || id > n_atoms)
-    return false;
+    return isfalse;
   get_neighbors (nb, id);
   if (strcmp (atom[id - 1].element, "C ") || atom[id - 1].neighbor_count <= 0)
-    return false;
+    return isfalse;
   FORLIM = atom[id - 1].neighbor_count;
   for (i = 0; i < FORLIM; i++) {
     if (bond[get_bond (id, nb[i]) - 1].btype == 'D' &&
               !strcmp (atom[nb[i] - 1].element, "O "))
             /* no N, amidines are different... */
-            r = true;
+            r = istrue;
       /* or
          (atom^[(nb[i])].element = 'S ')  or
          (atom^[(nb[i])].element = 'SE') */
+  }
   return r;
+}
 static boolean is_thioxo_C (int id)
+{
   int i;
-  boolean r = false;
+  boolean r = isfalse;
   neighbor_rec nb;
   int FORLIM;
   memset (nb, 0, sizeof (neighbor_rec));
   if (id < 1 || id > n_atoms)
-    return false;
+    return isfalse;
   get_neighbors (nb, id);
   if (strcmp (atom[id - 1].element, "C ") || atom[id - 1].neighbor_count <= 0)
-    return false;
+    return isfalse;
   FORLIM = atom[id - 1].neighbor_count;
   for (i = 0; i < FORLIM; i++) {
     if (bond[get_bond (id, nb[i]) - 1].btype == 'D' &&
               (!strcmp (atom[nb[i] - 1].element, "S ") ||
               !strcmp (atom[nb[i] - 1].element, "SE")))
             /* no N, amidines are different... */
-          r = true;
+          r = istrue;
+  }
   return r;
+}
 static boolean is_imino_C (int id)
+{
   int i;
-  boolean r = false;
+  boolean r = isfalse;
   neighbor_rec nb;
   int FORLIM;
   memset (nb, 0, sizeof (neighbor_rec));
   if (id < 1 || id > n_atoms)
-    return false;
+    return isfalse;
   get_neighbors (nb, id);
   if (strcmp (atom[id - 1].element, "C ") || atom[id - 1].neighbor_count <= 0)
-    return false;
+    return isfalse;
   FORLIM = atom[id - 1].neighbor_count;
   for (i = 0; i < FORLIM; i++) {
     if (bond[get_bond (id, nb[i]) - 1].btype == 'D' &&
               !strcmp (atom[nb[i] - 1].element, "N "))
-            r = true;
+            r = istrue;
+  }
   return r;
+}
-static boolean is_true_imino_C (int id)
+static boolean is_istrue_imino_C (int id)
+{
   int i;
-  boolean r = true;
+  boolean r = istrue;
   neighbor_rec nb;
   str2 nb_el;
   int a_n = 0;
   int b;                        /* v0.3j */
   int FORLIM;
 /* p2c: checkmol.pas: Note: Eliminated unused assignment statement [338] */
   memset (nb, 0, sizeof (neighbor_rec));
   if (id < 1 || id > n_atoms)
-    return false;
+    return isfalse;
   get_neighbors (nb, id);
   if (strcmp (atom[id - 1].element, "C ") || atom[id - 1].neighbor_count <= 0)
-    return false;
+    return isfalse;
   FORLIM = atom[id - 1].neighbor_count;
   for (i = 0; i < FORLIM; i++) {
     b = get_bond (id, nb[i]);   /* v0.3j */
-    if (bond[b - 1].btype == 'D' && bond[b - 1].arom == false &&
+    if (bond[b - 1].btype == 'D' && bond[b - 1].arom == isfalse &&
               !strcmp (atom[nb[i] - 1].element, "N "))
         /* v0.3j */
             a_n = nb[i];
+  }
   if (a_n <= 0)
-    return false;
+    return isfalse;
   memset (nb, 0, sizeof (neighbor_rec));
   get_neighbors (nb, a_n);
   FORLIM = atom[a_n - 1].neighbor_count;
   for (i = 0; i < FORLIM; i++) {
     strcpy (nb_el, atom[nb[i] - 1].element);
     if (strcmp (nb_el, "C ") && strcmp (nb_el, "H ")
             /*&&  strcmp (nb_el, "D ") */ )
             /* v0.3n: D */
-            r = false;
+            r = isfalse;
+  }
   return r;
+}
-static boolean is_true_exocyclic_imino_C (int id, int r_id)
+static boolean is_istrue_exocyclic_imino_C (int id, int r_id)
+{
   /* v0.3j */
   int i, j;
-  boolean r = false;
+  boolean r = isfalse;
   neighbor_rec nb;
   ringpath_type testring;
   int ring_size, b, FORLIM;
   memset (nb, 0, sizeof (neighbor_rec));
   if (id < 1 || id > n_atoms)
-    return false;
+    return isfalse;
   get_neighbors (nb, id);
   memset (testring, 0, sizeof (ringpath_type));
   ring_size = ringprop[r_id - 1].size;  /* v0.3j */
   for (j = 0; j < ring_size; j++)       /* v0.3j */
     testring[j] = ring[r_id - 1][j];
   if (strcmp (atom[id - 1].element, "C ") || atom[id - 1].neighbor_count <= 0)
-    return false;
+    return isfalse;
   FORLIM = atom[id - 1].neighbor_count;
   for (i = 0; i < FORLIM; i++) {
     b = get_bond (id, nb[i]);
-    if (bond[b - 1].btype == 'D' && bond[b - 1].arom == false &&
+    if (bond[b - 1].btype == 'D' && bond[b - 1].arom == isfalse &&
               !strcmp (atom[nb[i] - 1].element, "N ")) {
-            r = true;
+            r = istrue;
             for (j = 0; j < ring_size; j++) {
               if (nb[i] == ring[r_id - 1][j])
-                      r = false;
+                      r = isfalse;
+            }
+          }
+  }
   return r;
+}
 static boolean is_exocyclic_imino_C (int id, int r_id)
+{
   int i, j;
-  boolean r = false;
+  boolean r = isfalse;
   neighbor_rec nb;
   ringpath_type testring;
   int ring_size, FORLIM;
   memset (nb, 0, sizeof (neighbor_rec));
   if (id < 1 || id > n_atoms)
-    return false;
+    return isfalse;
   get_neighbors (nb, id);
   memset (testring, 0, sizeof (ringpath_type));
   ring_size = ringprop[r_id - 1].size;  /* v0.3j */
   for (j = 0; j < ring_size; j++)       /* v0.3j */
     testring[j] = ring[r_id - 1][j];
   if (strcmp (atom[id - 1].element, "C ") || atom[id - 1].neighbor_count <= 0)
-    return false;
+    return isfalse;
   FORLIM = atom[id - 1].neighbor_count;
   for (i = 0; i < FORLIM; i++) {
     if (bond[get_bond (id, nb[i]) - 1].btype == 'D' &&
               !strcmp (atom[nb[i] - 1].element, "N ")) {
-            r = true;
+            r = istrue;
             for (j = 0; j < ring_size; j++) {
               if (nb[i] == ring[r_id - 1][j])
-                      r = false;
+                      r = isfalse;
+            }
+          }
+  }
   return r;
+}
   return r;
+}
 static boolean is_hydroxy (int a_view, int a_ref)
+{
-  boolean r = false;
+  boolean r = isfalse;
   if (atom[a_view - 1]. heavy && (bond[get_bond (a_view, a_ref) - 1].btype == 'S')) {
     if (!strcmp (atom[a_ref - 1].atype, "O3 ") &&
               atom[a_ref - 1].neighbor_count == 1)
-            r = true;
+            r = istrue;
+  }
   return r;
+}
 static boolean is_sulfanyl (int a_view, int a_ref)
+{
-  boolean r = false;
+  boolean r = isfalse;
   if (atom[a_view - 1].
       heavy && (bond[get_bond (a_view, a_ref) - 1].btype == 'S')) {
     if (!strcmp (atom[a_ref - 1].atype, "S3 ") &&
               atom[a_ref - 1].neighbor_count == 1)
-            r = true;
+            r = istrue;
+  }
   return r;
+}
 static boolean is_amino (int a_view, int a_ref)
+{
-  boolean r = false;
+  boolean r = isfalse;
   if (atom[a_view - 1].
       heavy && (bond[get_bond (a_view, a_ref) - 1].btype == 'S')) {
     if ((!strcmp (atom[a_ref - 1].atype, "N3 ") ||
               !strcmp (atom[a_ref - 1].atype, "N3+")) &&
               atom[a_ref - 1].neighbor_count == 1)
-            r = true;
+            r = istrue;
+    }
   return r;
+}
 static boolean is_alkyl (int a_view, int a_ref)
+{
   int i;
-  boolean r = false;
+  boolean r = isfalse;
   neighbor_rec nb;
   str2 nb_el;
   int het_count = 0;
   int FORLIM;
   memset (nb, 0, sizeof (neighbor_rec));
   if (! (atom[a_view - 1].
       heavy && (bond[get_bond (a_view, a_ref) - 1].btype == 'S'))
       || strcmp (atom[a_ref - 1].atype, "C3 ")
-      || atom[a_ref - 1].arom != false)
+      || atom[a_ref - 1].arom != isfalse)
-    return false;
+    return isfalse;
   get_nextneighbors (nb, a_ref, a_view);
   FORLIM = atom[a_ref - 1].neighbor_count - 2;
   for (i = 0; i <= FORLIM; i++) {
     strcpy (nb_el, atom[nb[i] - 1].element);
     if (strcmp (nb_el, "C ") && strcmp (nb_el, "H ")
               && strcmp (nb_el, "LP"))
             /* added 'D ' in v0.3n */
             het_count++;
+  }
   if (het_count <= 1)           /* we consider (e.g.) alkoxyalkyl groups as alkyl */
-    r = true;
+    r = istrue;
   return r;
+}
-static boolean is_true_alkyl (int a_view, int a_ref)
+static boolean is_istrue_alkyl (int a_view, int a_ref)
+{
   int i;
-  boolean r = false;
+  boolean r = isfalse;
   neighbor_rec nb;
   str2 nb_el;
   int het_count = 0;
   int FORLIM;
   memset (nb, 0, sizeof (neighbor_rec));
   if (!(atom[a_view - 1].
        heavy && (bond[get_bond (a_view, a_ref) - 1].btype == 'S'))
       || strcmp (atom[a_ref - 1].atype, "C3 ")
-      || atom[a_ref - 1].arom != false)
+      || atom[a_ref - 1].arom != isfalse)
-    return false;
+    return isfalse;
   get_nextneighbors (nb, a_ref, a_view);
   FORLIM = atom[a_ref - 1].neighbor_count - 2;
   for (i = 0; i <= FORLIM; i++) {
     strcpy (nb_el, atom[nb[i] - 1].element);
     if (strcmp (nb_el, "C ") && strcmp (nb_el, "H ")
              /*&&  strcmp (nb_el, "D ") */  && strcmp (nb_el, "DU"))
              /* added 'D ' in v0.3n */
              het_count++;
+  }
   if (het_count == 0)           /* */
-    r = true;
+    r = istrue;
   return r;
+}
 static boolean is_alkenyl (int a_view, int a_ref)
+{
   /* new in v0.3j */
   int i;
-  boolean r = false;
+  boolean r = isfalse;
   neighbor_rec nb;
   str2 nb_el;
   str3 nb_at;
   int c2_count = 0, het_count = 0;
   int FORLIM;
   memset (nb, 0, sizeof (neighbor_rec));
   if (! (atom[a_view - 1].
        heavy && (bond[get_bond (a_view, a_ref) - 1].btype == 'S'))
       || strcmp (atom[a_ref - 1].atype, "C2 ")
-      || atom[a_ref - 1].arom != false) {
+      || atom[a_ref - 1].arom != isfalse) {
-    return false;
+    return isfalse;
   }                             /* v0.3k: changed c2_count = 1 into c2_count >= 1 */
   get_nextneighbors (nb, a_ref, a_view);
   FORLIM = atom[a_ref - 1].neighbor_count - 2;
   for (i = 0; i <= FORLIM; i++) {
     strcpy (nb_el, atom[nb[i] - 1].element);
     if (!strcmp (nb_at, "C2 "))
             c2_count++;
+  }
   if (c2_count >= 1 && het_count <= 1)
     /* we consider (e.g.) alkoxyalkenyl groups as alkenyl */
-    r = true;
+    r = istrue;
   return r;
+}
 static boolean is_alkynyl (int a_view, int a_ref)
+{
   /* new in v0.3j */
   int i;
-  boolean r = false;
+  boolean r = isfalse;
   neighbor_rec nb;
   str3 nb_at;
   int c1_count = 0;
   int FORLIM;
   memset (nb, 0, sizeof (neighbor_rec));
   if (!(atom[a_view - 1].
        heavy && (bond[get_bond (a_view, a_ref) - 1].btype == 'S'))
       || strcmp (atom[a_ref - 1].atype, "C1 ")
-      || atom[a_ref - 1].arom != false)
+      || atom[a_ref - 1].arom != isfalse)
-    return false;
+    return isfalse;
   get_nextneighbors (nb, a_ref, a_view);
   FORLIM = atom[a_ref - 1].neighbor_count - 2;
   for (i = 0; i <= FORLIM; i++) {
     strcpy (nb_at, atom[nb[i] - 1].atype);
     if (!strcmp (nb_at, "C1 "))
             c1_count++;
+  }
   if (c1_count == 1)
-    r = true;
+    r = istrue;
   return r;
+}
 static boolean is_aryl (int a_view, int a_ref)
+{
-  boolean r = false;
+  boolean r = isfalse;
   if ((atom[a_view - 1].
        heavy && (bond[get_bond (a_view, a_ref) - 1].btype == 'S'))
       && !strcmp (atom[a_ref - 1].element, "C ")
-      && atom[a_ref - 1].arom == true)
+      && atom[a_ref - 1].arom == istrue)
-    r = true;
+    r = istrue;
   return r;
+}
 static boolean is_alkoxy (int a_view, int a_ref)
+{
-  boolean r = false;
+  boolean r = isfalse;
   neighbor_rec nb;
   memset (nb, 0, sizeof (neighbor_rec));
   if (!(atom[a_view - 1].
        heavy && (bond[get_bond (a_view, a_ref) - 1].btype == 'S')))
-    return false;
+    return isfalse;
   if (strcmp (atom[a_ref - 1].atype, "O3 ")
       || atom[a_ref - 1].neighbor_count != 2)
-    return false;
+    return isfalse;
   get_nextneighbors (nb, a_ref, a_view);
   if (is_alkyl (a_ref, nb[0]))
-    r = true;
+    r = istrue;
   return r;
+}
 static boolean is_siloxy (int a_view, int a_ref)
+{
-  boolean r = false;
+  boolean r = isfalse;
   neighbor_rec nb;
   memset (nb, 0, sizeof (neighbor_rec));
   if (!(atom[a_view - 1].
        heavy && (bond[get_bond (a_view, a_ref) - 1].btype == 'S')))
-    return false;
+    return isfalse;
   if (strcmp (atom[a_ref - 1].atype, "O3 ")
       || atom[a_ref - 1].neighbor_count != 2)
-    return false;
+    return isfalse;
   get_nextneighbors (nb, a_ref, a_view);
   if (!strcmp (atom[nb[0] - 1].element, "SI"))
-    r = true;
+    r = istrue;
   return r;
+}
-static boolean is_true_alkoxy (int a_view, int a_ref)
+static boolean is_istrue_alkoxy (int a_view, int a_ref)
+{
-  boolean r = false;
+  boolean r = isfalse;
   neighbor_rec nb;
   memset (nb, 0, sizeof (neighbor_rec));
   if (!(atom[a_view - 1].
        heavy && (bond[get_bond (a_view, a_ref) - 1].btype == 'S')))
-    return false;
+    return isfalse;
   if (strcmp (atom[a_ref - 1].atype, "O3 ")
       || atom[a_ref - 1].neighbor_count != 2)
-    return false;
+    return isfalse;
   get_nextneighbors (nb, a_ref, a_view);
-  if (is_true_alkyl (a_ref, nb[0]))
+  if (is_istrue_alkyl (a_ref, nb[0]))
-    r = true;
+    r = istrue;
   return r;
+}
 static boolean is_aryloxy (int a_view, int a_ref)
+{
-  boolean r = false;
+  boolean r = isfalse;
   neighbor_rec nb;
   memset (nb, 0, sizeof (neighbor_rec));
   if (!(atom[a_view - 1].
        heavy && (bond[get_bond (a_view, a_ref) - 1].btype == 'S')))
-    return false;
+    return isfalse;
   if (strcmp (atom[a_ref - 1].atype, "O3 ")
       || atom[a_ref - 1].neighbor_count != 2)
-    return false;
+    return isfalse;
   get_nextneighbors (nb, a_ref, a_view);
   if (is_aryl (a_ref, nb[0]))
-    r = true;
+    r = istrue;
   return r;
+}
 static boolean is_alkenyloxy (int a_view, int a_ref) {
   /* v0.3j */
-  boolean r = false;
+  boolean r = isfalse;
   neighbor_rec nb;
   memset (nb, 0, sizeof (neighbor_rec));
   if (!(atom[a_view - 1].
        heavy && (bond[get_bond (a_view, a_ref) - 1].btype == 'S')))
-    return false;
+    return isfalse;
   if (strcmp (atom[a_ref - 1].atype, "O3 ")
       || atom[a_ref - 1].neighbor_count != 2)
-    return false;
+    return isfalse;
   get_nextneighbors (nb, a_ref, a_view);
   if (is_alkenyl (a_ref, nb[0]))
-    r = true;
+    r = istrue;
   return r;
+}
 static boolean is_alkynyloxy (int a_view, int a_ref)
+{
   /* v0.3j */
-  boolean r = false;
+  boolean r = isfalse;
   neighbor_rec nb;
   memset (nb, 0, sizeof (neighbor_rec));
   if (!(atom[a_view - 1].
        heavy && (bond[get_bond (a_view, a_ref) - 1].btype == 'S')))
-    return false;
+    return isfalse;
   if (strcmp (atom[a_ref - 1].atype, "O3 ")
       || atom[a_ref - 1].neighbor_count != 2)
-    return false;
+    return isfalse;
   get_nextneighbors (nb, a_ref, a_view);
   if (is_alkynyl (a_ref, nb[0]))
-    r = true;
+    r = istrue;
   return r;
+}
 static boolean is_alkylsulfanyl (int a_view, int a_ref)
+{
-  boolean r = false;
+  boolean r = isfalse;
   neighbor_rec nb;
   memset (nb, 0, sizeof (neighbor_rec));
   if (!(atom[a_view - 1].
        heavy && (bond[get_bond (a_view, a_ref) - 1].btype == 'S')))
-    return false;
+    return isfalse;
   if (strcmp (atom[a_ref - 1].atype, "S3 ")
       || atom[a_ref - 1].neighbor_count != 2)
-    return false;
+    return isfalse;
   get_nextneighbors (nb, a_ref, a_view);
   if (is_alkyl (a_ref, nb[0]))
-    r = true;
+    r = istrue;
   return r;
+}
-static boolean is_true_alkylsulfanyl (int a_view, int a_ref)
+static boolean is_istrue_alkylsulfanyl (int a_view, int a_ref)
+{
-  boolean r = false;
+  boolean r = isfalse;
   neighbor_rec nb;
   memset (nb, 0, sizeof (neighbor_rec));
   if (!(atom[a_view - 1].
        heavy && (bond[get_bond (a_view, a_ref) - 1].btype == 'S')))
-    return false;
+    return isfalse;
   if (strcmp (atom[a_ref - 1].atype, "S3 ")
       || atom[a_ref - 1].neighbor_count != 2)
-    return false;
+    return isfalse;
   get_nextneighbors (nb, a_ref, a_view);
-  if (is_true_alkyl (a_ref, nb[0]))
+  if (is_istrue_alkyl (a_ref, nb[0]))
-    r = true;
+    r = istrue;
   return r;
+}
 static boolean is_arylsulfanyl (int a_view, int a_ref)
+{
-  boolean r = false;
+  boolean r = isfalse;
   neighbor_rec nb;
   memset (nb, 0, sizeof (neighbor_rec));
   if (!(atom[a_view - 1].
        heavy && (bond[get_bond (a_view, a_ref) - 1].btype == 'S')))
-    return false;
+    return isfalse;
   if (strcmp (atom[a_ref - 1].atype, "S3 ")
       || atom[a_ref - 1].neighbor_count != 2)
-    return false;
+    return isfalse;
   get_nextneighbors (nb, a_ref, a_view);
   if (is_aryl (a_ref, nb[0]))
-    r = true;
+    r = istrue;
   return r;
+}
 static boolean is_alkenylsulfanyl (int a_view, int a_ref)
+{
   /* v0.3j */
-  boolean r = false;
+  boolean r = isfalse;
   neighbor_rec nb;
   memset (nb, 0, sizeof (neighbor_rec));
   if (!(atom[a_view - 1].
        heavy && (bond[get_bond (a_view, a_ref) - 1].btype == 'S')))
-    return false;
+    return isfalse;
   if (strcmp (atom[a_ref - 1].atype, "S3 ")
       || atom[a_ref - 1].neighbor_count != 2)
-    return false;
+    return isfalse;
   get_nextneighbors (nb, a_ref, a_view);
   if (is_alkenyl (a_ref, nb[0]))
-    r = true;
+    r = istrue;
   return r;
+}
 static boolean is_alkynylsulfanyl (int a_view, int a_ref)
+{
   /* v0.3j */
-  boolean r = false;
+  boolean r = isfalse;
   neighbor_rec nb;
   memset (nb, 0, sizeof (neighbor_rec));
   if (!(atom[a_view - 1].
        heavy && (bond[get_bond (a_view, a_ref) - 1].btype == 'S')))
-    return false;
+    return isfalse;
   if (strcmp (atom[a_ref - 1].atype, "S3 ")
       || atom[a_ref - 1].neighbor_count != 2)
-    return false;
+    return isfalse;
   get_nextneighbors (nb, a_ref, a_view);
   if (is_alkynyl (a_ref, nb[0]))
-    r = true;
+    r = istrue;
   return r;
+}
 static boolean is_alkylamino (int a_view, int a_ref)
+{
-  boolean r = false;
+  boolean r = isfalse;
   neighbor_rec nb;
   int alkyl_count = 0;
   memset (nb, 0, sizeof (neighbor_rec));
   if (!(atom[a_view - 1].
        heavy && (bond[get_bond (a_view, a_ref) - 1].btype == 'S')))
-    return false;
+    return isfalse;
   if (strcmp (atom[a_ref - 1].element, "N ")
       || atom[a_ref - 1].neighbor_count != 2)
-    return false;
+    return isfalse;
   get_nextneighbors (nb, a_ref, a_view);
   if (is_alkyl (a_ref, nb[0]))
     alkyl_count++;
   if (alkyl_count == 1)
-    r = true;
+    r = istrue;
   return r;
+}
 static boolean is_dialkylamino (int a_view, int a_ref)
+{
   int i;
-  boolean r = false;
+  boolean r = isfalse;
   neighbor_rec nb;
   int alkyl_count = 0;
   memset (nb, 0, sizeof (neighbor_rec));
   if (!(atom[a_view - 1].
        heavy && (bond[get_bond (a_view, a_ref) - 1].btype == 'S')))
-    return false;
+    return isfalse;
   if (strcmp (atom[a_ref - 1].element, "N ")
       || atom[a_ref - 1].neighbor_count != 3)
-    return false;
+    return isfalse;
   get_nextneighbors (nb, a_ref, a_view);
   for (i = 0; i <= 1; i++) {
     if (is_alkyl (a_ref, nb[i]))
             alkyl_count++;
+  }
   if (alkyl_count == 2)
-    r = true;
+    r = istrue;
   return r;
+}
 static boolean is_arylamino (int a_view, int a_ref)
+{
-  boolean r = false;
+  boolean r = isfalse;
   neighbor_rec nb;
   int aryl_count = 0;
   memset (nb, 0, sizeof (neighbor_rec));
   if (!(atom[a_view - 1].
        heavy && (bond[get_bond (a_view, a_ref) - 1].btype == 'S')))
-    return false;
+    return isfalse;
   if (strcmp (atom[a_ref - 1].element, "N ")
       || atom[a_ref - 1].neighbor_count != 2)
-    return false;
+    return isfalse;
   get_nextneighbors (nb, a_ref, a_view);
   if (is_aryl (a_ref, nb[0]))
     aryl_count++;
   if (aryl_count == 1)
-    r = true;
+    r = istrue;
   return r;
+}
 static boolean is_diarylamino (int a_view, int a_ref)
+{
   int i;
-  boolean r = false;
+  boolean r = isfalse;
   neighbor_rec nb;
   int aryl_count = 0;
   memset (nb, 0, sizeof (neighbor_rec));
   if (!(atom[a_view - 1].
        heavy && (bond[get_bond (a_view, a_ref) - 1].btype == 'S')))
-    return false;
+    return isfalse;
   if (strcmp (atom[a_ref - 1].element, "N ")
       || atom[a_ref - 1].neighbor_count != 3)
-    return false;
+    return isfalse;
   get_nextneighbors (nb, a_ref, a_view);
   for (i = 0; i <= 1; i++) {
     if (is_aryl (a_ref, nb[i]))
             aryl_count++;
+  }
   if (aryl_count == 2)
-    r = true;
+    r = istrue;
   return r;
+}
 static boolean is_alkylarylamino (int a_view, int a_ref)
+{
   int i;
-  boolean r = false;
+  boolean r = isfalse;
   neighbor_rec nb;
   int alkyl_count = 0, aryl_count = 0;
   memset (nb, 0, sizeof (neighbor_rec));
   if (!(atom[a_view - 1].
        heavy && (bond[get_bond (a_view, a_ref) - 1].btype == 'S')))
-    return false;
+    return isfalse;
   if (strcmp (atom[a_ref - 1].element, "N ")
       || atom[a_ref - 1].neighbor_count != 3)
-    return false;
+    return isfalse;
   get_nextneighbors (nb, a_ref, a_view);
   for (i = 0; i <= 1; i++) {
     if (is_alkyl (a_ref, nb[i]))
             alkyl_count++;
     if (is_aryl (a_ref, nb[i]))
             aryl_count++;
+  }
   if (alkyl_count == 1 && aryl_count == 1)
-    r = true;
+    r = istrue;
   return r;
+}
 static boolean is_C_monosubst_amino (int a_view, int a_ref)
+{
   /* new in v0.3j */
-  boolean r = false;
+  boolean r = isfalse;
   neighbor_rec nb;
   int c_count = 0;
   memset (nb, 0, sizeof (neighbor_rec));
   if (! (atom[a_view - 1].
        heavy && (bond[get_bond (a_view, a_ref) - 1].btype == 'S')))
-    return false;
+    return isfalse;
   if ((strcmp (atom[a_ref - 1].atype, "N3 ")
       && strcmp (atom[a_ref - 1].atype, "NAM"))
       || atom[a_ref - 1].neighbor_count != 2)
-    return false;
+    return isfalse;
   get_nextneighbors (nb, a_ref, a_view);
   if (!strcmp (atom[nb[0] - 1].element, "C "))
     c_count++;
   if (c_count == 1)
-    r = true;
+    r = istrue;
   return r;
+}
 static boolean is_C_disubst_amino (int a_view, int a_ref)
+{
   /* new in v0.3j */
   int i;
-  boolean r = false;
+  boolean r = isfalse;
   neighbor_rec nb;
   int b;
   int c_count = 0;
   b = get_bond (a_view, a_ref);
   memset (nb, 0, sizeof (neighbor_rec));
   if (!(atom[a_view - 1].heavy && bond[b - 1].btype == 'S' &&
-            bond[b - 1].arom == false))
+            bond[b - 1].arom == isfalse))
-    return false;
+    return isfalse;
   if ((strcmp (atom[a_ref - 1].atype, "N3 ")
       && strcmp (atom[a_ref - 1].atype, "NAM"))
       || atom[a_ref - 1].neighbor_count != 3)
-    return false;
+    return isfalse;
   get_nextneighbors (nb, a_ref, a_view);
   for (i = 0; i <= 1; i++) {
     if (!strcmp (atom[nb[i] - 1].element, "C "))
             c_count++;
+  }
   if (c_count == 2)
-    r = true;
+    r = istrue;
   return r;
+}
 static boolean is_subst_amino (int a_view, int a_ref)
+{
-  boolean r = false;
+  boolean r = isfalse;
   if (is_amino (a_view, a_ref) || is_alkylamino (a_view, a_ref) |
       is_arylamino (a_view, a_ref) || is_dialkylamino (a_view, a_ref) |
       is_alkylarylamino (a_view, a_ref) || is_diarylamino (a_view, a_ref))
-    r = true;
+    r = istrue;
   return r;
+}
-static boolean is_true_alkylamino (int a_view, int a_ref)
+static boolean is_istrue_alkylamino (int a_view, int a_ref)
+{
-  boolean r = false;
+  boolean r = isfalse;
   neighbor_rec nb;
   int alkyl_count = 0;
   memset (nb, 0, sizeof (neighbor_rec));
   if (!(atom[a_view - 1].
        heavy && (bond[get_bond (a_view, a_ref) - 1].btype == 'S')))
-    return false;
+    return isfalse;
   if ((strcmp (atom[a_ref - 1].atype, "N3 ")
       && strcmp (atom[a_ref - 1].atype, "N3+"))
       || atom[a_ref - 1].neighbor_count != 2)
-    return false;
+    return isfalse;
   get_nextneighbors (nb, a_ref, a_view);
-  if (is_true_alkyl (a_ref, nb[0]))
+  if (is_istrue_alkyl (a_ref, nb[0]))
     alkyl_count++;
   if (alkyl_count == 1)
-    r = true;
+    r = istrue;
   return r;
+}
-static boolean is_true_dialkylamino (int a_view, int a_ref)
+static boolean is_istrue_dialkylamino (int a_view, int a_ref)
+{
   int i;
-  boolean r = false;
+  boolean r = isfalse;
   neighbor_rec nb;
   int alkyl_count = 0;
   memset (nb, 0, sizeof (neighbor_rec));
   if (!(atom[a_view - 1].
        heavy && (bond[get_bond (a_view, a_ref) - 1].btype == 'S')))
-    return false;
+    return isfalse;
   if ((strcmp (atom[a_ref - 1].atype, "N3 ")
       && strcmp (atom[a_ref - 1].atype, "N3+"))
       || atom[a_ref - 1].neighbor_count != 3)
-    return false;
+    return isfalse;
   get_nextneighbors (nb, a_ref, a_view);
   for (i = 0; i <= 1; i++) {
-    if (is_true_alkyl (a_ref, nb[i]))
+    if (is_istrue_alkyl (a_ref, nb[i]))
             alkyl_count++;
+  }
   if (alkyl_count == 2)
-    r = true;
+    r = istrue;
   return r;
+}
 #if 0
-static boolean is_true_alkylarylamino (int a_view, int a_ref)
+static boolean is_istrue_alkylarylamino (int a_view, int a_ref)
+{
   int i;
-  boolean r = false;
+  boolean r = isfalse;
   neighbor_rec nb;
   int alkyl_count = 0, aryl_count = 0;
   memset (nb, 0, sizeof (neighbor_rec));
   if (!(atom[a_view - 1].
        heavy && (bond[get_bond (a_view, a_ref) - 1].btype == 'S')))
-    return false;
+    return isfalse;
   if ((strcmp (atom[a_ref - 1].atype, "N3 ")
       && strcmp (atom[a_ref - 1].atype, "N3+"))
       || atom[a_ref - 1].neighbor_count != 3)
-    return false;
+    return isfalse;
   get_nextneighbors (nb, a_ref, a_view);
   for (i = 0; i <= 1; i++) {
-    if (is_true_alkyl (a_ref, nb[i]))
+    if (is_istrue_alkyl (a_ref, nb[i]))
             alkyl_count++;
     if (is_aryl (a_ref, nb[i]))
             aryl_count++;
+  }
   if (alkyl_count == 1 && aryl_count == 1)
-    r = true;
+    r = istrue;
   return r;
+}
 #endif
 static boolean is_hydroxylamino (int a_view, int a_ref)
+{
   int i;
-  boolean r = false;
+  boolean r = isfalse;
   neighbor_rec nb;
   int oh_count = 0, het_count = 0;      /* v0.3k */
   str2 nb_el;                   /* v0.3k */
   int FORLIM;
   memset (nb, 0, sizeof (neighbor_rec));
   if (!(atom[a_view - 1].
        heavy && (bond[get_bond (a_view, a_ref) - 1].btype == 'S')))
-    return false;
+    return isfalse;
   if (strcmp (atom[a_ref - 1].element, "N ")
       || atom[a_ref - 1].neighbor_count < 2)
     /* v0.3c */
-    return false;
+    return isfalse;
   get_nextneighbors (nb, a_ref, a_view);
   FORLIM = atom[a_ref - 1].neighbor_count - 2;
   for (i = 0; i <= FORLIM; i++) {                               /* v0.3c */
     if (is_hydroxy (a_ref, nb[i]))
             oh_count++;
               /* v0.3k */
             het_count++;
       /* v0.3n: D */
+  }
   if (oh_count == 1 && het_count == 1)
-    r = true;
+    r = istrue;
   return r;
+}
 static boolean is_nitro (int a_view, int a_ref)
+{
   int i;
-  boolean r = false;
+  boolean r = isfalse;
   neighbor_rec nb;
   int o_count = 0, bond_count = 0;
   memset (nb, 0, sizeof (neighbor_rec));
   if (!(atom[a_view - 1].
        heavy && (bond[get_bond (a_view, a_ref) - 1].btype == 'S')))
-    return false;
+    return isfalse;
   if (strcmp (atom[a_ref - 1].element, "N ")
       || atom[a_ref - 1].neighbor_count != 3)
-    return false;
+    return isfalse;
   get_nextneighbors (nb, a_ref, a_view);
   for (i = 0; i <= 1; i++) {
     if (!strcmp (atom[nb[i] - 1].element, "O "))
             o_count++;
     if (bond[get_bond (a_ref, nb[i]) - 1].btype == 'S')
             bond_count++;
     if (bond[get_bond (a_ref, nb[i]) - 1].btype == 'D')
             bond_count += 2;
+  }
   if (o_count == 2 && bond_count >= 3)
-    r = true;
+    r = istrue;
   return r;
+}
 static boolean is_azido (int a_view, int a_ref)
+{
-  boolean r = false;
+  boolean r = isfalse;
   neighbor_rec nb;
   int bond_count = 0, n1 = 0, n2 = 0, n3 = 0;
   if (!(atom[a_view - 1].
        heavy && (bond[get_bond (a_view, a_ref) - 1].btype == 'S')))
-    return false;
+    return isfalse;
   if (strcmp (atom[a_ref - 1].element, "N ")
       || atom[a_ref - 1].neighbor_count != 2)
-    return false;
+    return isfalse;
   n1 = a_ref;
   memset (nb, 0, sizeof (neighbor_rec));
   get_nextneighbors (nb, n1, a_view);
   if (!strcmp (atom[nb[0] - 1].element, "N ")) {
     n2 = nb[0];
               bond_count += 3;
+          }
+  }
   if (n1 > 0 && n2 > 0 && n3 > 0 && atom[n3 - 1].neighbor_count == 1 &&
       bond_count > 3)
-    r = true;
+    r = istrue;
   return r;
+}
 static boolean is_diazonium (int a_view, int a_ref)
+{
-  boolean r = false;
+  boolean r = isfalse;
   neighbor_rec nb;
   int bond_count = 0, chg_count = 0, n1 = 0, n2 = 0;
   if (!(atom[a_view - 1].
        heavy && (bond[get_bond (a_view, a_ref) - 1].btype == 'S')))
-    return false;
+    return isfalse;
   if (strcmp (atom[a_ref - 1].element, "N ")
       || atom[a_ref - 1].neighbor_count != 2)
-    return false;
+    return isfalse;
   n1 = a_ref;
   chg_count = atom[n1 - 1].formal_charge;
   memset (nb, 0, sizeof (neighbor_rec));
   get_nextneighbors (nb, n1, a_view);
   if (!strcmp (atom[nb[0] - 1].element, "N ")) {
     if (bond[get_bond (n1, n2) - 1].btype == 'T')
             bond_count += 3;
+  }
   if (n1 > 0 && n2 > 0 && atom[n2 - 1].neighbor_count == 1
       && bond_count >= 2 && chg_count > 0)
-    r = true;
+    r = istrue;
   return r;
+}
 static boolean is_hydroximino_C (int id)
+{
   int i;
-  boolean r = false;
+  boolean r = isfalse;
   neighbor_rec nb;
   int a_het = 0;
   int FORLIM;
   memset (nb, 0, sizeof (neighbor_rec));
   if (id < 1 || id > n_atoms)
-    return false;
+    return isfalse;
   get_neighbors (nb, id);
   if (strcmp (atom[id - 1].element, "C ") || atom[id - 1].neighbor_count <= 0)
-    return false;
+    return isfalse;
   FORLIM = atom[id - 1].neighbor_count;
   for (i = 0; i < FORLIM; i++) {
     if ((bond[get_bond (id, nb[i]) - 1].btype == 'D' &&
               !strcmp (atom[nb[i] - 1].element, "N ")) && (hetbond_count (nb[i]) == 3))
             a_het = nb[i];
+  }
   if (a_het <= 0)
-    return false;
+    return isfalse;
   memset (nb, 0, sizeof (neighbor_rec));
   get_neighbors (nb, a_het);
   if (strcmp (atom[a_het - 1].element, "N ")
       || atom[a_het - 1].neighbor_count <= 0)
-    return false;
+    return isfalse;
   FORLIM = atom[a_het - 1].neighbor_count;
   for (i = 0; i < FORLIM; i++) {
     if (is_hydroxy (a_het, nb[i]))
-          r = true;
+          r = istrue;
+  }
   return r;
+}
 static boolean is_hydrazono_C (int id)
+{
   int i;
-  boolean r = false;
+  boolean r = isfalse;
   neighbor_rec nb;
   int a_het = 0;
   int FORLIM;
   memset (nb, 0, sizeof (neighbor_rec));
   if (id < 1 || id > n_atoms)
-    return false;
+    return isfalse;
   get_neighbors (nb, id);
   if (strcmp (atom[id - 1].element, "C ") || atom[id - 1].neighbor_count <= 0)
-    return false;
+    return isfalse;
   FORLIM = atom[id - 1].neighbor_count;
   for (i = 0; i < FORLIM; i++) {
     if (bond[get_bond (id, nb[i]) - 1].btype == 'D' &&
               !strcmp (atom[nb[i] - 1].element, "N ")) {
           /* and
              (hetbond_count(nb[i]) = 3)  */
           a_het = nb[i];
+          }
+  }
   if (a_het <= 0)
-    return false;
+    return isfalse;
   memset (nb, 0, sizeof (neighbor_rec));
   get_neighbors (nb, a_het);
   if (strcmp (atom[a_het - 1].element, "N ")
       || atom[a_het - 1].neighbor_count <= 0)
-    return false;
+    return isfalse;
   FORLIM = atom[a_het - 1].neighbor_count;
   for (i = 0; i < FORLIM; i++) {
     if (is_amino (a_het, nb[i]) || is_alkylamino (a_het, nb[i]) |
               is_alkylarylamino (a_het, nb[i]) || is_arylamino (a_het, nb[i]) |
               is_dialkylamino (a_het, nb[i]) || is_diarylamino (a_het, nb[i]))
-            r = true;
+            r = istrue;
+  }
   return r;
+}
 static boolean is_alkoxycarbonyl (int a_view, int a_ref)
+{
   int i;
-  boolean r = false;
+  boolean r = isfalse;
   neighbor_rec nb;
   memset (nb, 0, sizeof (neighbor_rec));
   if (!(atom[a_view - 1].heavy && (bond[get_bond (a_view, a_ref) - 1].btype == 'S')))
-    return false;
+    return isfalse;
   if (!(is_oxo_C (a_ref) && atom[a_ref - 1].neighbor_count == 3))
-    return false;
+    return isfalse;
   get_nextneighbors (nb, a_ref, a_view);
   for (i = 0; i <= 1; i++) {
     if (is_alkoxy (a_ref, nb[i]))
-            r = true;
+            r = istrue;
+  }
   return r;
+}
 static boolean is_aryloxycarbonyl (int a_view, int a_ref)
+{
   int i;
-  boolean r = false;
+  boolean r = isfalse;
   neighbor_rec nb;
   memset (nb, 0, sizeof (neighbor_rec));
   if (!(atom[a_view - 1].
        heavy && (bond[get_bond (a_view, a_ref) - 1].btype == 'S')))
-    return false;
+    return isfalse;
   if (!(is_oxo_C (a_ref) && atom[a_ref - 1].neighbor_count == 3))
-    return false;
+    return isfalse;
   get_nextneighbors (nb, a_ref, a_view);
   for (i = 0; i <= 1; i++) {
     if (is_aryloxy (a_ref, nb[i]))
-            r = true;
+            r = istrue;
+  }
   return r;
+}
 static boolean is_carbamoyl (int a_view, int a_ref)
+{
   int i;
-  boolean r = false;
+  boolean r = isfalse;
   neighbor_rec nb;
   memset (nb, 0, sizeof (neighbor_rec));
   if (!(atom[a_view - 1].
        heavy && (bond[get_bond (a_view, a_ref) - 1].btype == 'S')))
-    return false;
+    return isfalse;
   if (!(is_oxo_C (a_ref) && atom[a_ref - 1].neighbor_count == 3))
-    return false;
+    return isfalse;
   get_nextneighbors (nb, a_ref, a_view);
   for (i = 0; i <= 1; i++) {
     if (!strcmp (atom[nb[i] - 1].atype, "N3 ") || !strcmp (atom[nb[i] - 1].atype, "NAM"))
-            r = true;
+            r = istrue;
+  }
   return r;
+}
 static boolean is_alkoxythiocarbonyl (int a_view, int a_ref)
+{
   int i;
-  boolean r = false;
+  boolean r = isfalse;
   neighbor_rec nb;
   memset (nb, 0, sizeof (neighbor_rec));
   if (!(atom[a_view - 1].heavy && (bond[get_bond (a_view, a_ref) - 1].btype == 'S')))
-    return false;
+    return isfalse;
   if (!(is_thioxo_C (a_ref) && atom[a_ref - 1].neighbor_count == 3))
-    return false;
+    return isfalse;
   get_nextneighbors (nb, a_ref, a_view);
   for (i = 0; i <= 1; i++) {
     if (is_alkoxy (a_ref, nb[i]))
-            r = true;
+            r = istrue;
+  }
   return r;
+}
 static boolean is_aryloxythiocarbonyl (int a_view, int a_ref)
+{
   int i;
-  boolean r = false;
+  boolean r = isfalse;
   neighbor_rec nb;
   memset (nb, 0, sizeof (neighbor_rec));
   if (!(atom[a_view - 1].heavy && (bond[get_bond (a_view, a_ref) - 1].btype == 'S')))
-    return false;
+    return isfalse;
   if (!(is_thioxo_C (a_ref) && atom[a_ref - 1].neighbor_count == 3))
-    return false;
+    return isfalse;
   get_nextneighbors (nb, a_ref, a_view);
   for (i = 0; i <= 1; i++) {
     if (is_aryloxy (a_ref, nb[i]))
-            r = true;
+            r = istrue;
+  }
   return r;
+}
 static boolean is_thiocarbamoyl (int a_view, int a_ref)
+{
   int i;
-  boolean r = false;
+  boolean r = isfalse;
   neighbor_rec nb;
   memset (nb, 0, sizeof (neighbor_rec));
   if (!(atom[a_view - 1].
        heavy && (bond[get_bond (a_view, a_ref) - 1].btype == 'S')))
-    return false;
+    return isfalse;
   if (!(is_thioxo_C (a_ref) && atom[a_ref - 1].neighbor_count == 3))
-    return false;
+    return isfalse;
   get_nextneighbors (nb, a_ref, a_view);
   for (i = 0; i <= 1; i++) {
     if (!strcmp (atom[nb[i] - 1].atype, "N3 ") ||
               !strcmp (atom[nb[i] - 1].atype, "NAM"))
-            r = true;
+            r = istrue;
+  }
   return r;
+}
 static boolean is_alkanoyl (int a_view, int a_ref)
+{
   int i;
-  boolean r = false;
+  boolean r = isfalse;
   neighbor_rec nb;
   memset (nb, 0, sizeof (neighbor_rec));
   if (!(atom[a_view - 1].
        heavy && (bond[get_bond (a_view, a_ref) - 1].btype == 'S')))
-    return false;
+    return isfalse;
   if (!(is_oxo_C (a_ref) && atom[a_ref - 1].neighbor_count == 3))
-    return false;
+    return isfalse;
   get_nextneighbors (nb, a_ref, a_view);
   for (i = 0; i <= 1; i++) {
     if (is_alkyl (a_ref, nb[i]))
-            r = true;
+            r = istrue;
+  }
   return r;
+}
 static boolean is_aroyl (int a_view, int a_ref)
+{
   int i;
-  boolean r = false;
+  boolean r = isfalse;
   neighbor_rec nb;
   memset (nb, 0, sizeof (neighbor_rec));
   if (!(atom[a_view - 1].
        heavy && (bond[get_bond (a_view, a_ref) - 1].btype == 'S')))
-    return false;
+    return isfalse;
   if (!(is_oxo_C (a_ref) && atom[a_ref - 1].neighbor_count == 3))
-    return false;
+    return isfalse;
   get_nextneighbors (nb, a_ref, a_view);
   for (i = 0; i <= 1; i++) {
     if (is_aryl (a_ref, nb[i]))
-            r = true;
+            r = istrue;
+  }
   return r;
+}
 static boolean is_acyl (int a_view, int a_ref)
+{
-  boolean r = false;
+  boolean r = isfalse;
   if (is_alkanoyl (a_view, a_ref) || is_aroyl (a_view, a_ref))
-    r = true;
+    r = istrue;
   return r;
+}
 static boolean is_acyl_gen (int a_view, int a_ref)
+{
   /* new in v0.3j */
-  boolean r = false;
+  boolean r = isfalse;
   if (is_oxo_C (a_ref))
-    r = true;
+    r = istrue;
   return r;
+}
 static boolean is_acylamino (int a_view, int a_ref)
+{
-  boolean r = false;
+  boolean r = isfalse;
   neighbor_rec nb;
   int acyl_count = 0;
   memset (nb, 0, sizeof (neighbor_rec));
   if (!(atom[a_view - 1].
        heavy && (bond[get_bond (a_view, a_ref) - 1].btype == 'S')))
-    return false;
+    return isfalse;
   if (strcmp (atom[a_ref - 1].element, "N ")
       || atom[a_ref - 1].neighbor_count != 2)
-    return false;
+    return isfalse;
   get_nextneighbors (nb, a_ref, a_view);
   if (is_acyl (a_ref, nb[0]))
     acyl_count++;
   if (acyl_count == 1)
-    r = true;
+    r = istrue;
   return r;
+}
 static boolean is_subst_acylamino (int a_view, int a_ref)
+{
   /* may be substituted _or_ unsubstituted acylamino group! */
   int i;
-  boolean r = false;
+  boolean r = isfalse;
   neighbor_rec nb;
   int acyl_count = 0;
   int FORLIM;
   memset (nb, 0, sizeof (neighbor_rec));
   if (!(atom[a_view - 1].
        heavy && (bond[get_bond (a_view, a_ref) - 1].btype == 'S')))
-    return false;
+    return isfalse;
   if (strcmp (atom[a_ref - 1].element, "N ")
       || atom[a_ref - 1].neighbor_count < 2)
-    return false;
+    return isfalse;
   get_nextneighbors (nb, a_ref, a_view);
   FORLIM = atom[a_ref - 1].neighbor_count - 2;
   for (i = 0; i <= FORLIM; i++) {
     if (is_acyl_gen (a_ref, nb[i]))     /* v0.3j */
             acyl_count++;
+  }
   if (acyl_count > 0)
-    r = true;
+    r = istrue;
   return r;
+}
 static boolean is_hydrazino (int a_view, int a_ref)
+{
   int i;
-  boolean r = false;
+  boolean r = isfalse;
   neighbor_rec nb;
   int nr_count = 0;
   int FORLIM;
   memset (nb, 0, sizeof (neighbor_rec));
   if (!(atom[a_view - 1].
        heavy && (bond[get_bond (a_view, a_ref) - 1].btype == 'S')))
-    return false;
+    return isfalse;
   if (strcmp (atom[a_ref - 1].element, "N ")
       || atom[a_ref - 1].neighbor_count < 2)
-    return false;
+    return isfalse;
   get_nextneighbors (nb, a_ref, a_view);
   FORLIM = atom[a_ref - 1].neighbor_count - 2;
   for (i = 0; i <= FORLIM; i++) {                               /* fixed in v0.3c */
     if (is_amino (a_ref, nb[i]) || is_subst_amino (a_ref, nb[i]))
             nr_count++;
+  }
   if (nr_count == 1)
-    r = true;
+    r = istrue;
   return r;
+}
 static boolean is_nitroso (int a_view, int a_ref)
+{
   /* new in v0.3j */
-  boolean r = false;
+  boolean r = isfalse;
   neighbor_rec nb;
   int o_count = 0;
   int a2;
   memset (nb, 0, sizeof (neighbor_rec));
   if (!(atom[a_view - 1].
        heavy && (bond[get_bond (a_view, a_ref) - 1].btype == 'S')))
-    return false;
+    return isfalse;
   if (strcmp (atom[a_ref - 1].element, "N ")
       || atom[a_ref - 1].neighbor_count != 2)
-    return false;
+    return isfalse;
   get_nextneighbors (nb, a_ref, a_view);
   a2 = nb[0];
   if ((strcmp (atom[a2 - 1].element, "O ") == 0) &&
       (bond[get_bond (a_ref, a2) - 1].btype == 'D'))
     o_count++;
   if (o_count == 1)
-    r = true;
+    r = istrue;
   return r;
+}
 static boolean is_subst_hydrazino (int a_view, int a_ref)
+{
   int i;
-  boolean r = false;
+  boolean r = isfalse;
   neighbor_rec nb;
   int nr_count = 0;
   int a2, FORLIM;
   memset (nb, 0, sizeof (neighbor_rec));
   if (!(atom[a_view - 1].
        heavy && (bond[get_bond (a_view, a_ref) - 1].btype == 'S')))
-    return false;
+    return isfalse;
   if (strcmp (atom[a_ref - 1].element, "N ")
       || atom[a_ref - 1].neighbor_count < 2)
-    return false;
+    return isfalse;
   get_nextneighbors (nb, a_ref, a_view);
   FORLIM = atom[a_ref - 1].neighbor_count - 2;
   for (i = 0; i <= FORLIM; i++) {
     a2 = nb[i];
     if ((strcmp (atom[a2 - 1].element, "N ") == 0) && (!is_nitroso (a_ref, a2)))
             /* v0.3j */
             nr_count++;
+  }
   if (nr_count == 1)
-    r = true;
+    r = istrue;
   return r;
+}
 static boolean is_cyano (int a_view, int a_ref)
+{
-  boolean r = false;
+  boolean r = isfalse;
   if (((strcmp (atom[a_view - 1].atype, "C1 ") == 0) &&
       (bond[get_bond (a_view, a_ref) - 1].btype == 'T')) &&
       !strcmp (atom[a_ref - 1].atype, "N1 ") &&
       atom[a_ref - 1].neighbor_count == 1)
-    r = true;
+    r = istrue;
   return r;
+}
 static boolean is_cyano_c (int a_ref)
+{
   int i;
-  boolean r = false;
+  boolean r = isfalse;
   neighbor_rec nb;
   int FORLIM;
   memset (nb, 0, sizeof (neighbor_rec));
   if (strcmp (atom[a_ref - 1].atype, "C1 ")
       || atom[a_ref - 1].neighbor_count <= 0)
-    return false;
+    return isfalse;
   get_neighbors (nb, a_ref);
   FORLIM = atom[a_ref - 1].neighbor_count;
   for (i = 0; i < FORLIM; i++) {
     if (is_cyano (a_ref, nb[i]))
-            r = true;
+            r = istrue;
+  }
   return r;
+}
 static boolean is_nitrile (int a_view, int a_ref)
+{
-  boolean r = false;
+  boolean r = isfalse;
   neighbor_rec nb;
   str2 nb_el;
   if (!is_cyano (a_view, a_ref))
-    return false;
+    return isfalse;
   if (atom[a_view - 1].neighbor_count == 1
       && atom[a_view - 1].formal_charge == 0)
-    return true;
+    return istrue;
 /* p2c: checkmol.pas: Note: Eliminated unused assignment statement [338] */
   get_nextneighbors (nb, a_view, a_ref);
   strcpy (nb_el, atom[nb[0] - 1].element);
   if (!strcmp (nb_el, "C ")
       || !strcmp (nb_el, "H ") /*|| !strcmp (nb_el, "D ") */ )
     /* v0.3n: D */
-    r = true;
+    r = istrue;
   /* HCN is also a nitrile! */
   return r;
+}
 static boolean is_isonitrile (int a_view, int a_ref)
+{
   /* only recognized with CN triple bond! */
-  boolean r = false;
+  boolean r = isfalse;
   if (((strcmp (atom[a_view - 1].atype, "C1 ") == 0) &&
        (bond[get_bond (a_view, a_ref) - 1].btype == 'T')) &&
       !strcmp (atom[a_ref - 1].atype, "N1 ") &&
       atom[a_ref - 1].neighbor_count == 2
       && atom[a_view - 1].neighbor_count == 1)
-    r = true;
+    r = istrue;
   return r;
+}
 static boolean is_cyanate (int a_view, int a_ref)
+{
-  boolean r = false;
+  boolean r = isfalse;
   neighbor_rec nb;
   if (!is_cyano (a_view, a_ref))
-    return false;
+    return isfalse;
   if (atom[a_view - 1].neighbor_count != 2)
-    return false;
+    return isfalse;
   get_nextneighbors (nb, a_view, a_ref);
   if (is_alkoxy (a_view, nb[0]) || is_aryloxy (a_view, nb[0]))
-    r = true;
+    r = istrue;
   return r;
+}
 static boolean is_thiocyanate (int a_view, int a_ref)
+{
-  boolean r = false;
+  boolean r = isfalse;
   neighbor_rec nb;
   if (!is_cyano (a_view, a_ref))
-    return false;
+    return isfalse;
   if (atom[a_view - 1].neighbor_count != 2)
-    return false;
+    return isfalse;
   get_nextneighbors (nb, a_view, a_ref);
   if (is_alkylsulfanyl (a_view, nb[0]) || is_arylsulfanyl (a_view, nb[0]))
-    r = true;
+    r = istrue;
   return r;
+}
 static void update_Htotal ()
+{
   int i, j, b_id;
   neighbor_rec nb;
   int single_count, double_count, triple_count, arom_count, total_bonds,
     Htotal, nval;
   /* new in v0.3 */
-  boolean diazon = false;       /* new in v0.3j */
+  boolean diazon = isfalse;     /* new in v0.3j */
   neighbor_rec nb2;             /* new in v0.3j */
   int a1, a2, a3;               /* new in v0.3j */
   int FORLIM, FORLIM1;
   if (n_atoms < 1)
             if (!strcmp (atom[a1 - 1].element, "N ") && !strcmp (atom[a2 - 1].element, "N ")) {
               if (atom[a2 - 1].neighbor_count == 2) {
                       get_nextneighbors (nb2, a2, a1);
                       a3 = nb2[0];
                       if ((strcmp (atom[a3 - 1].element, "C ") == 0) && is_diazonium (a3, a2))
-                        diazon = true;
+                        diazon = istrue;
+                  }
+            }
+          }
     total_bonds = single_count + double_count * 2 + triple_count * 3 + (int) (1.5 * arom_count);
       /* calculate number of total hydrogens per atom */
                       /* N-oxide is N3 except in hetarene etc. */
                       else
                         strcpy (atom[i].atype, "N2 ");
+                    }
               /* fallback, added in v0.3g  */
-              if (arom_count > 1 || atom[i].arom == true)       /* v0.3n */
+              if (arom_count > 1 || atom[i].arom == istrue)     /* v0.3n */
                       strcpy (atom[i].atype, "NAR");
               if (triple_count == 0 && double_count == 0) {
                       if (atom[i].formal_charge == 0) {
                         if (acyl_count == 0)
                                 strcpy (atom[i].atype, "N3 ");
     ring_size = ringprop[i].size;
     if (ring_size == 6) {
             memset (testring, 0, sizeof (ringpath_type));
             for (j = 0; j < ring_size; j++)
               testring[j] = ring[i][j];
-            cumul = false;
+            cumul = isfalse;
             n_sb = 0;
             n_db = 0;
             n_ar = 0;
             a_prev = testring[ring_size - 1];
             for (j = 1; j <= ring_size; j++) {
               if (bt_fw == 'D')
                 n_db++;
               if (bt_fw == 'A')
                       n_ar++;
               if (bt_fw != 'A' && bt_bk == bt_fw)
-                      cumul = true;
+                      cumul = istrue;
               a_prev = a_ref;
+            }
-            if (n_ar == 6 || (n_sb == 3 && n_db == 3 && cumul == false)) {
+            if (n_ar == 6 || (n_sb == 3 && n_db == 3 && cumul == isfalse)) {
               /* this ring is aromatic */
               a_prev = testring[ring_size - 1];
               for (j = 0; j < ring_size; j++) {
                       a_ref = testring[j];
                       b_bk = get_bond (a_prev, a_ref);
-                      bond[b_bk - 1].arom = true;
+                      bond[b_bk - 1].arom = istrue;
                       a_prev = a_ref;
+                    }
-              ringprop[i].arom = true;
+              ringprop[i].arom = istrue;
+            }
+          }
+  }
   FORLIM = n_rings;
   for (i = 1; i <= FORLIM; i++) {
-    if (ringprop[i - 1].arom == false) {
+    if (ringprop[i - 1].arom == isfalse) {
             /* do the hard work only for those rings which are not yet flagged aromatic */
             memset (testring, 0, sizeof (ringpath_type));
             ring_size = ringprop[i - 1].size;   /* v0.3j */
             for (j = 0; j < ring_size; j++)     /* v0.3j */
               testring[j] = ring[i - 1][j];
             pi_count = 0;
             arom_pi_diff = 0;   /* v0.3j */
       /* p2c: checkmol.pas: Note: Eliminated unused assignment statement [338] */
-            ko = false;
+            ko = isfalse;
             a_prev = testring[ring_size - 1];
             for (j = 1; j <= ring_size; j++) {
               a_ref = testring[j - 1];
               if (j < ring_size)
                 a_next = testring[j];
               b_fw = get_bond (a_ref, a_next);
               bt_bk = bond[b_bk - 1].btype;
               bt_fw = bond[b_fw - 1].btype;
               ar_bk = bond[b_bk - 1].arom;
               ar_fw = bond[b_fw - 1].arom;
-              if (bt_bk == 'S' && bt_fw == 'S' && ar_bk == false && ar_fw == false) {
+              if (bt_bk == 'S' && bt_fw == 'S' && ar_bk == isfalse && ar_fw == isfalse) {
                 /* first, assume the worst case (interrupted conjugation) */
-                conj_intr = true;
+                conj_intr = istrue;
                 /* conjugation can be restored by hetero atoms */
                 if (!strcmp (atom[a_ref - 1].atype, "O3 ") ||
                     !strcmp (atom[a_ref - 1].atype, "S3 ") ||
                           !strcmp (atom[a_ref - 1].element, "N ") ||
                           !strcmp (atom[a_ref - 1].element, "SE")) {
-                        conj_intr = false;
+                        conj_intr = isfalse;
                         pi_count += 2;  /* lone pair adds for 2 pi electrons */
+                      }
                       /* conjugation can be restored by a formal charge at a methylene group */
                       if (!strcmp (atom[a_ref - 1].element, "C ") &&
                           atom[a_ref - 1].formal_charge != 0) {
-                          conj_intr = false;
+                          conj_intr = isfalse;
                           pi_count -= atom[a_ref - 1].formal_charge;
                           /* neg. charge increases pi_count! */
+                      }
                       /* conjugation can be restored by carbonyl groups etc. */
                       if (is_oxo_C (a_ref) || is_thioxo_C (a_ref) |
                           is_exocyclic_imino_C (a_ref, i))
-                        conj_intr = false;
+                        conj_intr = isfalse;
                       /* conjugation can be restored by exocyclic C=C double bond, */
                       /* adds 2 pi electrons to 5-membered rings, not to 7-membered rings (CAUTION!) */
                       /* apply only to non-aromatic exocyclic C=C bonds */
                       exo_mC = find_exocyclic_methylene_C (a_ref, i);   /* v0.3j */
                       if (exo_mC > 0 && (ring_size & 1)) {              /* v0.3j */
                           b_exo = get_bond (a_ref, exo_mC);     /* v0.3j  */
                           ar_exo = bond[b_exo - 1].arom;
                         if (((ring_size - 1) & 3) == 0) {       /* 5-membered rings and related */
-                                conj_intr = false;
+                                conj_intr = isfalse;
                                 pi_count += 2;
+                              }
                         else {
                                 if (!ar_exo)
-                                  conj_intr = false;
+                                  conj_intr = isfalse;
+                              }
+                      }
                       /* 7-membered rings and related */
                       /* if conjugation is still interrupted ==> knock-out */
                       if (conj_intr)
-                        ko = true;
+                        ko = istrue;
+                    }
               else {
-                      if (bt_bk == 'S' && bt_fw == 'S' && ar_bk == true && ar_fw == true) {
+                      if (bt_bk == 'S' && bt_fw == 'S' && ar_bk == istrue && ar_fw == istrue) {
                         if (!strcmp (atom[a_ref - 1].atype, "O3 ") ||
                                   !strcmp (atom[a_ref - 1].atype, "S3 ") ||
                                   !strcmp (atom[a_ref - 1].element, "N ") ||
                                   !strcmp (atom[a_ref - 1].element, "SE"))
                                 pi_count += 2;  /* lone pair adds for 2 pi electrons */
                                   pi_count += 2;
+                              }
+                      }
                       else {
                   pi_count++;   /* v0.3j; adjustment for bridgehead N: see below */
-                  if (bt_bk == 'S' && bt_fw == 'S' && ((ar_bk == true && ar_fw == false) ||
+                  if (bt_bk == 'S' && bt_fw == 'S' && ((ar_bk == istrue && ar_fw == isfalse) ||
-                                  (ar_bk == false && ar_fw == true))) {
+                                  (ar_bk == isfalse && ar_fw == istrue))) {
                                 /* v0.3j; if a bridgehead N were not aromatic, it could  */
                                 /* contribute 2 pi electrons --> try also this variant */
                                 /* (example: CAS 32278-54-9) */
                                 if (!strcmp (atom[a_ref - 1].element, "N ")) {
                                   arom_pi_diff++;
               /* v0.3j; odd pi_count might be compensated by arom_pi_diff */
                           /* apply Hueckel's rule */
               if (labs (ring_size - pi_count) < 2 &&
                         (((pi_count - 2) & 3) == 0 || ((pi_count + arom_pi_diff - 2) & 3) == 0)) {
                       /* this ring is aromatic */
-                      ringprop[i - 1].arom = true;
+                      ringprop[i - 1].arom = istrue;
                       /* now mark _all_ bonds in the ring as aromatic */
                       a_prev = testring[ring_size - 1];
                       for (j = 0; j < ring_size; j++) {
                         a_ref = testring[j];
-                        bond[get_bond (a_prev, a_ref) - 1].arom = true;
+                        bond[get_bond (a_prev, a_ref) - 1].arom = istrue;
                         a_prev = a_ref;
+                      }
+                    }
+            }
+          }
   /* finally, mark all involved atoms as aromatic */
   for (i = 0; i < FORLIM; i++) {
     if (bond[i].arom) {
             a1 = bond[i].a1;    /* v0.3n */
             a2 = bond[i].a2;    /* v0.3n */
-            atom[a1 - 1].arom = true;
+            atom[a1 - 1].arom = istrue;
-            atom[a2 - 1].arom = true;
+            atom[a2 - 1].arom = istrue;
             /* v0.3n: update atom types if applicable (C and N) */
             if (!strcmp (atom[a1 - 1].element, "C "))
               strcpy (atom[a1 - 1].atype, "CAR");
             if (!strcmp (atom[a2 - 1].element, "C "))
               strcpy (atom[a2 - 1].atype, "CAR");
   /* new in v0.3n: accept rings as aromatic if all bonds are of type 'A' */
   for (i = 0; i < FORLIM; i++) {
     memcpy (testring, ring[i], sizeof (ringpath_type));
     /*ring_size := path_length(testring); */
     ring_size = ringprop[i].size;       /* v0.3j */
-    aromatic = true;
+    aromatic = istrue;
-    aromatic_bt = true; /* v0.3n */
+    aromatic_bt = istrue;       /* v0.3n */
     a_prev = testring[ring_size - 1];
     for (j = 0; j < ring_size; j++) {
             a_ref = testring[j];
             b = get_bond (a_prev, a_ref);       /* v0.3n */
             if (!bond[b - 1].arom)
-              aromatic = false;
+              aromatic = isfalse;
             if (bond[b - 1].btype != 'A')       /* v0.3n */
-              aromatic_bt = false;
+              aromatic_bt = isfalse;
             a_prev = a_ref;
+          }
     if (aromatic_bt && !aromatic) {                     /* v0.3n: update aromaticity flag */
             a_prev = testring[ring_size - 1];
             for (j = 0; j < ring_size; j++) {
               a_ref = testring[j];
               b = get_bond (a_prev, a_ref);
-              bond[b - 1].arom = true;
+              bond[b - 1].arom = istrue;
               if (!strcmp (atom[a_ref - 1].element, "C "))
                       strcpy (atom[a_ref - 1].atype, "CAR");
               if (!strcmp (atom[a_ref - 1].element, "N "))
                       strcpy (atom[a_ref - 1].atype, "NAR");
               a_prev = a_ref;
+            }
-            aromatic = true;
+            aromatic = istrue;
           }                     /* end v0.3n block   */
     if (aromatic)
-            ringprop[i].arom = true;
+            ringprop[i].arom = istrue;
     else
-            ringprop[i].arom = false;
+            ringprop[i].arom = isfalse;
+  }
+}
 static void write_mol ()
+{
   if (n_rings <= 0)
     return;
   FORLIM = n_rings;
   for (i = 0; i < FORLIM; i++) {
     printf ("ring %d: ", i + 1);
-    /*aromatic := true; */
+    /*aromatic := istrue; */
     memset (testring, 0, sizeof (ringpath_type));
     ring_size = ringprop[i].size;       /* v0.3j */
     /*for j := 1 to max_ringsize do if ring^[i,j] > 0 then testring[j] := ring^[i,j]; */
     for (j = 0; j < ring_size; j++)     /* v0.3j */
             testring[j] = ring[i][j];
     /*ring_size := path_length(testring); */
     /*a_prev := testring[ring_size]; */
     for (j = 0; j < ring_size; j++) {
             printf ("%d ", testring[j]);
             /*a_ref := testring[j]; */
-            /*if (not bond^[get_bond(a_prev,a_ref)].arom) then aromatic := false; */
+            /*if (not bond^[get_bond(a_prev,a_ref)].arom) then aromatic := isfalse; */
             /*a_prev := a_ref; */
+          }
     /*if aromatic then write(' (aromatic)'); */
     if (ringprop[i].arom) printf (" (aromatic)");
     if (ringprop[i].envelope) printf (" (env)");
+  }
   if (ndl_n_rings <= 0)
     return;
   FORLIM = ndl_n_rings;
   for (i = 0; i < FORLIM; i++) {
-    aromatic = true;
+    aromatic = istrue;
     memset (testring, 0, sizeof (ringpath_type));
     for (j = 0; j < max_ringsize; j++) {
             if (ndl_ring[i][j] > 0)
               testring[j] = ndl_ring[i][j];
+          }
     a_prev = testring[ring_size - 1];
     for (j = 0; j < ring_size; j++) {
             printf ("%d ", testring[j]);
             a_ref = testring[j];
             if (!ndl_bond[get_ndl_bond (a_prev, a_ref) - 1].arom)       /* v0.3k */
-              aromatic = false;
+              aromatic = isfalse;
             a_prev = a_ref;
+          }
     if (aromatic) printf (" (aromatic)");
     putchar ('\n');
+  }
                 || !strcmp (nb_el, "AT"))
               hal_count++;
+          }
+  }
   if (het_count == 2) {                                 /* sulfuric acid derivative */
-    fg[fg_sulfuric_acid_deriv - 1] = true;
+    fg[fg_sulfuric_acid_deriv - 1] = istrue;
     if (o_count == 2) {
             if (or_count == 0)
-              fg[fg_sulfuric_acid - 1] = true;
+              fg[fg_sulfuric_acid - 1] = istrue;
             if (or_count == 1)
-              fg[fg_sulfuric_acid_monoester - 1] = true;
+              fg[fg_sulfuric_acid_monoester - 1] = istrue;
             if (or_count == 2)
-              fg[fg_sulfuric_acid_diester - 1] = true;
+              fg[fg_sulfuric_acid_diester - 1] = istrue;
+          }
     if (o_count == 1) {
             if (or_count == 1 && n_count == 1)
-              fg[fg_sulfuric_acid_amide_ester - 1] = true;
+              fg[fg_sulfuric_acid_amide_ester - 1] = istrue;
             if (or_count == 0 && n_count == 1)
-              fg[fg_sulfuric_acid_amide - 1] = true;
+              fg[fg_sulfuric_acid_amide - 1] = istrue;
+          }
     if (n_count == 2)
-            fg[fg_sulfuric_acid_diamide - 1] = true;
+            fg[fg_sulfuric_acid_diamide - 1] = istrue;
     if (hal_count > 0)
-            fg[fg_sulfuryl_halide - 1] = true;
+            fg[fg_sulfuryl_halide - 1] = istrue;
+  }
   if (het_count == 1 && c_count == 1) {                                 /* sulfonic acid derivative */
-    fg[fg_sulfonic_acid_deriv - 1] = true;
+    fg[fg_sulfonic_acid_deriv - 1] = istrue;
     if (o_count == 1 && or_count == 0)
-            fg[fg_sulfonic_acid - 1] = true;
+            fg[fg_sulfonic_acid - 1] = istrue;
     if (o_count == 1 && or_count == 1)
-            fg[fg_sulfonic_acid_ester - 1] = true;
+            fg[fg_sulfonic_acid_ester - 1] = istrue;
     if (n_count == 1)
-            fg[fg_sulfonamide - 1] = true;
+            fg[fg_sulfonamide - 1] = istrue;
     if (hal_count == 1)
-            fg[fg_sulfonyl_halide - 1] = true;
+            fg[fg_sulfonyl_halide - 1] = istrue;
+  }
   if (het_count == 0 && c_count == 2)   /* sulfone */
-    fg[fg_sulfone - 1] = true;
+    fg[fg_sulfone - 1] = istrue;
+}
 static void chk_p_deriv (int a_ref)
+{
   int i;
   het_count = oh_count + or_count + hal_count + n_count;
   if (!strcmp (atom[a_ref - 1].atype, "P3D") ||
       !strcmp (atom[a_ref - 1].atype, "P4 ")) {
     if (!strcmp (dbl_het, "O ")) {
             if (c_count == 0) {
-              fg[fg_phosphoric_acid_deriv - 1] = true;
+              fg[fg_phosphoric_acid_deriv - 1] = istrue;
               if (oh_count == 3)
-                fg[fg_phosphoric_acid - 1] = true;
+                fg[fg_phosphoric_acid - 1] = istrue;
               if (or_count > 0)
-                fg[fg_phosphoric_acid_ester - 1] = true;
+                fg[fg_phosphoric_acid_ester - 1] = istrue;
               if (hal_count > 0)
-                fg[fg_phosphoric_acid_halide - 1] = true;
+                fg[fg_phosphoric_acid_halide - 1] = istrue;
               if (n_count > 0)
-                fg[fg_phosphoric_acid_amide - 1] = true;
+                fg[fg_phosphoric_acid_amide - 1] = istrue;
+            }
             if (c_count == 1) {
-              fg[fg_phosphonic_acid_deriv - 1] = true;
+              fg[fg_phosphonic_acid_deriv - 1] = istrue;
               if (oh_count == 2)
-                fg[fg_phosphonic_acid - 1] = true;
+                fg[fg_phosphonic_acid - 1] = istrue;
               if (or_count > 0)
-                fg[fg_phosphonic_acid_ester - 1] = true;
+                fg[fg_phosphonic_acid_ester - 1] = istrue;
-              /*if (hal_count > 0)  then fg[fg_phosphonic_acid_halide] := true;             */
+              /*if (hal_count > 0)  then fg[fg_phosphonic_acid_halide] := istrue;             */
-              /*if (n_count > 0)    then fg[fg_phosphonic_acid_amide]  := true; */
+              /*if (n_count > 0)    then fg[fg_phosphonic_acid_amide]  := istrue; */
+            }
             if (c_count == 3)
-              fg[fg_phosphinoxide - 1] = true;
+              fg[fg_phosphinoxide - 1] = istrue;
+          }
     if (!strcmp (dbl_het, "S ")) {
       if (c_count == 0) {
-        fg[fg_thiophosphoric_acid_deriv - 1] = true;
+        fg[fg_thiophosphoric_acid_deriv - 1] = istrue;
         if (oh_count == 3)
-            fg[fg_thiophosphoric_acid - 1] = true;
+            fg[fg_thiophosphoric_acid - 1] = istrue;
         if (or_count > 0)
-            fg[fg_thiophosphoric_acid_ester - 1] = true;
+            fg[fg_thiophosphoric_acid_ester - 1] = istrue;
         if (hal_count > 0)
-            fg[fg_thiophosphoric_acid_halide - 1] = true;
+            fg[fg_thiophosphoric_acid_halide - 1] = istrue;
         if (n_count > 0)
-            fg[fg_thiophosphoric_acid_amide - 1] = true;
+            fg[fg_thiophosphoric_acid_amide - 1] = istrue;
+      }
+    }
+  }
-  /*  if (atom^[a_ref].atype = 'P4 ') then fg[fg_phosphoric_acid_deriv] := true; */
+  /*  if (atom^[a_ref].atype = 'P4 ') then fg[fg_phosphoric_acid_deriv] := istrue; */
   if (strcmp (atom[a_ref - 1].atype, "P3 "))    /* changed P3D into P3 in v0.3b */
     return;
   if (c_count == 3 && het_count == 0)
-    fg[fg_phosphine - 1] = true;
+    fg[fg_phosphine - 1] = istrue;
   if (c_count == 3 && oh_count == 1)
-    fg[fg_phosphinoxide - 1] = true;
+    fg[fg_phosphinoxide - 1] = istrue;
+}
 static void chk_b_deriv (int a_ref)
+{
   int i;
+  }
   het_count = oh_count + or_count + hal_count + n_count;
   /* fixed in v0.3b */
   if (c_count != 1 || het_count != 2)
     return;
-  fg[fg_boronic_acid_deriv - 1] = true;
+  fg[fg_boronic_acid_deriv - 1] = istrue;
   if (oh_count == 2)
-    fg[fg_boronic_acid - 1] = true;
+    fg[fg_boronic_acid - 1] = istrue;
   if (or_count > 0)
-    fg[fg_boronic_acid_ester - 1] = true;
+    fg[fg_boronic_acid_ester - 1] = istrue;
+}
 static void chk_ammon (int a_ref)
+{
   int i;
+          }
     if (bt == 'A' && ha)
             bo_sum += 1.5;
   }                             /* v0.3k: corrected end of "for ..." loop */
   if (het_count == 0 && r_count == 4)
-    fg[fg_quart_ammonium - 1] = true;
+    fg[fg_quart_ammonium - 1] = istrue;
   if (het_count != 1 || atom[a_ref - 1].neighbor_count < 3)
     return;
   if (o_count == 1 && or_count == 0 && bo_sum > 3)
-    fg[fg_n_oxide - 1] = true;  /* finds only aliphatic N-oxides! */
+    fg[fg_n_oxide - 1] = istrue;        /* finds only aliphatic N-oxides! */
   if (((o_count == 1 && or_count == 1) || o_count == 0) &&
-      atom[a_ref - 1].arom == true)
+      atom[a_ref - 1].arom == istrue)
-    fg[fg_quart_ammonium - 1] = true;
+    fg[fg_quart_ammonium - 1] = istrue;
+}
 static void swap_atoms (int *a1, int *a2)
+{
   int a_tmp;
   int het_count = 0, c_count = 0, o_count = 0;  /* v0.3k */
   int FORLIM;
   /* v0.3k */
   if (atom[a_view - 1].neighbor_count == 1) {
-      if (atom[a_ref - 1].arom == false)
+      if (atom[a_ref - 1].arom == isfalse)
-        fg[fg_imine - 1] = true;
+        fg[fg_imine - 1] = istrue;
       return;
+    }
   memset (nb, 0, sizeof (neighbor_rec));
   get_neighbors (nb, a_view);
   if (atom[a_view - 1].neighbor_count <= 1)
               a_het = nb[i];
               het_count++;
+            }
             if ((!strcmp (nb_el, "O ")
                && atom[nb[i] - 1].neighbor_count ==
-) && (bond[get_bond (a_view, nb[i]) - 1].arom == false))
+) && (bond[get_bond (a_view, nb[i]) - 1].arom == isfalse))
               /* v0.3k */
               o_count++;
+          }
     if ((nb[i] != a_ref) && (bond[get_bond (a_view, nb[i]) - 1].btype == 'D')){
       /* v0.3k; make sure we do not count nitro groups in "azi" form etc. */
               a_het = nb[i];    /* v0.3m */
               het_count++;
+            }
             if ((!strcmp (nb_el, "O ")
                 && atom[nb[i] - 1].neighbor_count == 1) &&
-                  (bond[get_bond (a_view, nb[i]) - 1].arom == false))
+                  (bond[get_bond (a_view, nb[i]) - 1].arom == isfalse))
               /* v0.3k */
               o_count++;
+          }
+  }
   if (c_count == 1) {
     if ((is_alkyl (a_view, a_c) || is_aryl (a_view, a_c) |
               is_alkenyl (a_view, a_c) || is_alkynyl (a_view, a_c))
-              && atom[a_ref - 1].arom == false && het_count == 0)
+              && atom[a_ref - 1].arom == isfalse && het_count == 0)
             /* v0.3k */
-            fg[fg_imine - 1] = true;
+            fg[fg_imine - 1] = istrue;
+  }
   if (het_count == 1) {
     strcpy (nb_el, atom[a_het - 1].element);
     if (!strcmp (nb_el, "O ")) {
             if (is_hydroxy (a_view, a_het))
-              fg[fg_oxime - 1] = true;
+              fg[fg_oxime - 1] = istrue;
           if (is_alkoxy (a_view, a_het) || is_aryloxy (a_view, a_het) |
               is_alkenyloxy (a_view, a_het) || is_alkynyloxy (a_view, a_het))
-            fg[fg_oxime_ether - 1] = true;
+            fg[fg_oxime_ether - 1] = istrue;
+          }
     if (!strcmp (nb_el, "N ")) {
             if (is_amino (a_view, a_het) || is_alkylamino (a_view, a_het) |
                 is_dialkylamino (a_view, a_het) || is_alkylarylamino (a_view,a_het) |
                 is_arylamino (a_view, a_het) || is_diarylamino (a_view, a_het))
-              fg[fg_hydrazone - 1] = true;
+              fg[fg_hydrazone - 1] = istrue;
             else {
               memset (nb, 0, sizeof (neighbor_rec));
               get_neighbors (nb, a_het);
               if (atom[a_het - 1].neighbor_count > 1) {
                       FORLIM = atom[a_het - 1].neighbor_count;
                       for (i = 0; i < FORLIM; i++) {
                         if (nb[i] != a_view) {
                                 if (is_carbamoyl (a_het, nb[i]))
-                                  fg[fg_semicarbazone - 1] = true;
+                                  fg[fg_semicarbazone - 1] = istrue;
                                 if (is_thiocarbamoyl (a_het, nb[i]))
-                                  fg[fg_thiosemicarbazone - 1] = true;
+                                  fg[fg_thiosemicarbazone - 1] = istrue;
+                              }
+                      }
+                    }
+            }
+          }
   }                             /* v0.3k: nitro groups in "azi" form */
   /* check for semicarbazone or thiosemicarbazone */
   if (het_count == 2 && o_count == 2)
-    fg[fg_nitro_compound - 1] = true;
+    fg[fg_nitro_compound - 1] = istrue;
+}
 static void chk_carbonyl_deriv (int a_view, int a_ref)
+{
   /* a_view = C */
               n_db++;
+          }
+  }
   /* new in v0.3b */
   if (is_oxo_C (a_view)) {
-    fg[fg_carbonyl - 1] = true;
+    fg[fg_carbonyl - 1] = istrue;
     if (c_count + cn_count < 2) {                       /* new in v0.3b (detection of ketenes) */
             if (n_db <= 1)
-              fg[fg_aldehyde - 1] = true;
+              fg[fg_aldehyde - 1] = istrue;
             else
-              fg[fg_ketene - 1] = true;
+              fg[fg_ketene - 1] = istrue;
+          }
     if (c_count == 2) {
             if (atom[a_view - 1].arom)
-              fg[fg_oxohetarene - 1] = true;
+              fg[fg_oxohetarene - 1] = istrue;
             else
-              fg[fg_ketone - 1] = true;
+              fg[fg_ketone - 1] = istrue;
+          }
     if (cn_count > 0)
-            fg[fg_acyl_cyanide - 1] = true;
+            fg[fg_acyl_cyanide - 1] = istrue;
+  }
   if (is_thioxo_C (a_view)) {
-    fg[fg_thiocarbonyl - 1] = true;
+    fg[fg_thiocarbonyl - 1] = istrue;
     if (c_count < 2)
-            fg[fg_thioaldehyde - 1] = true;
+            fg[fg_thioaldehyde - 1] = istrue;
     if (c_count == 2) {
             if (atom[a_view - 1].arom)
-              fg[fg_thioxohetarene - 1] = true;
+              fg[fg_thioxohetarene - 1] = istrue;
             else
-              fg[fg_thioketone - 1] = true;
+              fg[fg_thioketone - 1] = istrue;
+          }
+  }
   if (is_imino_C (a_view))
     chk_imine (a_view, a_ref);
+}
+            }
+          }
+  }
   if (is_oxo_C (a_view)) {
     if (o_count == 1) {                 /* anhydride is checked somewhere else */
-            if (bond[get_bond (a_view, a_o) - 1].arom == false)
+            if (bond[get_bond (a_view, a_o) - 1].arom == isfalse)
-              fg[fg_carboxylic_acid_deriv - 1] = true;
+              fg[fg_carboxylic_acid_deriv - 1] = istrue;
             if (is_hydroxy (a_view, a_o)) {
               if (atom[a_o - 1].formal_charge == 0)
-                      fg[fg_carboxylic_acid - 1] = true;
+                      fg[fg_carboxylic_acid - 1] = istrue;
               if (atom[a_o - 1].formal_charge == -1)
-                      fg[fg_carboxylic_acid_salt - 1] = true;
+                      fg[fg_carboxylic_acid_salt - 1] = istrue;
+            }
             if (is_alkoxy (a_view, a_o) || is_aryloxy (a_view, a_o) |
                 is_alkenyloxy (a_view, a_o) || is_alkynyloxy (a_view, a_o)) {
-              if (bond[get_bond (a_view, a_o) - 1].arom == false)
+              if (bond[get_bond (a_view, a_o) - 1].arom == isfalse)
-                      fg[fg_carboxylic_acid_ester - 1] = true;
+                      fg[fg_carboxylic_acid_ester - 1] = istrue;
               if (bond[get_bond (a_view, a_o) - 1].ring_count > 0) {
-                      if (bond[get_bond (a_view, a_o) - 1].arom == true) {
+                      if (bond[get_bond (a_view, a_o) - 1].arom == istrue) {
-                        /*fg[fg_lactone_heteroarom] := true else fg[fg_lactone] := true; */
+                        /*fg[fg_lactone_heteroarom] := istrue else fg[fg_lactone] := istrue; */
-                        fg[fg_oxohetarene - 1] = true;
+                        fg[fg_oxohetarene - 1] = istrue;
+                      }
                     else
-                      fg[fg_lactone - 1] = true;
+                      fg[fg_lactone - 1] = istrue;
+                    }
+            }
+          }
     if (n_count == 1) {
-            if (bond[get_bond (a_view, a_n) - 1].arom == false)
+            if (bond[get_bond (a_view, a_n) - 1].arom == isfalse)
-              fg[fg_carboxylic_acid_deriv - 1] = true;
+              fg[fg_carboxylic_acid_deriv - 1] = istrue;
             else {
-              /*fg[fg_lactam_heteroarom] := true;  (* catches also pyridazines, 1,2,3-triazines, etc. */
+              /*fg[fg_lactam_heteroarom] := istrue;  (* catches also pyridazines, 1,2,3-triazines, etc. */
-              fg[fg_oxohetarene - 1] = true;
+              fg[fg_oxohetarene - 1] = istrue;
+            }
             if (is_amino (a_view, a_n) || (!strcmp (atom[a_n - 1].atype, "NAM")
                       && atom[a_n - 1].neighbor_count == 1)) {
-              fg[fg_carboxylic_acid_amide - 1] = true;
+              fg[fg_carboxylic_acid_amide - 1] = istrue;
-              fg[fg_carboxylic_acid_prim_amide - 1] = true;
+              fg[fg_carboxylic_acid_prim_amide - 1] = istrue;
+            }
             /*if (is_alkylamino(a_view,a_n)) or (is_arylamino(a_view,a_n)) then  */
             if (is_C_monosubst_amino (a_view, a_n) &&
                 (!is_subst_acylamino (a_view, a_n))) {                  /* v0.3j */
-              if (bond[get_bond (a_view, a_n) - 1].arom == false)
+              if (bond[get_bond (a_view, a_n) - 1].arom == isfalse)
-                      fg[fg_carboxylic_acid_amide - 1] = true;
+                      fg[fg_carboxylic_acid_amide - 1] = istrue;
-              if (bond[get_bond (a_view, a_n) - 1].arom == false)
+              if (bond[get_bond (a_view, a_n) - 1].arom == isfalse)
-                      fg[fg_carboxylic_acid_sec_amide - 1] = true;
+                      fg[fg_carboxylic_acid_sec_amide - 1] = istrue;
               if (bond[get_bond (a_view, a_n) - 1].ring_count > 0) {
-                      if (bond[get_bond (a_view, a_n) - 1].arom == true) {
+                      if (bond[get_bond (a_view, a_n) - 1].arom == istrue) {
-                        /*fg[fg_lactam_heteroarom]    := true else  */
+                        /*fg[fg_lactam_heteroarom]    := istrue else  */
-                        fg[fg_oxohetarene - 1] = true;
+                        fg[fg_oxohetarene - 1] = istrue;
+                      }
                       else
-                        fg[fg_lactam - 1] = true;
+                        fg[fg_lactam - 1] = istrue;
+                    }
+            }
             /*if (is_dialkylamino(a_view,a_n)) or (is_alkylarylamino(a_view,a_n)) or */
             /*   (is_diarylamino(a_view,a_n)) then  */
             if (is_C_disubst_amino (a_view, a_n) & (!is_subst_acylamino (a_view, a_n))) {
               /* v0.3j */
-              if (bond[get_bond (a_view, a_n) - 1].arom == false)
+              if (bond[get_bond (a_view, a_n) - 1].arom == isfalse)
-                fg[fg_carboxylic_acid_amide - 1] = true;
+                fg[fg_carboxylic_acid_amide - 1] = istrue;
-              if (bond[get_bond (a_view, a_n) - 1].arom == false)
+              if (bond[get_bond (a_view, a_n) - 1].arom == isfalse)
-                fg[fg_carboxylic_acid_tert_amide - 1] = true;
+                fg[fg_carboxylic_acid_tert_amide - 1] = istrue;
               if (bond[get_bond (a_view, a_n) - 1].ring_count > 0) {
-                if (bond[get_bond (a_view, a_n) - 1].arom == true) {
+                if (bond[get_bond (a_view, a_n) - 1].arom == istrue) {
-                        /*fg[fg_lactam_heteroarom]    := true else  */
+                        /*fg[fg_lactam_heteroarom]    := istrue else  */
-                        fg[fg_oxohetarene - 1] = true;
+                        fg[fg_oxohetarene - 1] = istrue;
+                      }
                       else
-                        fg[fg_lactam - 1] = true;
+                        fg[fg_lactam - 1] = istrue;
+                    }
+            }
             if (is_hydroxylamino (a_view, a_n))
-              fg[fg_hydroxamic_acid - 1] = true;
+              fg[fg_hydroxamic_acid - 1] = istrue;
             if (is_hydrazino (a_view, a_n))
-              fg[fg_carboxylic_acid_hydrazide - 1] = true;
+              fg[fg_carboxylic_acid_hydrazide - 1] = istrue;
             if (is_azido (a_view, a_n))
-              fg[fg_carboxylic_acid_azide - 1] = true;
+              fg[fg_carboxylic_acid_azide - 1] = istrue;
+          }
     if (s_count == 1) {                 /* anhydride is checked somewhere else */
-            if (bond[get_bond (a_view, a_s) - 1].arom == false)
+            if (bond[get_bond (a_view, a_s) - 1].arom == isfalse)
-              fg[fg_thiocarboxylic_acid_deriv - 1] = true;
+              fg[fg_thiocarboxylic_acid_deriv - 1] = istrue;
             if (is_sulfanyl (a_view, a_s))
-              fg[fg_thiocarboxylic_acid - 1] = true;
+              fg[fg_thiocarboxylic_acid - 1] = istrue;
             if (is_alkylsulfanyl (a_view, a_s) || is_arylsulfanyl (a_view, a_s)) {
-              if (bond[get_bond (a_view, a_s) - 1].arom == false)
+              if (bond[get_bond (a_view, a_s) - 1].arom == isfalse)
-                      fg[fg_thiocarboxylic_acid_ester - 1] = true;
+                      fg[fg_thiocarboxylic_acid_ester - 1] = istrue;
               if (bond[get_bond (a_view, a_s) - 1].ring_count > 0) {
-                      if (bond[get_bond (a_view, a_s) - 1].arom == true) {
+                      if (bond[get_bond (a_view, a_s) - 1].arom == istrue) {
-                        /*fg[fg_thiolactone_heteroarom] := true else fg[fg_thiolactone] := true; */
+                        /*fg[fg_thiolactone_heteroarom] := istrue else fg[fg_thiolactone] := istrue; */
-                        fg[fg_oxohetarene - 1] = true;
+                        fg[fg_oxohetarene - 1] = istrue;
+                      }
                       else
-                        fg[fg_thiolactone - 1] = true;
+                        fg[fg_thiolactone - 1] = istrue;
+                    }
+            }
+          }
   }                             /* end Oxo-C */
   if (is_thioxo_C (a_view)) {
-    /* fg[fg_thiocarboxylic_acid_deriv]  := true; */
+    /* fg[fg_thiocarboxylic_acid_deriv]  := istrue; */
     if (o_count == 1) {                 /* anhydride is checked somewhere else */
-            if (bond[get_bond (a_view, a_o) - 1].arom == false)
+            if (bond[get_bond (a_view, a_o) - 1].arom == isfalse)
-              fg[fg_thiocarboxylic_acid_deriv - 1] = true;
+              fg[fg_thiocarboxylic_acid_deriv - 1] = istrue;
             if (is_hydroxy (a_view, a_o))
-              fg[fg_thiocarboxylic_acid - 1] = true;    /* fixed in v0.3c */
+              fg[fg_thiocarboxylic_acid - 1] = istrue;  /* fixed in v0.3c */
             if (is_alkoxy (a_view, a_o) || is_aryloxy (a_view, a_o)) {
-              if (bond[get_bond (a_view, a_s) - 1].arom == false)
+              if (bond[get_bond (a_view, a_s) - 1].arom == isfalse)
-                      fg[fg_thiocarboxylic_acid_ester - 1] = true;
+                      fg[fg_thiocarboxylic_acid_ester - 1] = istrue;
               if (bond[get_bond (a_view, a_o) - 1].ring_count > 0) {
-                      if (bond[get_bond (a_view, a_o) - 1].arom == true) {
+                      if (bond[get_bond (a_view, a_o) - 1].arom == istrue) {
-                        /*fg[fg_thiolactone_heteroarom] := true else fg[fg_thiolactone] := true; */
+                        /*fg[fg_thiolactone_heteroarom] := istrue else fg[fg_thiolactone] := istrue; */
-                        fg[fg_thioxohetarene - 1] = true;
+                        fg[fg_thioxohetarene - 1] = istrue;
+                      }
                       else
-                        fg[fg_thiolactone - 1] = true;
+                        fg[fg_thiolactone - 1] = istrue;
+                    }
+            }
+          }
     if (n_count == 1) {
-            if (bond[get_bond (a_view, a_n) - 1].arom == false)
+            if (bond[get_bond (a_view, a_n) - 1].arom == isfalse)
-              fg[fg_thiocarboxylic_acid_deriv - 1] = true;
+              fg[fg_thiocarboxylic_acid_deriv - 1] = istrue;
             else {
-              /*fg[fg_thiolactam_heteroarom] := true;  (* catches also pyridazines, 1,2,3-triazines, etc. */
+              /*fg[fg_thiolactam_heteroarom] := istrue;  (* catches also pyridazines, 1,2,3-triazines, etc. */
-              fg[fg_thioxohetarene - 1] = true;
+              fg[fg_thioxohetarene - 1] = istrue;
+            }
             /* catches also pyridazines, 1,2,3-triazines, etc. */
             if (is_amino (a_view, a_n)){
-              fg[fg_thiocarboxylic_acid_amide - 1] = true;
+              fg[fg_thiocarboxylic_acid_amide - 1] = istrue;
-              /* fg[fg_thiocarboxylic_acid_prim_amide] := true; */
+              /* fg[fg_thiocarboxylic_acid_prim_amide] := istrue; */
+            }
             /*if (is_alkylamino(a_view,a_n)) or (is_arylamino(a_view,a_n)) then  */
             if (is_C_monosubst_amino (a_view, a_n) & (!is_subst_acylamino (a_view, a_n))) {
               /* v0.3j */
-              if (bond[get_bond (a_view, a_n) - 1].arom == false)
+              if (bond[get_bond (a_view, a_n) - 1].arom == isfalse)
-                      fg[fg_thiocarboxylic_acid_amide - 1] = true;
+                      fg[fg_thiocarboxylic_acid_amide - 1] = istrue;
-              /*fg[fg_thiocarboxylic_acid_sec_amide]  := true; */
+              /*fg[fg_thiocarboxylic_acid_sec_amide]  := istrue; */
               if (bond[get_bond (a_view, a_n) - 1].ring_count > 0) {
-                      if (bond[get_bond (a_view, a_n) - 1].arom == true) {
+                      if (bond[get_bond (a_view, a_n) - 1].arom == istrue) {
-                        /*fg[fg_thiolactam_heteroarom] := true else fg[fg_thiolactam] := true; */
+                        /*fg[fg_thiolactam_heteroarom] := istrue else fg[fg_thiolactam] := istrue; */
-                        fg[fg_thioxohetarene - 1] = true;
+                        fg[fg_thioxohetarene - 1] = istrue;
+                    }
                     else
-                      fg[fg_thiolactam - 1] = true;
+                      fg[fg_thiolactam - 1] = istrue;
+                  }
+          }
           /*if (is_dialkylamino(a_view,a_n)) or (is_alkylarylamino(a_view,a_n)) or */
           /*   (is_diarylamino(a_view,a_n)) then  */
           if (is_C_disubst_amino (a_view, a_n) & (!is_subst_acylamino (a_view, a_n))) {
             /* v0.3j */
-            if (bond[get_bond (a_view, a_n) - 1].arom == false)
+            if (bond[get_bond (a_view, a_n) - 1].arom == isfalse)
-                    fg[fg_thiocarboxylic_acid_amide - 1] = true;
+                    fg[fg_thiocarboxylic_acid_amide - 1] = istrue;
-              /*fg[fg_thiocarboxylic_acid_tert_amide] := true; */
+              /*fg[fg_thiocarboxylic_acid_tert_amide] := istrue; */
             if (bond[get_bond (a_view, a_n) - 1].ring_count > 0) {
-                    if (bond[get_bond (a_view, a_n) - 1].arom == true) {
+                    if (bond[get_bond (a_view, a_n) - 1].arom == istrue) {
-                      /*fg[fg_thiolactam_heteroarom] := true else fg[fg_thiolactam] := true; */
+                      /*fg[fg_thiolactam_heteroarom] := istrue else fg[fg_thiolactam] := istrue; */
-                      fg[fg_thioxohetarene - 1] = true;
+                      fg[fg_thioxohetarene - 1] = istrue;
+                    }
                     else
-                      fg[fg_thiolactam - 1] = true;
+                      fg[fg_thiolactam - 1] = istrue;
+                  }
+          }
+        }
   if (s_count == 1) {                   /* anhydride is checked somewhere else */
-          if (bond[get_bond (a_view, a_s) - 1].arom == false)
+          if (bond[get_bond (a_view, a_s) - 1].arom == isfalse)
-            fg[fg_thiocarboxylic_acid_deriv - 1] = true;
+            fg[fg_thiocarboxylic_acid_deriv - 1] = istrue;
           if (is_sulfanyl (a_view, a_s))
-            fg[fg_thiocarboxylic_acid - 1] = true;
+            fg[fg_thiocarboxylic_acid - 1] = istrue;
           if (is_alkylsulfanyl (a_view, a_s) || is_arylsulfanyl (a_view, a_s)) {
-      if (bond[get_bond (a_view, a_s) - 1].arom == false)
+      if (bond[get_bond (a_view, a_s) - 1].arom == isfalse)
-                    fg[fg_thiocarboxylic_acid_ester - 1] = true;
+                    fg[fg_thiocarboxylic_acid_ester - 1] = istrue;
               if (bond[get_bond (a_view, a_s) - 1].ring_count > 0) {
-                      if (bond[get_bond (a_view, a_s) - 1].arom == true) {
+                      if (bond[get_bond (a_view, a_s) - 1].arom == istrue) {
-                        /*fg[fg_thiolactone_heteroarom] := true else fg[fg_thiolactone] := true; */
+                        /*fg[fg_thiolactone_heteroarom] := istrue else fg[fg_thiolactone] := istrue; */
-                        fg[fg_thioxohetarene - 1] = true;
+                        fg[fg_thioxohetarene - 1] = istrue;
+                      }
                       else
-                        fg[fg_thiolactone - 1] = true;
+                        fg[fg_thiolactone - 1] = istrue;
+                    }
+            }
+          }
   }                             /* end Thioxo-C */
-  if (is_true_imino_C (a_view)) {
+  if (is_istrue_imino_C (a_view)) {
     if (o_count == 1) {
-            if (bond[get_bond (a_view, a_o) - 1].arom == false)
+            if (bond[get_bond (a_view, a_o) - 1].arom == isfalse)
-              fg[fg_carboxylic_acid_deriv - 1] = true;
+              fg[fg_carboxylic_acid_deriv - 1] = istrue;
             if (is_alkoxy (a_view, a_o) || is_aryloxy (a_view, a_o)) {
-              if (bond[get_bond (a_view, a_o) - 1].arom == false)
+              if (bond[get_bond (a_view, a_o) - 1].arom == isfalse)
-                      fg[fg_imido_ester - 1] = true;
+                      fg[fg_imido_ester - 1] = istrue;
+            }
+          }
-    if ((n_count == 1) && (bond[get_bond (a_view, a_n) - 1].arom == false)) {
+    if ((n_count == 1) && (bond[get_bond (a_view, a_n) - 1].arom == isfalse)) {
-            if (bond[get_bond (a_view, a_n) - 1].arom == false)
+            if (bond[get_bond (a_view, a_n) - 1].arom == isfalse)
-              fg[fg_carboxylic_acid_deriv - 1] = true;
+              fg[fg_carboxylic_acid_deriv - 1] = istrue;
             if (is_amino (a_view, a_n) || is_subst_amino (a_view, a_n)) {
-              if (bond[get_bond (a_view, a_n) - 1].arom == false)
+              if (bond[get_bond (a_view, a_n) - 1].arom == isfalse)
-                      fg[fg_carboxylic_acid_deriv - 1] = true;
+                      fg[fg_carboxylic_acid_deriv - 1] = istrue;
-              fg[fg_carboxylic_acid_amidine - 1] = true;
+              fg[fg_carboxylic_acid_amidine - 1] = istrue;
+            }
             if (is_hydrazino (a_view, a_n)) {
-              if (bond[get_bond (a_view, a_n) - 1].arom == false)
+              if (bond[get_bond (a_view, a_n) - 1].arom == isfalse)
-                      fg[fg_carboxylic_acid_amidrazone - 1] = true;
+                      fg[fg_carboxylic_acid_amidrazone - 1] = istrue;
+            }
+          }
-    if ((n_count == 1) && (bond[get_bond (a_view, a_n) - 1].arom == true))
+    if ((n_count == 1) && (bond[get_bond (a_view, a_n) - 1].arom == istrue))
             /* catches also pyridazines, 1,2,3-triazines, etc. */
-          fg[fg_iminohetarene - 1] = true;
+          fg[fg_iminohetarene - 1] = istrue;
     if (s_count == 1) {
-            if (bond[get_bond (a_view, a_s) - 1].arom == false)
+            if (bond[get_bond (a_view, a_s) - 1].arom == isfalse)
-              fg[fg_carboxylic_acid_deriv - 1] = true;
+              fg[fg_carboxylic_acid_deriv - 1] = istrue;
             if (is_alkylsulfanyl (a_view, a_s) || is_arylsulfanyl (a_view, a_s)) {
-              if (bond[get_bond (a_view, a_s) - 1].arom == false)
+              if (bond[get_bond (a_view, a_s) - 1].arom == isfalse)
-                 fg[fg_imido_thioester - 1] = true;
+                 fg[fg_imido_thioester - 1] = istrue;
+            }
+          }
+  }
   if (is_hydroximino_C (a_view)) {
-    if (bond[get_bond (a_view, a_n) - 1].arom == false)
+    if (bond[get_bond (a_view, a_n) - 1].arom == isfalse)
-            fg[fg_carboxylic_acid_deriv - 1] = true;
+            fg[fg_carboxylic_acid_deriv - 1] = istrue;
       if (o_count == 1) {
               if (is_hydroxy (a_view, a_o))
-                fg[fg_hydroxamic_acid - 1] = true;
+                fg[fg_hydroxamic_acid - 1] = istrue;
+            }
+    }
     if (!is_hydrazono_C (a_view))
       return;
-    if (bond[get_bond (a_view, a_n) - 1].arom == false)
+    if (bond[get_bond (a_view, a_n) - 1].arom == isfalse)
-      fg[fg_carboxylic_acid_deriv - 1] = true;
+      fg[fg_carboxylic_acid_deriv - 1] = istrue;
     if (n_count == 1) {
         if (is_amino (a_view, a_n) || is_subst_amino (a_view, a_n))
-          fg[fg_carboxylic_acid_amidrazone - 1] = true;
+          fg[fg_carboxylic_acid_amidrazone - 1] = istrue;
+  }
+}
 static void chk_co2_sp2 (int a_view, int a_ref)
+{
+            }
+          }
+  }
   if (is_oxo_C (a_view)) {
       if (o_count == 2) {
-              fg[fg_carbonic_acid_deriv - 1] = true;
+              fg[fg_carbonic_acid_deriv - 1] = istrue;
               if (or_count == 1)
-                fg[fg_carbonic_acid_monoester - 1] = true;
+                fg[fg_carbonic_acid_monoester - 1] = istrue;
               if (or_count == 2)
-                fg[fg_carbonic_acid_diester - 1] = true;
+                fg[fg_carbonic_acid_diester - 1] = istrue;
+            }
       if (o_count == 1 && s_count == 1) {
-              fg[fg_thiocarbonic_acid_deriv - 1] = true;
+              fg[fg_thiocarbonic_acid_deriv - 1] = istrue;
               if (or_count + sr_count == 1)
-                fg[fg_thiocarbonic_acid_monoester - 1] = true;
+                fg[fg_thiocarbonic_acid_monoester - 1] = istrue;
               if (or_count + sr_count == 2)
-                fg[fg_thiocarbonic_acid_diester - 1] = true;
+                fg[fg_thiocarbonic_acid_diester - 1] = istrue;
+            }
       if (s_count == 2) {
-              fg[fg_thiocarbonic_acid_deriv - 1] = true;
+              fg[fg_thiocarbonic_acid_deriv - 1] = istrue;
               if (sr_count == 1)
-                fg[fg_thiocarbonic_acid_monoester - 1] = true;
+                fg[fg_thiocarbonic_acid_monoester - 1] = istrue;
               if (sr_count == 2)
-                fg[fg_thiocarbonic_acid_diester - 1] = true;
+                fg[fg_thiocarbonic_acid_diester - 1] = istrue;
+            }
       if (o_count == 1 && n_count == 1) {
-              fg[fg_carbamic_acid_deriv - 1] = true;
+              fg[fg_carbamic_acid_deriv - 1] = istrue;
               if (or_count == 0)
-                fg[fg_carbamic_acid - 1] = true;
+                fg[fg_carbamic_acid - 1] = istrue;
               if (or_count == 1)
-                fg[fg_carbamic_acid_ester - 1] = true;
+                fg[fg_carbamic_acid_ester - 1] = istrue;
+            }
       if (s_count == 1 && n_count == 1) {
-              fg[fg_thiocarbamic_acid_deriv - 1] = true;
+              fg[fg_thiocarbamic_acid_deriv - 1] = istrue;
               if (sr_count == 0)
-                fg[fg_thiocarbamic_acid - 1] = true;
+                fg[fg_thiocarbamic_acid - 1] = istrue;
               if (sr_count == 1)
-                fg[fg_thiocarbamic_acid_ester - 1] = true;
+                fg[fg_thiocarbamic_acid_ester - 1] = istrue;
+            }
       if (n_count == 2) {
             if (nn_count == 1)
-              fg[fg_semicarbazide - 1] = true;
+              fg[fg_semicarbazide - 1] = istrue;
             else {
               if (nnx_count == 0)       /* excludes semicarbazones */
-                      fg[fg_urea - 1] = true;
+                      fg[fg_urea - 1] = istrue;
+            }
+          }
   }                             /* end Oxo-C */
   if (is_thioxo_C (a_view)) {
       if (o_count == 2) {
-              fg[fg_thiocarbonic_acid_deriv - 1] = true;
+              fg[fg_thiocarbonic_acid_deriv - 1] = istrue;
               if (or_count == 1)
-                fg[fg_thiocarbonic_acid_monoester - 1] = true;
+                fg[fg_thiocarbonic_acid_monoester - 1] = istrue;
               if (or_count == 2)
-                fg[fg_thiocarbonic_acid_diester - 1] = true;
+                fg[fg_thiocarbonic_acid_diester - 1] = istrue;
+            }
       if (o_count == 1 && s_count == 1) {
-              fg[fg_thiocarbonic_acid_deriv - 1] = true;
+              fg[fg_thiocarbonic_acid_deriv - 1] = istrue;
               if (or_count + sr_count == 1)
-                fg[fg_thiocarbonic_acid_monoester - 1] = true;
+                fg[fg_thiocarbonic_acid_monoester - 1] = istrue;
               if (or_count + sr_count == 2)
-                fg[fg_thiocarbonic_acid_diester - 1] = true;
+                fg[fg_thiocarbonic_acid_diester - 1] = istrue;
+            }
       if (s_count == 2) {
-              fg[fg_thiocarbonic_acid_deriv - 1] = true;
+              fg[fg_thiocarbonic_acid_deriv - 1] = istrue;
               if (sr_count == 1)
-                fg[fg_thiocarbonic_acid_monoester - 1] = true;
+                fg[fg_thiocarbonic_acid_monoester - 1] = istrue;
               if (sr_count == 2)
-                fg[fg_thiocarbonic_acid_diester - 1] = true;
+                fg[fg_thiocarbonic_acid_diester - 1] = istrue;
+            }
       if (o_count == 1 && n_count == 1) {
-              fg[fg_thiocarbamic_acid_deriv - 1] = true;
+              fg[fg_thiocarbamic_acid_deriv - 1] = istrue;
               if (or_count == 0)
-                fg[fg_thiocarbamic_acid - 1] = true;
+                fg[fg_thiocarbamic_acid - 1] = istrue;
               if (or_count == 1)
-                fg[fg_thiocarbamic_acid_ester - 1] = true;
+                fg[fg_thiocarbamic_acid_ester - 1] = istrue;
+            }
       if (s_count == 1 && n_count == 1) {
-              fg[fg_thiocarbamic_acid_deriv - 1] = true;
+              fg[fg_thiocarbamic_acid_deriv - 1] = istrue;
               if (sr_count == 0)
-                fg[fg_thiocarbamic_acid - 1] = true;
+                fg[fg_thiocarbamic_acid - 1] = istrue;
               if (sr_count == 1)
-                fg[fg_thiocarbamic_acid_ester - 1] = true;
+                fg[fg_thiocarbamic_acid_ester - 1] = istrue;
+            }
       if (n_count == 2) {
             if (nn_count == 1)
-              fg[fg_thiosemicarbazide - 1] = true;
+              fg[fg_thiosemicarbazide - 1] = istrue;
             else {
               if (nnx_count == 0)       /* excludes thiosemicarbazones */
-                      fg[fg_thiourea - 1] = true;
+                      fg[fg_thiourea - 1] = istrue;
+            }
+          }
   }                             /* end Thioxo-C */
-  if (!(is_true_imino_C (a_view) &&
+  if (!(is_istrue_imino_C (a_view) &&
-       (bond[get_bond (a_view, a_ref) - 1].arom == false))) {
+       (bond[get_bond (a_view, a_ref) - 1].arom == isfalse))) {
       return;
   }                             /* end Imino-C */
   if (o_count == 1 && n_count == 1)
-    fg[fg_isourea - 1] = true;
+    fg[fg_isourea - 1] = istrue;
   if (s_count == 1 && n_count == 1)
-    fg[fg_isothiourea - 1] = true;
+    fg[fg_isothiourea - 1] = istrue;
   if (n_count == 2)
-    fg[fg_guanidine - 1] = true;
+    fg[fg_guanidine - 1] = istrue;
+}
 static void chk_co2_sp (int a_view, int a_ref)
+{
   int i;
                       s_count++;
+            }
+          }
+  }
   if (o_count + s_count == 2)   /* new in v0.3b */
-    fg[fg_co2_deriv - 1] = true;
+    fg[fg_co2_deriv - 1] = istrue;
   if (o_count == 1 && n_count == 1)
-    fg[fg_isocyanate - 1] = true;
+    fg[fg_isocyanate - 1] = istrue;
   if (s_count == 1 && n_count == 1)
-    fg[fg_isothiocyanate - 1] = true;
+    fg[fg_isothiocyanate - 1] = istrue;
   if (n_count == 2)
-    fg[fg_carbodiimide - 1] = true;
+    fg[fg_carbodiimide - 1] = istrue;
+}
 static void chk_triple(int a1,int a2)
+{
   str2 a1_el, a2_el;
   strcpy (a1_el, atom[a1 - 1].element);
   strcpy (a2_el, atom[a2 - 1].element);
   if ((!strcmp (a1_el, "C ") && !strcmp (a2_el, "C ")) &&
-      (bond[get_bond (a1, a2) - 1].arom == false))
+      (bond[get_bond (a1, a2) - 1].arom == isfalse))
-    fg[fg_alkyne - 1] = true;
+    fg[fg_alkyne - 1] = istrue;
   if (is_nitrile (a1, a2))
-    fg[fg_nitrile - 1] = true;
+    fg[fg_nitrile - 1] = istrue;
   if (is_isonitrile (a1, a2))
-    fg[fg_isonitrile - 1] = true;
+    fg[fg_isonitrile - 1] = istrue;
   if (is_cyanate (a1, a2))
-    fg[fg_cyanate - 1] = true;
+    fg[fg_cyanate - 1] = istrue;
   if (is_thiocyanate (a1, a2))
-    fg[fg_thiocyanate - 1] = true;
+    fg[fg_thiocyanate - 1] = istrue;
+}
 static void chk_ccx (int a_view, int a_ref)
+{
   int i;
               !strcmp (atom[nb[i] - 1].atype, "NAM"))
             n_count++;
+          }
+  }
   if (oh_count == 1)
-    fg[fg_enol - 1] = true;
+    fg[fg_enol - 1] = istrue;
   if (or_count == 1)
-    fg[fg_enolether - 1] = true;
+    fg[fg_enolether - 1] = istrue;
   if (n_count == 1)
-    fg[fg_enamine - 1] = true;
+    fg[fg_enamine - 1] = istrue;
   /* new in v0.2f   (regard anything else as an alkene) */
   if (oh_count + or_count + n_count == 0)
-    fg[fg_alkene - 1] = true;
+    fg[fg_alkene - 1] = istrue;
+}
 static void chk_xccx (int a_view, int a_ref)
+{
   int i;
                 !strcmp (atom[nb[i] - 1].atype, "NAM"))
               n_count++;
+          }
+  }
   if (oh_count == 2)
-    fg[fg_enediol - 1] = true;
+    fg[fg_enediol - 1] = istrue;
   /* new in v0.2f   (regard anything else as an alkene) */
   if (oh_count + or_count + n_count == 0)
-    fg[fg_alkene - 1] = true;
+    fg[fg_alkene - 1] = istrue;
+}
 static void chk_n_o_dbl(int a1,int a2)
+{
   int i;
             b = get_bond (a1, nb[i]);   /* v0.3j */
             strcpy (nb_el, atom[nb[i] - 1].element);
             bt = bond[b - 1].btype;     /* v0.3k */
             if (strcmp (nb_el, "C ") && strcmp (nb_el, "H ")
                 /*&&  strcmp (nb_el, "D ") */  && strcmp (nb_el, "DU")
-                && strcmp (nb_el, "LP") && bond[b - 1].arom == false)
+                && strcmp (nb_el, "LP") && bond[b - 1].arom == isfalse)
                 /* added 'D ' in v0.3n */
               het_count++;
             /* v0.3k: ignore hetero atoms */
             /* in aromatic rings like isoxazole  */
             if (bt == 'S')
+          }
+  }
   if (or_count + n_count + c_count == 1 && atom[a1 - 1].neighbor_count == 2) {
     /* excludes nitro etc. */
     if (or_count == 1)
-            fg[fg_nitrite - 1] = true;
+            fg[fg_nitrite - 1] = istrue;
     if (c_count == 1)
-            fg[fg_nitroso_compound - 1] = true;
+            fg[fg_nitroso_compound - 1] = istrue;
     if (n_count == 1)           /* instead of nitrosamine  v0.3j */
-            fg[fg_nitroso_compound - 1] = true;
+            fg[fg_nitroso_compound - 1] = istrue;
-    /*if (n_count = 1) then fg[fg_nitrosamine]   := true;  (* still missing */
+    /*if (n_count = 1) then fg[fg_nitrosamine]   := istrue;  (* still missing */
+  }
   /*if ((c_count > 1) and (or_count = 0) and (n_count = 0)) then */
   /*  begin */
-  /*    fg[fg_n_oxide] := true; */
+  /*    fg[fg_n_oxide] := istrue; */
   /*  end; */
   /* new approach in v0.3k */
   if (het_count == 0 && bo_sum > 2)     /* =O does not count! */
-    fg[fg_n_oxide - 1] = true;
+    fg[fg_n_oxide - 1] = istrue;
+}
 static void chk_sulfoxide(int a1,int a2)
+{
   int i;
             o_count++;
     if (is_alkyl (a1, nb[i]) || is_aryl (a1, nb[i]))
             c_count++;
+  }
   if (o_count == 1 && c_count == 2)
-    fg[fg_sulfoxide - 1] = true;
+    fg[fg_sulfoxide - 1] = istrue;
+}
 static void chk_double(int a1,int a2)
+{
   str2 a1_el, a2_el;
   strcpy (a1_el, atom[a1 - 1].element);
   strcpy (a2_el, atom[a2 - 1].element);
   if ((!strcmp (a1_el, "C ") && strcmp (a2_el, "C ")) &&
-      (bond[get_bond (a1, a2) - 1].arom == false)) {
+      (bond[get_bond (a1, a2) - 1].arom == isfalse)) {
     if (hetbond_count (a1) == 2)
             chk_carbonyl_deriv (a1, a2);
     if (hetbond_count (a1) == 3)
             chk_carboxyl_deriv (a1, a2);
     if (hetbond_count (a1) == 4) {
               chk_co2_sp (a1, a2);
+          }
   }                             /* end C=X */
   if ((!strcmp (atom[a1 - 1].atype, "C2 ")
        && !strcmp (atom[a2 - 1].atype,
-                   "C2 ")) && (bond[get_bond (a1, a2) - 1].arom == false)) {
+                   "C2 ")) && (bond[get_bond (a1, a2) - 1].arom == isfalse)) {
     if ((hetbond_count (a1) == 0) && (hetbond_count (a2) == 2))
-            fg[fg_ketene_acetal_deriv - 1] = true;
+            fg[fg_ketene_acetal_deriv - 1] = istrue;
     if ((hetbond_count (a1) == 0) && (hetbond_count (a2) == 1))
             chk_ccx (a1, a2);
     if ((hetbond_count (a1) == 1) && (hetbond_count (a2) == 1))
             chk_xccx (a1, a2);
     if (((hetbond_count (a1) == 0) && (hetbond_count (a2) == 0)) &&
-              atom[a1 - 1].arom == false && atom[a2 - 1].arom == false)
+              atom[a1 - 1].arom == isfalse && atom[a2 - 1].arom == isfalse)
-            fg[fg_alkene - 1] = true;
+            fg[fg_alkene - 1] = istrue;
+  }
   if (((!strcmp (a1_el, "N ") && !strcmp (a2_el, "N "))
       && (hetbond_count (a1) == 2) && (hetbond_count (a2) == 2)
-      && (bond[get_bond (a1, a2) - 1].arom == false))
+      && (bond[get_bond (a1, a2) - 1].arom == isfalse))
       && atom[a1 - 1].neighbor_count == 2 && atom[a2 - 1].neighbor_count == 2)
-    fg[fg_azo_compound - 1] = true;
+    fg[fg_azo_compound - 1] = istrue;
   if (!strcmp (a1_el, "N ") && !strcmp (a2_el, "O "))
     chk_n_o_dbl (a1, a2);
   if (!strcmp (a1_el, "S ") && !strcmp (a2_el, "O "))
     chk_sulfoxide (a1, a2);
+}
 static void chk_c_hal(int a1,int a2)
+{
   str2 a2_el;
   strcpy (a2_el, atom[a2 - 1].element);
-  fg[fg_halogen_deriv - 1] = true;
+  fg[fg_halogen_deriv - 1] = istrue;
   if (atom[a1 - 1].arom) {
-    fg[fg_aryl_halide - 1] = true;
+    fg[fg_aryl_halide - 1] = istrue;
     if (!strcmp (a2_el, "F "))
-            fg[fg_aryl_fluoride - 1] = true;
+            fg[fg_aryl_fluoride - 1] = istrue;
     if (!strcmp (a2_el, "CL"))
-            fg[fg_aryl_chloride - 1] = true;
+            fg[fg_aryl_chloride - 1] = istrue;
     if (!strcmp (a2_el, "BR"))
-            fg[fg_aryl_bromide - 1] = true;
+            fg[fg_aryl_bromide - 1] = istrue;
     if (!strcmp (a2_el, "I "))
-            fg[fg_aryl_iodide - 1] = true;
+            fg[fg_aryl_iodide - 1] = istrue;
     return;
+  }
   if ((strcmp (atom[a1 - 1].atype, "C3 ") == 0) && (hetbond_count (a1) <= 2)) {
     /* alkyl halides */
-    fg[fg_alkyl_halide - 1] = true;
+    fg[fg_alkyl_halide - 1] = istrue;
     if (!strcmp (a2_el, "F "))
-            fg[fg_alkyl_fluoride - 1] = true;
+            fg[fg_alkyl_fluoride - 1] = istrue;
     if (!strcmp (a2_el, "CL"))
-            fg[fg_alkyl_chloride - 1] = true;
+            fg[fg_alkyl_chloride - 1] = istrue;
     if (!strcmp (a2_el, "BR"))
-            fg[fg_alkyl_bromide - 1] = true;
+            fg[fg_alkyl_bromide - 1] = istrue;
     if (!strcmp (a2_el, "I "))
-            fg[fg_alkyl_iodide - 1] = true;
+            fg[fg_alkyl_iodide - 1] = istrue;
+  }
   if ((strcmp (atom[a1 - 1].atype, "C2 ") == 0) && (hetbond_count (a1) == 3)) {
     /* acyl halides and related compounds */
     if (is_oxo_C (a1)) {
-            fg[fg_acyl_halide - 1] = true;
+            fg[fg_acyl_halide - 1] = istrue;
             if (!strcmp (a2_el, "F "))
-              fg[fg_acyl_fluoride - 1] = true;
+              fg[fg_acyl_fluoride - 1] = istrue;
             if (!strcmp (a2_el, "CL"))
-              fg[fg_acyl_chloride - 1] = true;
+              fg[fg_acyl_chloride - 1] = istrue;
             if (!strcmp (a2_el, "BR"))
-              fg[fg_acyl_bromide - 1] = true;
+              fg[fg_acyl_bromide - 1] = istrue;
             if (!strcmp (a2_el, "I "))
-              fg[fg_acyl_iodide - 1] = true;
+              fg[fg_acyl_iodide - 1] = istrue;
+          }
     if (is_thioxo_C (a1))
-            fg[fg_thiocarboxylic_acid_deriv - 1] = true;
+            fg[fg_thiocarboxylic_acid_deriv - 1] = istrue;
     if (is_imino_C (a1))
-            fg[fg_imidoyl_halide - 1] = true;
+            fg[fg_imidoyl_halide - 1] = istrue;
+  }
   if (!((strcmp (atom[a1 - 1].atype, "C2 ") == 0)
        && (hetbond_count (a1) == 4)))
     /* chloroformates etc. */
     return;
   /* still missing: polyhalogen compounds (-CX2H, -CX3) */
-  fg[fg_co2_deriv - 1] = true;
+  fg[fg_co2_deriv - 1] = istrue;
   if (is_oxo_C (a1)) {
-      fg[fg_carbonic_acid_deriv - 1] = true;
+      fg[fg_carbonic_acid_deriv - 1] = istrue;
     if (is_alkoxycarbonyl (a2, a1) || is_aryloxycarbonyl (a2, a1))
-            fg[fg_carbonic_acid_ester_halide - 1] = true;
+            fg[fg_carbonic_acid_ester_halide - 1] = istrue;
     if (is_carbamoyl (a2, a1)) {
-            fg[fg_carbamic_acid_deriv - 1] = true;
+            fg[fg_carbamic_acid_deriv - 1] = istrue;
-            fg[fg_carbamic_acid_halide - 1] = true;
+            fg[fg_carbamic_acid_halide - 1] = istrue;
+          }
+  }
   if (!is_thioxo_C (a1))
     return;
-  fg[fg_thiocarbonic_acid_deriv - 1] = true;
+  fg[fg_thiocarbonic_acid_deriv - 1] = istrue;
   if (is_alkoxythiocarbonyl (a2, a1) || is_aryloxythiocarbonyl (a2, a1))
-    fg[fg_thiocarbonic_acid_ester_halide - 1] = true;
+    fg[fg_thiocarbonic_acid_ester_halide - 1] = istrue;
   if (is_thiocarbamoyl (a2, a1)) {
-    fg[fg_thiocarbamic_acid_deriv - 1] = true;
+    fg[fg_thiocarbamic_acid_deriv - 1] = istrue;
-    fg[fg_thiocarbamic_acid_halide - 1] = true;
+    fg[fg_thiocarbamic_acid_halide - 1] = istrue;
       /* end of non-aromatic halogen compounds */
+  }
+}
 static void chk_c_o(int a1,int a2)
+{
   /* ignore heteroaromatic rings (like furan, thiophene, etc.) */
-  if (bond[get_bond (a1, a2) - 1].arom == true)
+  if (bond[get_bond (a1, a2) - 1].arom == istrue)
     return;
-  if (is_true_alkyl (a2, a1) && is_hydroxy (a1, a2)) {
+  if (is_istrue_alkyl (a2, a1) && is_hydroxy (a1, a2)) {
-    fg[fg_hydroxy - 1] = true;
+    fg[fg_hydroxy - 1] = istrue;
-    fg[fg_alcohol - 1] = true;
+    fg[fg_alcohol - 1] = istrue;
     if (atom[a1 - 1].neighbor_count <= 2)
-            fg[fg_prim_alcohol - 1] = true;
+            fg[fg_prim_alcohol - 1] = istrue;
     if (atom[a1 - 1].neighbor_count == 3)
-            fg[fg_sec_alcohol - 1] = true;
+            fg[fg_sec_alcohol - 1] = istrue;
     if (atom[a1 - 1].neighbor_count == 4)
-            fg[fg_tert_alcohol - 1] = true;
+            fg[fg_tert_alcohol - 1] = istrue;
+  }
   if (is_aryl (a2, a1) && is_hydroxy (a1, a2)) {
-    fg[fg_hydroxy - 1] = true;
+    fg[fg_hydroxy - 1] = istrue;
-    fg[fg_phenol - 1] = true;
+    fg[fg_phenol - 1] = istrue;
+  }
-  if (is_true_alkyl (a2, a1) && is_true_alkoxy (a1, a2)) {
+  if (is_istrue_alkyl (a2, a1) && is_istrue_alkoxy (a1, a2)) {
-    fg[fg_ether - 1] = true;
+    fg[fg_ether - 1] = istrue;
-    fg[fg_dialkylether - 1] = true;
+    fg[fg_dialkylether - 1] = istrue;
+  }
-  if ((is_true_alkyl (a2, a1) && is_aryloxy (a1, a2)) ||
+  if ((is_istrue_alkyl (a2, a1) && is_aryloxy (a1, a2)) ||
-      (is_aryl (a2, a1) && is_true_alkoxy (a1, a2))) {
+      (is_aryl (a2, a1) && is_istrue_alkoxy (a1, a2))) {
-    fg[fg_ether - 1] = true;
+    fg[fg_ether - 1] = istrue;
-    fg[fg_alkylarylether - 1] = true;
+    fg[fg_alkylarylether - 1] = istrue;
+  }
   if (is_aryl (a2, a1) && is_aryloxy (a1, a2)) {
-    fg[fg_ether - 1] = true;
+    fg[fg_ether - 1] = istrue;
-    fg[fg_diarylether - 1] = true;
+    fg[fg_diarylether - 1] = istrue;
+  }
-  if ((is_true_alkyl (a2, a1) || is_aryl (a2, a1)) && is_alkynyloxy (a1, a2)) {
+  if ((is_istrue_alkyl (a2, a1) || is_aryl (a2, a1)) && is_alkynyloxy (a1, a2)) {
-    fg[fg_ether - 1] = true;
+    fg[fg_ether - 1] = istrue;
-    ether_generic = true;
+    ether_generic = istrue;
+  }
   if (is_alkynyl (a2, a1) && is_hydroxy (a1, a2)) {
-    fg[fg_hydroxy - 1] = true;
+    fg[fg_hydroxy - 1] = istrue;
-    hydroxy_generic = true;
+    hydroxy_generic = istrue;
+  }
+}
 static void chk_c_s(int a1,int a2)
+{
   int o_count = 0, oh_count = 0, or_count = 0, n_count = 0, c_count = 0,
     hal_count = 0;
   int FORLIM;
   /* ignore heteroaromatic rings (like furan, thiophene, etc.) */
-  if (bond[get_bond (a1, a2) - 1].arom == true)
+  if (bond[get_bond (a1, a2) - 1].arom == istrue)
     return;
   if (is_alkyl (a2, a1) && is_sulfanyl (a1, a2)) {
-    fg[fg_thiol - 1] = true;
+    fg[fg_thiol - 1] = istrue;
-    fg[fg_alkylthiol - 1] = true;
+    fg[fg_alkylthiol - 1] = istrue;
+  }
   if (is_aryl (a2, a1) && is_sulfanyl (a1, a2)) {
-    fg[fg_thiol - 1] = true;
+    fg[fg_thiol - 1] = istrue;
-    fg[fg_arylthiol - 1] = true;
+    fg[fg_arylthiol - 1] = istrue;
+  }
-  if (is_true_alkyl (a2, a1) && is_true_alkylsulfanyl (a1, a2))
+  if (is_istrue_alkyl (a2, a1) && is_istrue_alkylsulfanyl (a1, a2))
-    fg[fg_thioether - 1] = true;
+    fg[fg_thioether - 1] = istrue;
-  if ((is_true_alkyl (a2, a1) && is_arylsulfanyl (a1, a2)) ||
+  if ((is_istrue_alkyl (a2, a1) && is_arylsulfanyl (a1, a2)) ||
-        (is_aryl (a2, a1) && is_true_alkylsulfanyl (a1, a2)))
+        (is_aryl (a2, a1) && is_istrue_alkylsulfanyl (a1, a2)))
-    fg[fg_thioether - 1] = true;
+    fg[fg_thioether - 1] = istrue;
   if (is_aryl (a2, a1) && is_arylsulfanyl (a1, a2))
-    fg[fg_thioether - 1] = true;
+    fg[fg_thioether - 1] = istrue;
   /* check for sulfinic/sulfenic acid derivatives */
   memset (nb, 0, sizeof (neighbor_rec));
   get_neighbors (nb, a2);
   FORLIM = atom[a2 - 1].neighbor_count;
   for (i = 0; i < FORLIM; i++) {
+  }
   if (c_count != 1)
     return;
   if (atom[a2 - 1].neighbor_count == 3 && o_count - oh_count - or_count == 1) {
     /* sulfinic acid && derivs */
-    fg[fg_sulfinic_acid_deriv - 1] = true;
+    fg[fg_sulfinic_acid_deriv - 1] = istrue;
     if (oh_count == 1)
-            fg[fg_sulfinic_acid - 1] = true;
+            fg[fg_sulfinic_acid - 1] = istrue;
     if (or_count == 1)
-            fg[fg_sulfinic_acid_ester - 1] = true;
+            fg[fg_sulfinic_acid_ester - 1] = istrue;
     if (hal_count == 1)
-            fg[fg_sulfinic_acid_halide - 1] = true;
+            fg[fg_sulfinic_acid_halide - 1] = istrue;
     if (n_count == 1)
-            fg[fg_sulfinic_acid_amide - 1] = true;
+            fg[fg_sulfinic_acid_amide - 1] = istrue;
+  }
   if (atom[a2 - 1].neighbor_count != 2 || o_count - oh_count - or_count != 0)
     /* sulfenic acid && derivs */
     return;
-  fg[fg_sulfenic_acid_deriv - 1] = true;
+  fg[fg_sulfenic_acid_deriv - 1] = istrue;
   if (oh_count == 1)
-    fg[fg_sulfenic_acid - 1] = true;
+    fg[fg_sulfenic_acid - 1] = istrue;
   if (or_count == 1)
-    fg[fg_sulfenic_acid_ester - 1] = true;
+    fg[fg_sulfenic_acid_ester - 1] = istrue;
   if (hal_count == 1)
-    fg[fg_sulfenic_acid_halide - 1] = true;
+    fg[fg_sulfenic_acid_halide - 1] = istrue;
   if (n_count == 1)
-    fg[fg_sulfenic_acid_amide - 1] = true;
+    fg[fg_sulfenic_acid_amide - 1] = istrue;
+}
 static void chk_c_n(int a1,int a2)
+{
   /* ignore heteroaromatic rings (like furan, thiophene, pyrrol, etc.) */
-  if (atom[a2 - 1].arom == true)
+  if (atom[a2 - 1].arom == istrue)
     return;
-  if (is_true_alkyl (a2, a1) && is_amino (a1, a2)) {
+  if (is_istrue_alkyl (a2, a1) && is_amino (a1, a2)) {
-    fg[fg_amine - 1] = true;
+    fg[fg_amine - 1] = istrue;
-    fg[fg_prim_amine - 1] = true;
+    fg[fg_prim_amine - 1] = istrue;
-    fg[fg_prim_aliph_amine - 1] = true;
+    fg[fg_prim_aliph_amine - 1] = istrue;
+    }
   if (is_aryl (a2, a1) && is_amino (a1, a2)) {
-    fg[fg_amine - 1] = true;
+    fg[fg_amine - 1] = istrue;
-    fg[fg_prim_amine - 1] = true;
+    fg[fg_prim_amine - 1] = istrue;
-    fg[fg_prim_arom_amine - 1] = true;
+    fg[fg_prim_arom_amine - 1] = istrue;
+  }
-  if (is_true_alkyl (a2, a1) && is_true_alkylamino (a1, a2)) {
+  if (is_istrue_alkyl (a2, a1) && is_istrue_alkylamino (a1, a2)) {
-    fg[fg_amine - 1] = true;
+    fg[fg_amine - 1] = istrue;
-    fg[fg_sec_amine - 1] = true;
+    fg[fg_sec_amine - 1] = istrue;
-    fg[fg_sec_aliph_amine - 1] = true;
+    fg[fg_sec_aliph_amine - 1] = istrue;
+  }
-  if (is_aryl (a2, a1) && is_true_alkylamino (a1, a2)) {
+  if (is_aryl (a2, a1) && is_istrue_alkylamino (a1, a2)) {
-    fg[fg_amine - 1] = true;
+    fg[fg_amine - 1] = istrue;
-    fg[fg_sec_amine - 1] = true;
+    fg[fg_sec_amine - 1] = istrue;
-    fg[fg_sec_mixed_amine - 1] = true;
+    fg[fg_sec_mixed_amine - 1] = istrue;
+  }
   if (is_aryl (a2, a1) && is_arylamino (a1, a2)) {
-    fg[fg_amine - 1] = true;
+    fg[fg_amine - 1] = istrue;
-    fg[fg_sec_amine - 1] = true;
+    fg[fg_sec_amine - 1] = istrue;
-    fg[fg_sec_arom_amine - 1] = true;
+    fg[fg_sec_arom_amine - 1] = istrue;
+  }
-  if (is_true_alkyl (a2, a1) && is_true_dialkylamino (a1, a2)) {
+  if (is_istrue_alkyl (a2, a1) && is_istrue_dialkylamino (a1, a2)) {
-    fg[fg_amine - 1] = true;
+    fg[fg_amine - 1] = istrue;
-    fg[fg_tert_amine - 1] = true;
+    fg[fg_tert_amine - 1] = istrue;
-    fg[fg_tert_aliph_amine - 1] = true;
+    fg[fg_tert_aliph_amine - 1] = istrue;
+  }
-  if ((is_true_alkyl (a2, a1) && is_diarylamino (a1, a2)) ||
+  if ((is_istrue_alkyl (a2, a1) && is_diarylamino (a1, a2)) ||
-      (is_aryl (a2, a1) && is_true_dialkylamino (a1, a2))) {
+      (is_aryl (a2, a1) && is_istrue_dialkylamino (a1, a2))) {
-    fg[fg_amine - 1] = true;
+    fg[fg_amine - 1] = istrue;
-    fg[fg_tert_amine - 1] = true;
+    fg[fg_tert_amine - 1] = istrue;
-    fg[fg_tert_mixed_amine - 1] = true;
+    fg[fg_tert_mixed_amine - 1] = istrue;
+  }
   if (is_aryl (a2, a1) && is_diarylamino (a1, a2)) {
-    fg[fg_amine - 1] = true;
+    fg[fg_amine - 1] = istrue;
-    fg[fg_tert_amine - 1] = true;
+    fg[fg_tert_amine - 1] = istrue;
-    fg[fg_tert_arom_amine - 1] = true;
+    fg[fg_tert_arom_amine - 1] = istrue;
+  }
   if ((is_alkyl (a2, a1) || is_aryl (a2, a1) || is_alkenyl (a2, a1) ||
-       is_alkynyl (a2, a1)) && is_hydroxylamino (a1, a2) && (is_acyl_gen (a2, a1) == false))
+       is_alkynyl (a2, a1)) && is_hydroxylamino (a1, a2) && (is_acyl_gen (a2, a1) == isfalse))
     /* v0.3k */
-    fg[fg_hydroxylamine - 1] = true;
+    fg[fg_hydroxylamine - 1] = istrue;
   /* v0.3k */
   /* v0.3k  */
   if ((is_alkyl (a2, a1) || is_aryl (a2, a1) || is_acyl (a2, a1) ||
        is_alkenyl (a2, a1) || is_alkynyl (a2, a1)) && is_hydrazino (a1, a2))
-    fg[fg_hydrazine - 1] = true;
+    fg[fg_hydrazine - 1] = istrue;
   if ((is_alkyl (a2, a1) || is_aryl (a2, a1) || is_alkenyl (a2, a1) ||
        is_alkynyl (a2, a1)) && is_azido (a1, a2))
     /* v0.3k */
-    fg[fg_azide - 1] = true;
+    fg[fg_azide - 1] = istrue;
   if ((is_alkyl (a2, a1) || is_aryl (a2, a1) || is_alkenyl (a2, a1) ||
        is_alkynyl (a2, a1)) && is_diazonium (a1, a2))
     /* v0.3k */
-    fg[fg_diazonium_salt - 1] = true;
+    fg[fg_diazonium_salt - 1] = istrue;
   if ((is_alkyl (a2, a1) || is_aryl (a2, a1) || is_alkenyl (a2, a1) |
        is_alkynyl (a2, a1)) && is_nitro (a1, a2))
     /* v0.3k */
-    fg[fg_nitro_compound - 1] = true;
+    fg[fg_nitro_compound - 1] = istrue;
   if (is_alkynyl (a2, a1) &&
         (is_amino (a1, a2) || is_C_monosubst_amino (a1, a2) |
        (is_C_disubst_amino (a1, a2) && (!is_acylamino (a1, a2))))) {
-      fg[fg_amine - 1] = true;
+      fg[fg_amine - 1] = istrue;
-      amine_generic = true;
+      amine_generic = istrue;
+  }
+}
 static void chk_c_c(int a1,int a2)
+{
   int i;
   neighbor_rec nb;
   int oh_count, nhr_count, FORLIM;
   /* ignore aromatic rings */
-  if (atom[a2 - 1].arom == true)
+  if (atom[a2 - 1].arom == istrue)
     return;
   /*check for 1,2-diols and 1,2-aminoalcoholes */
   if (!strcmp (atom[a1 - 1].atype, "C3 ")
         && !strcmp (atom[a2 - 1].atype, "C3 ")) {
       if ((hetbond_count (a1) == 1) && (hetbond_count (a2) == 1)) {
                           is_arylamino (a2, nb[i]))
                         nhr_count++;
+                    }
+            }
             if (oh_count == 2)
-              fg[fg_1_2_diol - 1] = true;
+              fg[fg_1_2_diol - 1] = istrue;
             if (oh_count == 1 && nhr_count == 1)
-              fg[fg_1_2_aminoalcohol - 1] = true;
+              fg[fg_1_2_aminoalcohol - 1] = istrue;
+          }
+  }
   /* check for alpha-aminoacids and alpha-hydroxyacids */
   if (strcmp (atom[a1 - 1].atype, "C3 ")
       || strcmp (atom[a2 - 1].atype, "C2 "))
             if (is_hydroxy (a2, nb[i]))
               oh_count++;
+          }
+  }
   if ((oh_count == 2) && is_oxo_C (a2))
-    fg[fg_alpha_hydroxyacid - 1] = true;
+    fg[fg_alpha_hydroxyacid - 1] = istrue;
   if ((oh_count == 1 && nhr_count == 1) && is_oxo_C (a2))
-    fg[fg_alpha_aminoacid - 1] = true;
+    fg[fg_alpha_aminoacid - 1] = istrue;
+}
 static void chk_x_y_single (int a_view, int a_ref)
+{
   if (!strcmp (atom[a_view - 1].atype, "O3 ") &&
         !strcmp (atom[a_ref - 1].atype, "O3 ")) {
     if (is_hydroxy (a_ref, a_view) || is_hydroxy (a_view, a_ref))
-            fg[fg_hydroperoxide - 1] = true;
+            fg[fg_hydroperoxide - 1] = istrue;
     if ((is_alkoxy (a_ref, a_view) || is_aryloxy (a_ref, a_view) |
               is_siloxy (a_ref, a_view)) && (is_alkoxy (a_view,a_ref) |
                         is_aryloxy (a_view, a_ref) |
                         is_siloxy (a_view, a_ref)))
-            fg[fg_peroxide - 1] = true;
+            fg[fg_peroxide - 1] = istrue;
   }                             /* still missing: peracid */
   if (!strcmp (atom[a_view - 1].atype, "S3 ") &&
       !strcmp (atom[a_ref - 1].atype, "S3 ")) {
       if (atom[a_view - 1].neighbor_count == 2 &&
           atom[a_ref - 1].neighbor_count == 2)
-          fg[fg_disulfide - 1] = true;
+          fg[fg_disulfide - 1] = istrue;
+  }
   if ((!strcmp (atom[a_view - 1].element, "N ") &&
        !strcmp (atom[a_ref - 1].element, "N ")) && (hetbond_count (a_view) == 1)
       && (hetbond_count (a_ref) == 1)) {
       /*if ((is_amino(a_ref,a_view)) or  */
       /*    (is_subst_amino(a_ref,a_view)) or */
       /*    (is_acylamino(a_ref,a_view))) and */
       /*   ((is_amino(a_view,a_ref)) or  */
       /*    (is_subst_amino(a_view,a_ref)) or */
       /*    (is_acylamino(a_ref,a_view))) then  */
-      if (bond[get_bond (a_view, a_ref) - 1].arom == false)
+      if (bond[get_bond (a_view, a_ref) - 1].arom == isfalse)
-              fg[fg_hydrazine - 1] = true;
+              fg[fg_hydrazine - 1] = istrue;
+  }
   if (!strcmp (atom[a_view - 1].element, "N ") &&
       !strcmp (atom[a_ref - 1].atype, "O3 ")) {
     /* bond is in "opposite" direction */
     if ((is_alkoxy (a_view, a_ref) || is_aryloxy (a_view, a_ref)) &&
               is_nitro (a_ref, a_view))
-            fg[fg_nitrate - 1] = true;
+            fg[fg_nitrate - 1] = istrue;
-    if ((is_nitro (a_ref, a_view) == false
+    if ((is_nitro (a_ref, a_view) == isfalse
-              && atom[a_view - 1].arom == false) && (is_amino (a_ref, a_view) |
+              && atom[a_view - 1].arom == isfalse) && (is_amino (a_ref, a_view) |
                     is_subst_amino (a_ref, a_view)) &&
-              (is_acylamino (a_ref, a_view) == false))
+              (is_acylamino (a_ref, a_view) == isfalse))
-            fg[fg_hydroxylamine - 1] = true;    /* new in v0.3c */
+            fg[fg_hydroxylamine - 1] = istrue;  /* new in v0.3c */
+  }
   if (!strcmp (atom[a_view - 1].element, "S ") &&
       !strcmp (atom[a_ref - 1].element, "O "))
     chk_sulfoxide (a_view, a_ref);
+}
     chk_c_o (a1, a2);
   if (!strcmp (a1_el, "C ") && !strcmp (a2_el, "S "))
     chk_c_s (a1, a2);
   if (!strcmp (a1_el, "C ") && !strcmp (a2_el, "N "))
     chk_c_n (a1, a2);
-  if ((strcmp (a1_el, "C ") == 0) && atom[a2 - 1].metal && (is_cyano_c (a1) == false)) {
+  if ((strcmp (a1_el, "C ") == 0) && atom[a2 - 1].metal && (is_cyano_c (a1) == isfalse)) {
-      fg[fg_organometallic - 1] = true;
+      fg[fg_organometallic - 1] = istrue;
       if (!strcmp (a2_el, "LI"))
-              fg[fg_organolithium - 1] = true;
+              fg[fg_organolithium - 1] = istrue;
       if (!strcmp (a2_el, "MG"))
-              fg[fg_organomagnesium - 1] = true;
+              fg[fg_organomagnesium - 1] = istrue;
+  }
   if (!strcmp (a1_el, "C ") && !strcmp (a2_el, "C "))
     chk_c_c (a1, a2);
   if (strcmp (a1_el, "C ") && strcmp (a2_el, "C "))
     chk_x_y_single (a1, a2);
             sr_count++;
     if (!strcmp (atom[nb[i] - 1].atype, "N3 ") || !strcmp (atom[nb[i] - 1].atype, "NAM"))
             n_count++;
+  }
   if (oh_count == 2)
-    fg[fg_carbonyl_hydrate - 1] = true;
+    fg[fg_carbonyl_hydrate - 1] = istrue;
   if (oh_count == 1 && or_count == 1)
-    fg[fg_hemiacetal - 1] = true;
+    fg[fg_hemiacetal - 1] = istrue;
   if (or_count == 2)
-    fg[fg_acetal - 1] = true;
+    fg[fg_acetal - 1] = istrue;
   if ((oh_count == 1 || or_count == 1) && n_count == 1)
-    fg[fg_hemiaminal - 1] = true;
+    fg[fg_hemiaminal - 1] = istrue;
   if (n_count == 2)
-    fg[fg_aminal - 1] = true;
+    fg[fg_aminal - 1] = istrue;
   if ((sh_count == 1 || sr_count == 1) && n_count == 1)
-    fg[fg_thiohemiaminal - 1] = true;
+    fg[fg_thiohemiaminal - 1] = istrue;
   if (sr_count == 2 || (or_count == 1 && sr_count == 1))
-    fg[fg_thioacetal - 1] = true;
+    fg[fg_thioacetal - 1] = istrue;
+}
 static void chk_carboxyl_deriv_sp3 (int a_ref)
+{
   int i;
             oh_count++;
     if (!strcmp (atom[nb[i] - 1].atype, "N3 ") ||
               !strcmp (atom[nb[i] - 1].atype, "NAM"))
             n_count++;
+  }
-  /*if (or_count + n_count > 1) then fg[fg_orthocarboxylic_acid_deriv] := true;  (* until v0.3i */
+  /*if (or_count + n_count > 1) then fg[fg_orthocarboxylic_acid_deriv] := istrue;  (* until v0.3i */
   if (electroneg_count == 3 && hal_count < 3)   /* v0.3j */
-    fg[fg_orthocarboxylic_acid_deriv - 1] = true;
+    fg[fg_orthocarboxylic_acid_deriv - 1] = istrue;
   if (or_count == 3)
-    fg[fg_carboxylic_acid_orthoester - 1] = true;
+    fg[fg_carboxylic_acid_orthoester - 1] = istrue;
   if (or_count == 2 && n_count == 1)
-    fg[fg_carboxylic_acid_amide_acetal - 1] = true;
+    fg[fg_carboxylic_acid_amide_acetal - 1] = istrue;
   if (oh_count > 0 && oh_count + or_count + n_count == 3)       /* new in v0.3c */
-    fg[fg_orthocarboxylic_acid_deriv - 1] = true;
+    fg[fg_orthocarboxylic_acid_deriv - 1] = istrue;
+}
 static void chk_anhydride (int a_ref)
+{
   int i;
   for (i = 0; i < FORLIM; i++) {
     if (is_acyl (a_ref, nb[i]) || is_carbamoyl (a_ref, nb[i]))
             acyl_count++;
+  }
   if (acyl_count == 2 && !strcmp (atom[a_ref - 1].atype, "O3 ")) {
-    fg[fg_carboxylic_acid_deriv - 1] = true;
+    fg[fg_carboxylic_acid_deriv - 1] = istrue;
-    fg[fg_carboxylic_acid_anhydride - 1] = true;
+    fg[fg_carboxylic_acid_anhydride - 1] = istrue;
+  }
+}
 static void chk_imide (int a_ref)
+{
             acyl_count++;
+  }
   if (acyl_count < 2 || strcmp (atom[a_ref - 1].element, "N "))
     /* v0.3j: accept also N-acyl-imides */
     return;
-  fg[fg_carboxylic_acid_deriv - 1] = true;
+  fg[fg_carboxylic_acid_deriv - 1] = istrue;
-  fg[fg_carboxylic_acid_imide - 1] = true;
+  fg[fg_carboxylic_acid_imide - 1] = istrue;
   if (atom[a_ref - 1].neighbor_count == 2)
-    fg[fg_carboxylic_acid_unsubst_imide - 1] = true;
+    fg[fg_carboxylic_acid_unsubst_imide - 1] = istrue;
   if (atom[a_ref - 1].neighbor_count == 3)
-    fg[fg_carboxylic_acid_subst_imide - 1] = true;
+    fg[fg_carboxylic_acid_subst_imide - 1] = istrue;
+}
 static void chk_12diphenol (int a_view, int a_ref)
+{
   int i;
             if (is_hydroxy (a_ref, nb[i]))
               oh_count++;
+          }
+  }
   if (oh_count == 2)
-    fg[fg_1_2_diphenol - 1] = true;
+    fg[fg_1_2_diphenol - 1] = istrue;
+}
 static void chk_arom_fg (int a1, int a2)
+{
   if ((hetbond_count (a1) == 1) && (hetbond_count (a2) == 1))
+}
 static boolean is_arene (int r_id)
+{
   int i, j;
-  boolean r = true;
+  boolean r = istrue;
   ringpath_type testring;
   int ring_size, a_prev, a_ref;
 /* p2c: checkmol.pas: Note: Eliminated unused assignment statement [338] */
   if (r_id < 1 || r_id > n_rings)
-    return false;
+    return isfalse;
   memset (testring, 0, sizeof (ringpath_type));
   ring_size = ringprop[r_id - 1].size;  /* v0.3j */
   /*for j := 1 to max_ringsize do if ring^[r_id,j] > 0 then testring[j] := ring^[r_id,j]; */
   for (j = 0; j < ring_size; j++)       /* v0.3j */
     testring[j] = ring[r_id - 1][j];
   /*ring_size := path_length(testring); */
   if (ring_size <= 2)
-    return false;
+    return isfalse;
   a_prev = testring[ring_size - 1];
   for (i = 0; i < ring_size; i++) {
     a_ref = testring[i];
-    if (bond[get_bond (a_prev, a_ref) - 1].arom == false)
+    if (bond[get_bond (a_prev, a_ref) - 1].arom == isfalse)
-            r = false;
+            r = isfalse;
     a_prev = a_ref;
+  }
   return r;
+}
 static boolean is_heterocycle (int r_id)
+{
   int i, j;
-  boolean r = false;
+  boolean r = isfalse;
   ringpath_type testring;
   int ring_size, a_ref;
   if (r_id < 1 || r_id > n_rings)
-    return false;
+    return isfalse;
   memset (testring, 0, sizeof (ringpath_type));
   ring_size = ringprop[r_id - 1].size;  /* v0.3j */
   /*for j := 1 to max_ringsize do if ring^[r_id,j] > 0 then testring[j] := ring^[r_id,j]; */
   for (j = 0; j < ring_size; j++)       /* v0.3j */
     testring[j] = ring[r_id - 1][j];
   /*ring_size := path_length(testring); */
   if (ring_size <= 2)
-    return false;
+    return isfalse;
   for (i = 0; i < ring_size; i++) {
     a_ref = testring[i];
     if (strcmp (atom[a_ref - 1].element, "C "))
-            r = true;
+            r = istrue;
+  }
   return r;
+}
 static void chk_oxo_thioxo_imino_hetarene (int r_id)
   ring_size = ringprop[r_id - 1].size;  /* v0.3j */
   /*for j := 1 to max_ringsize do if ring^[r_id,j] > 0 then testring[j] := ring^[r_id,j]; */
   for (j = 0; j < ring_size; j++)       /* v0.3j */
     testring[j] = ring[r_id - 1][j];
   /*ring_size := path_length(testring); */
-  /*if (is_arene(r_id)) and (odd(ring_size) = false) then */
+  /*if (is_arene(r_id)) and (odd(ring_size) = isfalse) then */
   if (!is_arene (r_id))         /* v0.3j */
     return;
   for (i = 0; i < ring_size; i++) {
     a_ref = testring[i];
     if (is_oxo_C (a_ref))
-            fg[fg_oxohetarene - 1] = true;
+            fg[fg_oxohetarene - 1] = istrue;
     if (is_thioxo_C (a_ref))
-            fg[fg_thioxohetarene - 1] = true;
+            fg[fg_thioxohetarene - 1] = istrue;
-    if (is_true_exocyclic_imino_C (a_ref, r_id))        /* v0.3j */
+    if (is_istrue_exocyclic_imino_C (a_ref, r_id))      /* v0.3j */
-            fg[fg_iminohetarene - 1] = true;
+            fg[fg_iminohetarene - 1] = istrue;
+  }
+}
 static void chk_ion (int a_ref)
+{
     return;
   FORLIM = atom[a_ref - 1].neighbor_count;
   for (i = 0; i < FORLIM; i++)
     charge += atom[nb[i] - 1].formal_charge;
   if (charge > 0)
-    fg[fg_cation - 1] = true;
+    fg[fg_cation - 1] = istrue;
   if (charge < 0)
-    fg[fg_anion - 1] = true;
+    fg[fg_anion - 1] = istrue;
+}
 static void chk_functionalgroups ()
+{
   int i, a1, a2;
     return;
   FORLIM = n_atoms;
   for (i = 1; i <= FORLIM; i++) {                               /* a few groups are best discovered in the atom list */
     if (!strcmp (atom[i - 1].atype, "SO2"))
             chk_so2_deriv (i);
-    /*if (atom^[i].atype = 'SO ') then fg[fg_sulfoxide] := true;  (* do another check in the bond list!! */
+    /*if (atom^[i].atype = 'SO ') then fg[fg_sulfoxide] := istrue;  (* do another check in the bond list!! */
     if (!strcmp (atom[i - 1].element, "P "))
             chk_p_deriv (i);
     if (!strcmp (atom[i - 1].element, "B "))
             chk_b_deriv (i);
     if (!strcmp (atom[i - 1].atype, "N3+") || atom[i - 1].formal_charge > 0)
   if (n_rings > 0) {
     FORLIM = n_rings;
     for (i = 1; i <= FORLIM; i++) {
             chk_oxo_thioxo_imino_hetarene (i);
             if (is_arene (i))
-              fg[fg_aromatic - 1] = true;
+              fg[fg_aromatic - 1] = istrue;
             if (is_heterocycle (i))
-              fg[fg_heterocycle - 1] = true;
+              fg[fg_heterocycle - 1] = istrue;
+          }
+  }
   if (pos_chg + neg_chg > 0)
-    fg[fg_cation - 1] = true;
+    fg[fg_cation - 1] = istrue;
   if (pos_chg + neg_chg < 0)
-    fg[fg_anion - 1] = true;
+    fg[fg_anion - 1] = istrue;
+}
 static void write_fg_text ()
+{
   if (fg[fg_cation - 1])
+  {
   if (!rfile_is_open)
+  {
   assign (rfile, molfilename);
   rewind (rfile);
-  rfile_is_open = true;
+  rfile_is_open = istrue;
+  }
   /* p2c: checkmol.pas, line 7733: Warning:
   * Don't know how to ASSIGN to a non-explicit file variable [207] */
   *rline = '\0';
-  mol_in_queue = false;
+  mol_in_queue = isfalse;
   while ((!P_eof (rfile)) && (strpos2 (rline, "$$$$", 1) == 0))
+  {
   fgets (rline, 256, rfile);
   TEMP = strchr (rline, '\n');
   if (TEMP != NULL)
   *TEMP = 0;
-  /*mol_in_queue := false; */
+  /*mol_in_queue := isfalse; */
   if (molbufindex >= max_atoms + max_bonds + 64)
+  {
   printf ("Not enough memory for molfile! %12ld\n",
   molbufindex);
   if (rfile != NULL)
   _Escape (1);
+  }
   molbufindex++;
   strcpy (molbuf[molbufindex - 1], rline);
   if (strpos2 (rline, "$$$$", 1) > 0)
-  mol_in_queue = true;
+  mol_in_queue = istrue;
+  }
   if (!P_eof (rfile))
   return;
   if (rfile != NULL)
   fclose (rfile);
   rfile = NULL;
-  rfile_is_open = false;
+  rfile_is_open = isfalse;
-  mol_in_queue = false;
+  mol_in_queue = isfalse;
   return;
+  }
   *rline = '\0';
-  mol_in_queue = false;
+  mol_in_queue = isfalse;
   while ((!P_eof (stdin)) && (strpos2 (rline, "$$$$", 1) == 0))
+  {
   gets (rline);
   if (molbufindex >= max_atoms + max_bonds + 64)
+  {
+  }
   molbufindex++;
   strcpy (molbuf[molbufindex - 1], rline);
   if (strpos2 (rline, "$$$$", 1) > 0)
+  {
-  mol_in_queue = true;
+  mol_in_queue = istrue;
   /* read from standard input
+  }
+  }
   } */
 #endif
   molbufindex = 0;
   if (!opt_stdin) {
     if (!rfile_is_open) {
             rfile = fopen (molfilename, "r");
             rewind (rfile);
-            rfile_is_open = true;
+            rfile_is_open = istrue;
+          }
     /* p2c: checkmol.pas, line 7226: Warning:
      * Don't know how to ASSIGN to a non-explicit file variable [207] */
     *rline = '\0';
-    mol_in_queue = false;
+    mol_in_queue = isfalse;
     while ((fgets (rline, 256, rfile) != NULL) && (strstr (rline, "$$$$") == NULL)) {
             TEMP = strchr (rline, '\n');
             if (TEMP != NULL)
               *TEMP = 0;
-            /*mol_in_queue := false; */
+            /*mol_in_queue := isfalse; */
             if (molbufindex >= max_atoms + max_bonds + 64) {
               printf ("Not enough memory for molfile! %d\n", molbufindex);
               if (rfile != NULL)
                       fclose (rfile);
               rfile = NULL;
               exit (1);
+            }
             //molbufindex++;
             strcpy (molbuf[molbufindex++], rline);
             if (strstr (rline, "$$$$") != NULL)
-              mol_in_queue = true;
+              mol_in_queue = istrue;
+          }
     if (!feof (rfile))
             return;
     if (rfile != NULL)
             fclose (rfile);
     rfile = NULL;
-    rfile_is_open = false;
+    rfile_is_open = isfalse;
-    mol_in_queue = false;
+    mol_in_queue = isfalse;
     return;
+  }
   *rline = '\0';
-  mol_in_queue = false;
+  mol_in_queue = isfalse;
   do {
     if(fgets (rline, 256, stdin)==NULL || feof (stdin))
             return;
     TEMP = strchr (rline, '\n');
     if (TEMP != NULL)
             exit (1);
+          }
     //molbufindex++;
     strcpy (molbuf[molbufindex++], rline);
     if (strstr (rline, "$$$$") != NULL) {
-            mol_in_queue = true;
+            mol_in_queue = istrue;
             /* read from standard input */
+          }
+  }
   while (strstr (rline, "$$$$") == NULL);
+}
         ndl_molstat.n_psla = molstat.n_psla;
         $ENDIF*/
   /* make sure some modes can be switched on only by the query file *M*/
   /* and not by subsequent haystack file(s) */
   if (ez_flag)   /* new in v0.3f */
-   ez_search = true;
+   ez_search = istrue;
   if (chir_flag)   /* new in v0.3f */
-    rs_search = true;
+    rs_search = istrue;
+}
 #endif
 static void copy_mol_to_needle ()
+{
   memcpy (&ndl_molstat, &molstat, sizeof (molstat));
   // make sure some modes can be switched on only by the query file
   // and not by subsequent haystack file(s)
   if (ez_flag)                  // new in v0.3f
-    ez_search = true;
+    ez_search = istrue;
   if (chir_flag)                // new in v0.3f
-    rs_search = true;
+    rs_search = istrue;
   ndl_querymol = found_querymol;        /* 0.3p */
+}
   memcpy (&tmp_molstat, &molstat, sizeof (molstat));
   // make sure some modes can be switched on only by the query file
   // and not by subsequent haystack file(s)
   if (ez_flag)                  // new in v0.3f
-    ez_search = true;
+    ez_search = istrue;
   if (chir_flag)                // new in v0.3f
-    rs_search = true;
+    rs_search = istrue;
   ndl_querymol = found_querymol;        /* 0.3p */
+}
   tmp_molstat.n_psla = molstat.n_psla;
   $ENDIF*/
   /* make sure some modes can be switched on only by the query file */
   /* and not by subsequent haystack file(s) */
   if (ez_flag)   /* new in v0.3f */
-    ez_search = true;
+    ez_search = istrue;
   if (chir_flag)   /* new in v0.3f */
-    rs_search = true;
+    rs_search = istrue;
+}
 #endif
 static void copy_tmp_to_mol ()
+{
   memcpy (&molstat, &tmp_molstat, sizeof (tmp_molstat));
   // make sure some modes can be switched on only by the query file
   // and not by subsequent haystack file(s)
   if (ez_flag)                  // new in v0.3f
-    ez_search = true;
+    ez_search = istrue;
   if (chir_flag)                // new in v0.3f
-    rs_search = true;
+    rs_search = istrue;
+}
 #if 0
 static void copy_tmp_to_mol()
      molstat.n_psla = tmp_molstat.n_psla;
      $ENDIF */
   /* make sure some modes can be switched on only by the query file */
   /* and not by subsequent haystack file(s) */
      if (ez_flag)
-     ez_search = true;
+     ez_search = istrue;
      if (chir_flag)
-     rs_search = true;
+     rs_search = istrue;
+     }
 #endif
 static void get_ringstat (int r_id)
+{
   for (j = 0; j < ring_size; j++)       /* v0.3j */
     testring[j] = ring[r_id - 1][j];
     /* p2c: checkmol.pas, line 8238:
     * Note: Turbo Pascal conditional compilation directive was ignored [218] */
 #ifdef reduced_SAR
-  if (ring_size <= 2 || ringprop[r_id - 1].envelope != false)
+  if (ring_size <= 2 || ringprop[r_id - 1].envelope != isfalse)
     /* v0.3n: ignore envelope rings */
     return;
 #else
   if (ring_size <= 2)
     return;
             if (!strcmp (atype, "O3 "))
               molstat.n_O3++;
             if (!strcmp (atype, "N1 "))
               molstat.n_N1++;
             if (!strcmp (atype, "N2 ") || !strcmp (atype, "NAR") ||
-                (!strcmp (atype, "NAM") && atom[i].arom == true))
+                (!strcmp (atype, "NAM") && atom[i].arom == istrue))
               /* v0.3n */
               molstat.n_N2++;
             if (!strcmp (atype, "N3 ") || !strcmp (atype, "NPL") ||
                 !strcmp (atype, "N3+") ||
-                (!strcmp (atype, "NAM") && atom[i].arom == false))
+                (!strcmp (atype, "NAM") && atom[i].arom == isfalse))
               /* v0.3n */
               molstat.n_N3++;
             if (!strcmp (elem, "A "))   /* query atom */
               molstat.n_QA++;
             if (!strcmp (elem, "Q "))   /* query atom */
   }                             /* rings */
   /* v0.3n */
   n_countablerings = 0;         /* v0.3n */
   FORLIM = n_rings;
   for (i = 1; i <= FORLIM; i++) {
-    if (ringprop[i - 1].envelope == false)      /* v0.3n */
+    if (ringprop[i - 1].envelope == isfalse)    /* v0.3n */
             n_countablerings++;
-    if (is_arene (i) && ringprop[i - 1].envelope == false) {
+    if (is_arene (i) && ringprop[i - 1].envelope == isfalse) {
       /* v0.3n: ignore envelope rings */
             molstat.n_rAr++;
-            if ((ringprop[i - 1].size == 6) && (is_heterocycle (i) == false))
+            if ((ringprop[i - 1].size == 6) && (is_heterocycle (i) == isfalse))
               /* v0.3l */
               molstat.n_rBz++;
+          }
     get_ringstat (i);
-    if (ringprop[i - 1].arom == true && ringprop[i - 1].envelope == false)
+    if (ringprop[i - 1].arom == istrue && ringprop[i - 1].envelope == isfalse)
             /* new in v0.3n; replaces assignment below */
             n_b2formal++;
+  }
   /*n_b2formal := n_rar;  (* new in v0.2e; adds 1 formal double bond for each aromatic ring */
   /* in order to allow an isolated double bond in the needle */
   /* matchpath, regardless where the recursive search starts; */
   /* refined in v0.3f: exclude only alkene-C as reference atoms */
   /* added in v0.3o: needle atom must be "tagged" in order to be */
   /* selected (prevents unconnected fragments from being overlooked) */
   if (ndl_n_atoms == 0)
-    return false;
+    return isfalse;
   if (ez_search && ndl_n_heavyatoms > 2) {
     FORLIM = ndl_n_atoms;
     for (i = 1; i <= FORLIM; i++) {                     /* ignore sp2-carbons if not aromatic */
-           /*if ((ndl_atom^[i].atype <> 'C2 ') or (ndl_atom^[i].arom = true)) then */
+           /*if ((ndl_atom^[i].atype <> 'C2 ') or (ndl_atom^[i].arom = istrue)) then */
-            if (ndl_alkene_C (i) == false && ndl_atom[i - 1].tag) {                     /* v0.3o */
+            if (ndl_alkene_C (i) == isfalse && ndl_atom[i - 1].tag) {                   /* v0.3o */
               n_nb = ndl_atom[i - 1].neighbor_count;
               n_hc = ndl_hetatom_count (i);
               if (n_nb * 11 + n_hc * 7 > score && ndl_atom[i - 1].heavy) {
                 /* v0.3j */
                 index = i;
+          }
+  }
   /* it is possible that no suitable reference atom has been found here */
   /* (e.g., with "pure" polyenes), so we need a fallback option anyway */
   if (index == 0) {
-    ez_search = false;  /* just in case it was true */
+    ez_search = isfalse;        /* just in case it was istrue */
-    opt_geom = false;           /* just in case it was true */
+    opt_geom = isfalse;         /* just in case it was istrue */
     FORLIM = ndl_n_atoms;
     for (i = 1; i <= FORLIM; i++) {
             n_nb = ndl_atom[i - 1].neighbor_count;
             n_hc = ndl_hetatom_count (i);
             if (n_nb * 11 + n_hc * 7 > score && ndl_atom[i - 1].heavy &&
   if (cv == NULL)
     return 0;
   memset (cvlist, 0, sizeof (int) * max_atoms);
   FORLIM = ndl_n_atoms;
   for (i = 0; i < FORLIM; i++) {
-    if (ndl_atom[i].heavy == true) {
+    if (ndl_atom[i].heavy == istrue) {
             cvdef = cv[i].def;
-            isnew = true;
+            isnew = istrue;
             if (entries > 0) {
               for (j = 0; j < entries; j++) {
                       if (cvlist[j] == cvdef)
-                        isnew = false;
+                        isnew = isfalse;
+                    }
+            }
             if (isnew) {
                 entries++;
                 cvlist[entries - 1] = cvdef;
   int i, j;
   neighbor_rec nb;
   int nnb, nsum, n_cv, FORLIM;
   if (cv == NULL || ndl_n_atoms == 0)
-    return false;
+    return isfalse;
   FORLIM = ndl_n_atoms;
   /* update the connection values (Morgan algorithm) */
   memset (nb, 0, sizeof (neighbor_rec));
   for (i = 1; i <= FORLIM; i++) {
-    if (ndl_atom[i - 1].heavy == true) {
+    if (ndl_atom[i - 1].heavy == istrue) {
             get_ndl_neighbors (nb, i);
             nnb = ndl_atom[i - 1].neighbor_count;
             nsum = 0;
             if (nnb > 0) {
               for (j = 0; j < nnb; j++) {
-                if (ndl_atom[nb[j] - 1].heavy == true)
+                if (ndl_atom[nb[j] - 1].heavy == istrue)
                   nsum += cv[nb[j] - 1].def;
+              }
+            }
             cv[i - 1].tmp = nsum;
+          }
   /* new in v0.3j, modified in v0.3m */
   int Result, i;
   int res = 1, it = 0;
   int n_cv;
   int n_cv_prev = 0;
-  boolean finished = false;
+  boolean finished = isfalse;
   int cvmax = 0;
   int FORLIM;
   if (ndl_n_atoms == 0)
     return 0;
   cv_init ();
   do {
     it++;                       /* iteration counter (a safeguard against infinite loops) */
     n_cv = cv_iterate (n_cv_prev);
     if (n_cv <= n_cv_prev)
-            finished = true;
+            finished = istrue;
     n_cv_prev = n_cv;
+  }
   while (!(finished || it > 10000));
   FORLIM = ndl_n_atoms;
   /* now that we have canonical connection values (Morgan algorithm), */
   /* pick the atom with the highest value */
   /* added in v0.3o: atom must be "tagged" */
   for (i = 1; i <= FORLIM; i++) {
       /*writeln('cv for atom ',i,': ',cv^[i].def); */
-    if (((cv[i - 1].def > cvmax) && (ndl_alkene_C (i) == false || ez_search == false))
+    if (((cv[i - 1].def > cvmax) && (ndl_alkene_C (i) == isfalse || ez_search == isfalse))
               && ndl_atom[i - 1].tag) {                 /* v0.3o */
             cvmax = cv[i - 1].def;
             res = i;
+          }
+  }
   str2 ndl_el;
   str3 ndl_atype;
   str2 hst_el;
   str3 hst_atype;
   int ndl_nbc, hst_nbc, ndl_Hexp, hst_Htot;
-  boolean res = false;
+  boolean res = isfalse;
   strcpy (ndl_el, ndl_atom[ndl_a - 1].element);
   strcpy (ndl_atype, ndl_atom[ndl_a - 1].atype);
   ndl_nbc = ndl_atom[ndl_a - 1].neighbor_count;
   ndl_Hexp = ndl_atom[ndl_a - 1].Hexp;
   hst_nbc = atom[hst_a - 1].neighbor_count;
   hst_Htot = atom[hst_a - 1].Htot;
   /* v0.3o: formal charges must be the same */
   if (ndl_atom[ndl_a - 1].formal_charge != atom[hst_a - 1].formal_charge)
-    return false;
+    return isfalse;
   /* v0.3x: isotope nucleon numbers must be the same */
   if (ndl_atom[ndl_a - 1].nucleon_number != atom[hst_a - 1].nucleon_number)
-    return false;
+    return isfalse;
   /* v0.3x: radicals must be the same */
   if (ndl_atom[ndl_a - 1].radical_type != atom[hst_a - 1].radical_type)
-    return false;
+    return isfalse;
   if (!strcmp (ndl_atype, hst_atype))
-    res = true;
+    res = istrue;
   else {
     if (!strcmp (ndl_el, hst_el) && ndl_atom[ndl_a - 1].arom && atom[hst_a - 1].arom)
-            res = true;
+            res = istrue;
     if (ndl_querymol && (ndl_atom[ndl_a - 1].q_arom && atom[hst_a - 1].arom))
-            res = true;         /* 0.3 p */
+            res = istrue;               /* 0.3 p */
+  }
   if (!strcmp (ndl_el, "A ") && atom[hst_a - 1].heavy)
-    res = true;
+    res = istrue;
   if (!strcmp (ndl_el, "Q ")) {
     if (atom[hst_a - 1].heavy && strcmp (hst_el, "C "))
-            res = true;
+            res = istrue;
+  }
   if (!strcmp (ndl_el, "X ")) {
     if (!strcmp (hst_el, "F ") || !strcmp (hst_el, "CL") ||
             !strcmp (hst_el, "BR") || !strcmp (hst_el, "I ")
             || !strcmp (hst_el, "AT"))
-          res = true;
+          res = istrue;
+  }
   /* if needle atom has more substituents than haystack atom ==> no match */
   if (ndl_nbc > hst_nbc)
-    res = false;
+    res = isfalse;
   /* check for explicit hydrogens */
   if (ndl_Hexp > hst_Htot)
-    res = false;
+    res = isfalse;
     /* p2c: checkmol.pas, line 8859:
     * Note: Turbo Pascal conditional compilation directive was ignored [218] */
     /*$IFDEF debug */
     /* if res then debugoutput('atom types OK ('+inttostr(ndl_a)+'/'+inttostr(hst_a)+')')
      else debugoutput('atom types not OK ('+inttostr(ndl_a)+':'+ndl_atype+'/'+inttostr(hst_a)+':'+hst_atype+')'); */
     /*$ENDIF */
     /* new in v0.3m: in "fingerprint mode", also query atom symbols must match */
   if (opt_fp) {
     if (strcmp (ndl_el, hst_el))
-            res = false;
+            res = isfalse;
+  }
   return res;
+}
 static boolean atomtypes_OK (int ndl_a, int hst_a)
+{
   str2 ndl_el, hst_el;
   int ndl_nbc, hst_nbc, ndl_Hexp, hst_Htot;
-  boolean res = false;
+  boolean res = isfalse;
   if (ndl_a < 1 || ndl_a > ndl_n_atoms || hst_a < 1 || hst_a > n_atoms)
-    return false;
+    return isfalse;
   /* check for opposite charges;  v0.3l, refined in v0.3o, 0.3x */
   /* except in strict mode, matching pairs of charged+uncharged atoms  */
   /* are tolerated (this is a feature, not a bug) */
   if (opt_chg) {
     if (ndl_atom[ndl_a - 1].formal_charge != atom[hst_a - 1].formal_charge)
-        return false;
+        return isfalse;
+  }
   //  else
   //    {
   //      if (ndl_atom[ndl_a - 1].formal_charge != 0 &&
   //        atom[hst_a - 1].formal_charge != 0 &&
   //        ndl_atom[ndl_a - 1].formal_charge != atom[hst_a - 1].formal_charge)
-  //      return false;
+  //      return isfalse;
   //    }
   //
   //  /* v0.3x: isotopes must be the same */
   if (opt_iso) {
     if (ndl_atom[ndl_a - 1].nucleon_number != atom[hst_a - 1].nucleon_number)
-            return false;
+            return isfalse;
+  }
   //  else
   //    {
   //      if (ndl_atom[ndl_a - 1].nucleon_number != 0 &&
   //        atom[hst_a - 1].nucleon_number != 0 &&
   //        ndl_atom[ndl_a - 1].nucleon_number !=
   //        atom[hst_a - 1].nucleon_number)
-  //      return false;
+  //      return isfalse;
   //    }
   //
   //  /* v0.3x: radicals must be the same */
   if (opt_rad) {
     if (ndl_atom[ndl_a - 1].radical_type != atom[hst_a - 1].radical_type)
-            return false;
+            return isfalse;
+  }
   //  else
   //    {
   //      if (ndl_atom[ndl_a - 1].radical_type != 0 &&
   //        atom[hst_a - 1].radical_type != 0 &&
   //        ndl_atom[ndl_a - 1].radical_type != atom[hst_a - 1].radical_type)
-  //      return false;
+  //      return isfalse;
   //    }
   /* in exact mode, check if (disconnected) fragment is already tagged; v0.3o */
-  if (opt_exact && atom[hst_a - 1].tag == true) {
+  if (opt_exact && atom[hst_a - 1].tag == istrue) {
     /* p2c: checkmol.pas, line 8899:
   * Note: Turbo Pascal conditional compilation directive was ignored [218] */
       /*$IFDEF debug */
       /* debugoutput('fragmnet already tagged at '+inttostr(hst_a)); */
       /*$ENDIF */
-      return false;
+      return isfalse;
+  }
   if (opt_strict)               /* new in v0.2f */
     return (atomtypes_OK_strict (ndl_a, hst_a));
   strcpy (ndl_el, ndl_atom[ndl_a - 1].element);
   ndl_nbc = ndl_atom[ndl_a - 1].neighbor_count;
   ndl_Hexp = ndl_atom[ndl_a - 1].Hexp;
   strcpy (hst_el, atom[hst_a - 1].element);
   hst_nbc = atom[hst_a - 1].neighbor_count;
   hst_Htot = atom[hst_a - 1].Htot;
   if (!strcmp (ndl_el, hst_el)) /* very simplified... */
-    res = true;
+    res = istrue;
   if (!strcmp (ndl_el, "A ") && atom[hst_a - 1].heavy)
-    res = true;
+    res = istrue;
   if (!strcmp (ndl_el, "Q ")) {
     if (atom[hst_a - 1].heavy && strcmp (hst_el, "C "))
-            res = true;
+            res = istrue;
+  }
   if (!strcmp (ndl_el, "X ")) {
     if (!strcmp (hst_el, "F ") || !strcmp (hst_el, "CL") ||
               !strcmp (hst_el, "BR") || !strcmp (hst_el, "I ")
               || !strcmp (hst_el, "AT"))
-            res = true;
+            res = istrue;
+  }
   /* v0.3o: in exact mode, check for identical neighbor_count */
   if (opt_exact) {
     if (ndl_nbc != hst_nbc) {
-          res = false;
+          res = isfalse;
     /* p2c: checkmol.pas, line 8934:
      * Note: Turbo Pascal conditional compilation directive was ignored [218] */
           /*$IFDEF debug */
           //debugoutput
           //  ("exact match failed: different number of neighbor atoms");
           /*$ENDIF */
+          }
+  }
   /* if needle atom has more substituents than haystack atom ==> no match */
   if (ndl_nbc > hst_nbc)
-    res = false;
+    res = isfalse;
   /* check for explicit hydrogens */
   if (ndl_Hexp > hst_Htot)
-    res = false;
+    res = isfalse;
   /* p2c: checkmol.pas, line 8943:
   * Note: Turbo Pascal conditional compilation directive was ignored [218] */
   /*$IFDEF debug */
   /* if res then debugoutput('atom types OK ('+inttostr(ndl_a)+'/'+inttostr(hst_a)+')')
      else debugoutput('atom types not OK ('+inttostr(ndl_a)+'/'+inttostr(hst_a)+')'); */
   boolean ndl_arom, hst_arom;
   char ndl_btype, hst_btype;
   int ndl_rc;                   /* new in v0.3d */
   int hst_rc;                   /* new in v0.3d */
   int ndl_btopo;                /* new in v0.3d */
-  boolean res = false;
+  boolean res = isfalse;
   /* p2c: checkmol.pas, line 8960:
   * Note: Turbo Pascal conditional compilation directive was ignored [218] */
   /*$IFDEF debug */
   /*char na[256]; char ha[256];*/
   char tstr[256];
    if (hst_arom)
      strcpy (ha, "(ar)");
    else
      *ha = '\0';*/
    /*$ENDIF */
-  if (ndl_arom == true && hst_arom == true)
+  if (ndl_arom == istrue && hst_arom == istrue)
-    res = true;
+    res = istrue;
-  if (ndl_arom == false && hst_arom == false) {
+  if (ndl_arom == isfalse && hst_arom == isfalse) {
     if (ndl_btype == hst_btype)
-            res = true;
+            res = istrue;
     if (ndl_btype == 'l' && (hst_btype == 'S' || hst_btype == 'D'))
-            res = true;
+            res = istrue;
     if (ndl_btype == 's' && hst_btype == 'S')
-            res = true;
+            res = istrue;
     if (ndl_btype == 'd' && hst_btype == 'D')
-            res = true;
+            res = istrue;
+  }
   /* a little exception: */
-  if (ndl_arom == false && hst_arom == true) {
+  if (ndl_arom == isfalse && hst_arom == istrue) {
     if (ndl_btype == 'A')
-            res = true;
+            res = istrue;
     if (ndl_btype == 's' || ndl_btype == 'd')
-            res = true;
+            res = istrue;
     if (ndl_bond[ndl_b - 1].q_arom)
-            res = true;         /* 0.3p */
+            res = istrue;               /* 0.3p */
+  }
   if (ndl_btype == 'a')
-    res = true;
+    res = istrue;
   /* new in v0.3d: strict comparison of topology (and even ring_count!) */
   if (ndl_btopo < btopo_always_any || ndl_btopo == btopo_exact_rc) {
     if (ndl_rc != hst_rc) {
-            res = false;                /* this excludes further ring annulations as well as */
+            res = isfalse;              /* this excludes further ring annulations as well as */
       /* p2c: checkmol.pas, line 9001:
       * Note: Turbo Pascal conditional compilation directive was ignored [218] */
             /*$IFDEF debug */
             /* open-chains query structures to be found in rings */
             /*
             /*$ENDIF */
+          }
+  }
   else {
     if (ndl_btopo == btopo_excess_rc && hst_rc <= ndl_rc) {
-            res = false;
+            res = isfalse;
     /* p2c: checkmol.pas, line 9010:
     * Note: Turbo Pascal conditional compilation directive was ignored [218] */
           /*$IFDEF debug */
           /* tstr := ' ringcount mismatch ('+inttostr(ndl_rc)+'/'+inttostr(hst_rc)+')'; */
           /*$ENDIF */
   boolean ndl_arom, hst_arom;
   char ndl_btype, hst_btype;
   int ndl_rc;                   /* new in v0.3d */
   int hst_rc;                   /* new in v0.3d */
   int ndl_btopo;                /* new in v0.3d */
-  boolean res = false;
+  boolean res = isfalse;
   /* p2c: checkmol.pas, line 9032:
   * Note: Turbo Pascal conditional compilation directive was ignored [218] */
   /*$IFDEF debug */
   /*char na[256], ha[256];*/
   char tstr[256];
   /*$ENDIF */
   int a1, a2;
   str2 a1_el, a2_el;
   if (ndl_b < 1 || ndl_b > ndl_n_bonds || hst_b < 1 || hst_b > n_bonds)
-    return false;
+    return isfalse;
   if (opt_strict)               /* new in v0.2f */
     return (bondtypes_OK_strict (ndl_b, hst_b));
   /* p2c: checkmol.pas, line 9051:
   * Note: Turbo Pascal conditional compilation directive was ignored [218] */
   /*$IFDEF debug */
   //  if (hst_arom)
   //    strcpy (ha, "(ar)");
   //  else
   //    *ha = '\0';
   /*$ENDIF */
-  if (ndl_arom == true && hst_arom == true)
+  if (ndl_arom == istrue && hst_arom == istrue)
-    res = true;
+    res = istrue;
-  if (ndl_arom == false && hst_arom == false) {
+  if (ndl_arom == isfalse && hst_arom == isfalse) {
     if (ndl_btype == hst_btype)
-            res = true;
+            res = istrue;
     if (ndl_btype == 'l' && (hst_btype == 'S' || hst_btype == 'D'))
-            res = true;
+            res = istrue;
     if (ndl_btype == 's' && hst_btype == 'S')
-            res = true;
+            res = istrue;
     if (ndl_btype == 'd' && hst_btype == 'D')
-            res = true;
+            res = istrue;
+  }
   /* a little exception: */
-  if (ndl_arom == false && hst_arom == true) {
+  if (ndl_arom == isfalse && hst_arom == istrue) {
     if (ndl_btype == 'A')
-            res = true;
+            res = istrue;
     if (ndl_btype == 's' || ndl_btype == 'd')
-            res = true;
+            res = istrue;
     if (ndl_btype == 'D') {                     /* added in 0.2d: do not accept C=O etc. as C-O/arom */
             a1 = ndl_bond[ndl_b - 1].a1;
             a2 = ndl_bond[ndl_b - 1].a2;
             strcpy (a1_el, ndl_atom[a1 - 1].element);
             strcpy (a2_el, ndl_atom[a2 - 1].element);
             if (strcmp (a1_el, "O ") && strcmp (a2_el, "O ")
                 && strcmp (a1_el, "S ") && strcmp (a2_el, "S ")
                 && strcmp (a1_el, "SE") && strcmp (a2_el, "SE")
                 && strcmp (a1_el, "TE") && strcmp (a2_el, "TE"))
-              res = true;
+              res = istrue;
+          }
     if (ndl_bond[ndl_b - 1].q_arom)
-            res = true;         /* 0.3p */
+            res = istrue;               /* 0.3p */
+  }
   if (ndl_btype == 'a')
-    res = true;
+    res = istrue;
   /* new in v0.3d: obey topology requirements in query structure */
   if (ndl_btopo != btopo_any && ndl_btopo != btopo_always_any) {
     if (ndl_btopo == btopo_ring && hst_rc == 0)
-      res = false;
+      res = isfalse;
     if (ndl_btopo == btopo_chain && hst_rc > 0)
-      res = false;
+      res = isfalse;
     if (ndl_btopo == btopo_excess_rc && hst_rc <= ndl_rc)
-      res = false;
+      res = isfalse;
     if (ndl_btopo == btopo_exact_rc && hst_rc != ndl_rc)
-      res = false;
+      res = isfalse;
+  }
   /* p2c: checkmol.pas, line 9098:
    * Note: Turbo Pascal conditional compilation directive was ignored [218] */
     /*$IFDEF debug */
-    /* if res = false then tstr := ' bond topology mismatch '+inttostr(ndl_rc)+'/'+inttostr(hst_rc); */
+    /* if res = isfalse then tstr := ' bond topology mismatch '+inttostr(ndl_rc)+'/'+inttostr(hst_rc); */
     /*$ENDIF */
   /* p2c: checkmol.pas, line 9102:
    * Note: Turbo Pascal conditional compilation directive was ignored [218] */
     /*$IFDEF debug */
     /*
+}
 static boolean matrix_OK (boolean (*m)[max_neighbors], int ndl_dim, int hst_dim)
+{
   /* new, recursive version in v0.2i: can handle up to max_neighbors substituents */
-  boolean mr = false;
+  boolean mr = isfalse;
   matchmatrix lm;
   int i, ii, j, lndl_dim, lhst_dim;
   if (ndl_dim < 1 || ndl_dim > max_neighbors || hst_dim < 1 ||
       hst_dim > max_neighbors || ndl_dim > hst_dim)
-    return false;
+    return isfalse;
   if (ndl_dim == 1) {
     for (i = 0; i < hst_dim; i++) {
             if (m[0][i])
-              mr = true;
+              mr = istrue;
+          }
     return mr;
+  }
   for (i = 1; i <= hst_dim; i++) {
     if (m[0][i - 1]) {
             /* write remaining fields into a new matchmatrix which is smaller by 1x1 */
-            memset (lm, false, sizeof (matchmatrix));
+            memset (lm, isfalse, sizeof (matchmatrix));
             for (j = 2; j <= ndl_dim; j++) {
               lhst_dim = 0;
               for (ii = 1; ii <= hst_dim; ii++) {
                 if (ii != i) {
                   lhst_dim++;
+                }
+              }
+            }
             lndl_dim = ndl_dim - 1;
             if (matrix_OK (lm, lndl_dim, lhst_dim)) {                   /* recursive call to matrix_OK */
-              return true;
+              return istrue;
             /* stop any further work immediately */
+            }
+          }
+  }
-  return false;
+  return isfalse;
+}
 static boolean is_flat (double angle_deg)
+{
   /* new in v0.3j */
   if (fabs (angle_deg) > 5 && fabs (angle_deg) < 175)
-    return false;
+    return isfalse;
   else
-    return true;
+    return istrue;
+}
 static boolean chirality_OK (int *ndl_cp, int *hst_cp)
+{
-  boolean res = true;
+  boolean res = istrue;
   double ndl_ct, hst_ct, ndl_ct_deg, hst_ct_deg;
   p_3d np1, np2, np3, np4, hp1, hp2, hp3, hp4;
   int level = 0;
   int i;
-  boolean up = false, down = false, updown = false;
+  boolean up = isfalse, down = isfalse, updown = isfalse;
   int ta1, ta2, ta3, ta4, ba1, ba2, FORLIM;
   /* fill temporary atom variables */
   ta1 = ndl_cp[0];              /* this is the central atom */
   ta2 = ndl_cp[1];
             if (ndl_bond[i].stereo == bstereo_up ||
                   ndl_bond[i].stereo == bstereo_down) {
               ba1 = ndl_bond[i].a1;
               ba2 = ndl_bond[i].a2;
               if (ba1 == ta1 && ndl_bond[i].stereo == bstereo_up) {
-                      up = true;
+                      up = istrue;
                       if (ba2 == ta2 || ba2 == ta3 || ba2 == ta4) {
-                        updown = true;
+                        updown = istrue;
                         if (ba2 == ta2)
                                 np1.z += 0.8;
                         if (ba2 == ta3)
                                 np3.z += 0.8;
                         if (ba2 == ta4)
+                      }
                       else
                         level++;
+                    }
               if (ba1 == ta1 && ndl_bond[i].stereo == bstereo_down) {
-                      down = true;
+                      down = istrue;
                       if (ba2 == ta2 || ba2 == ta3 || ba2 == ta4) {
-                        updown = true;
+                        updown = istrue;
                         if (ba2 == ta2)
                                 np1.z -= 0.8;
                         if (ba2 == ta3)
                                 np3.z -= 0.8;
                         if (ba2 == ta4)
+                      }
                       else
                         level--;
+                    }
               if (ba2 == ta1 && ndl_bond[i].stereo == bstereo_up) {
-                      down = true;
+                      down = istrue;
                       if (ba1 == ta2 || ba1 == ta3 || ba1 == ta4) {
-                        updown = true;
+                        updown = istrue;
                         if (ba1 == ta2)
                           np1.z -= 0.8;
                         if (ba1 == ta3)
                           np3.z -= 0.8;
                         if (ba1 == ta4)
+                      }
                       else
                         level--;
+                    }
               if (ba2 == ta1 && ndl_bond[i].stereo == bstereo_down) {
-                      up = true;
+                      up = istrue;
                       if (ba1 == ta2 || ba1 == ta3 || ba1 == ta4) {
-                        updown = true;
+                        updown = istrue;
                         if (ba1 == ta2)
                                 np1.z += 0.8;
                         if (ba1 == ta3)
                                 np3.z += 0.8;
                         if (ba1 == ta4)
                       else
                         level++;
+                    }
+            }
           }                     /* for i ... */
-    if (updown == false && level != 0) {
+    if (updown == isfalse && level != 0) {
             if (level > 0)
               np2.z += 0.3;
             if (level < 0)
               np2.z -= 0.3;
+          }
   hp4.x = atom[ta4 - 1].x;
   hp4.y = atom[ta4 - 1].y;
   hp4.z = atom[ta4 - 1].z;
   /* now check all haystack bonds if we should care about up/down bonds */
   level = 0;
-  updown = false;
+  updown = isfalse;
-  up = false;
+  up = isfalse;
-  down = false;
+  down = isfalse;
   if (n_bonds > 0) {
     FORLIM = n_bonds;
     for (i = 0; i < FORLIM; i++) {
             if (bond[i].stereo == bstereo_up || bond[i].stereo == bstereo_down) {
               ba1 = bond[i].a1;
               ba2 = bond[i].a2;
               if (ba1 == ta1 && bond[i].stereo == bstereo_up) {
-                      up = true;
+                      up = istrue;
                       if (ba2 == ta2 || ba2 == ta3 || ba2 == ta4) {
-                        updown = true;
+                        updown = istrue;
                         if (ba2 == ta2)
                                 hp1.z += 0.8;
                         if (ba2 == ta3)
                                 hp3.z += 0.8;
                         if (ba2 == ta4)
+                      }
                       else
                         level++;
+                    }
               if (ba1 == ta1 && bond[i].stereo == bstereo_down) {
-                      down = true;
+                      down = istrue;
                       if (ba2 == ta2 || ba2 == ta3 || ba2 == ta4) {
-                        updown = true;
+                        updown = istrue;
                         if (ba2 == ta2)
                               hp1.z -= 0.8;
                         if (ba2 == ta3)
                                 hp3.z -= 0.8;
                         if (ba2 == ta4)
+                     }
                     else
                       level--;
+                    }
               if (ba2 == ta1 && bond[i].stereo == bstereo_up) {
-                      down = true;
+                      down = istrue;
                       if (ba1 == ta2 || ba1 == ta3 || ba1 == ta4) {
-                        updown = true;
+                        updown = istrue;
                         if (ba1 == ta2)
                                hp1.z -= 0.8;
                         if (ba1 == ta3)
                                 hp3.z -= 0.8;
                         if (ba1 == ta4)
+                      }
                       else
                         level--;
+                    }
               if (ba2 == ta1 && bond[i].stereo == bstereo_down) {
-                      up = true;
+                      up = istrue;
                       if (ba1 == ta2 || ba1 == ta3 || ba1 == ta4) {
-                        updown = true;
+                        updown = istrue;
                         if (ba1 == ta2)
                                 hp1.z += 0.8;
                         if (ba1 == ta3)
                                 hp3.z += 0.8;
                         if (ba1 == ta4)
                       else
                         level++;
+                    }
+            }
           }                     /* for i ... */
-    if (updown == false && level != 0) {
+    if (updown == isfalse && level != 0) {
             if (level > 0)
               hp2.z += 0.3;
             if (level < 0)
               hp2.z -= 0.3;
+          }
   /* now do a plausibility check and finally check the sense */
   /* (clockwise or counterclockwise) */
   /*
      if (abs(ndl_ct_deg) > 5) and (abs(ndl_ct_deg) < 175) and
      (abs(hst_ct_deg) > 5) and (abs(hst_ct_deg) < 175) and
-     (ndl_ct_deg * hst_ct_deg < 0) then res := false;
+     (ndl_ct_deg * hst_ct_deg < 0) then res := isfalse;
    */
   if (((!is_flat (ndl_ct_deg)) && (!is_flat (hst_ct_deg))) &&
       ndl_ct_deg * hst_ct_deg < 0)
-    res = false;
+    res = isfalse;
   if (rs_strict) {
       if (((is_flat (ndl_ct_deg) && (!is_flat (hst_ct_deg))) ||
                 (is_flat (hst_ct_deg) && (!is_flat (ndl_ct_deg)))) ||
                 ndl_ct_deg * hst_ct_deg < 0)
-              res = false;
+              res = isfalse;
+  }
   return res;
+}
 static boolean ndl_maybe_chiral (int na)
+{
   /* new in v0.3h */
-  boolean res = false;
+  boolean res = isfalse;
   str2 el;
   str3 at;
   int n_nb;
   strcpy (el, ndl_atom[na - 1].element);
   strcpy (at, ndl_atom[na - 1].atype);
   n_nb = ndl_atom[na - 1].neighbor_count;
   if (!strcmp (at, "C3 ") && n_nb > 2)
-    res = true;
+    res = istrue;
   if (!strcmp (el, "N ")) {
     if (!strcmp (at, "N3+") && n_nb == 4)
-            res = true;
+            res = istrue;
+  }
   if (!strcmp (el, "S ")) {                             /* sulfoxide */
     if ((n_nb == 3) && (ndl_hetatom_count (na) == 1))
-            res = true;
+            res = istrue;
+  }
   if (strcmp (el, "P ") && strcmp (el, "AS"))   /* "As" added in v0.3j */
     return res;
   if (n_nb > 3)                 /* are we missing something here? */
-    res = true;
+    res = istrue;
   if (ndl_hetatom_count (na) >= 2)      /* v0.3m; ignore phosphates etc. */
-    res = false;
+    res = isfalse;
   return res;
+}
 static boolean is_matching (int *ndl_xmp, int *hst_xmp)
+{
   /* p2c: checkmol.pas, line 9451:
   * Note: Turbo Pascal conditional compilation directive was ignored [218] */
       /*$IFDEF debug */
       //debugoutput ("needle and haystack matchpaths are of different length");
       /*$ENDIF */
-    return false;
+    return isfalse;
+  }
   ndl_a = ndl_mp[ndl_mp_len - 1];
   hst_a = hst_mp[hst_mp_len - 1];
-  ndl_atom[ndl_a - 1].tag = false;
+  ndl_atom[ndl_a - 1].tag = isfalse;
   /* new in v0.3o: mark the last needle atom as "visited" */
   if (ndl_mp_len > 1) {
     prev_ndl_a = ndl_mp[ndl_mp_len - 2];
     prev_hst_a = hst_mp[hst_mp_len - 2];
+    }
   /* if geometry checking is on, check it here */
-  if (ez_search == true && ndl_mp_len > 3) {
+  if (ez_search == istrue && ndl_mp_len > 3) {
     na1 = ndl_mp[ndl_mp_len - 1];
     na2 = ndl_mp[ndl_mp_len - 2];
     na3 = ndl_mp[ndl_mp_len - 3];
     na4 = ndl_mp[ndl_mp_len - 4];
     ha1 = hst_mp[hst_mp_len - 1];
     ha2 = hst_mp[hst_mp_len - 2];
     ha3 = hst_mp[hst_mp_len - 3];
     ha4 = hst_mp[hst_mp_len - 4];
     prev_ndl_b = get_ndl_bond (na2, na3);
     prev_hst_b = get_bond (ha2, ha3);
-    if (ndl_bond[prev_ndl_b - 1].btype == 'D' && bond[prev_hst_b - 1].arom == false
+    if (ndl_bond[prev_ndl_b - 1].btype == 'D' && bond[prev_hst_b - 1].arom == isfalse
               && (ndl_bond[prev_ndl_b - 1].stereo != bstereo_double_either
               && bond[prev_hst_b - 1].stereo != bstereo_double_either)
               /* 0.3x always match if needle and/or haystack bond is double_either */
               && (!strcmp (atom[ha2 - 1].element, "C ")
               || !strcmp (atom[ha2 - 1].element, "N "))
         /* p2c: checkmol.pas, line 9501:
         * Note: Turbo Pascal conditional compilation directive was ignored [218] */
               /*$IFDEF debug */
               //debugoutput ("E/Z geometry mismatch");
               /*$ENDIF */
-              return false;
+              return isfalse;
+            }
+          }
   }                             /* end of E/Z geometry check */
   /* check whatever can be checked as early as now: */
   /* e.g. different elements or more substituents on needle atom than on haystack */
   if (!atomtypes_OK (ndl_a, hst_a))
-    return false;
+    return isfalse;
   /* positive scenarios, e.g. one-atom fragments  (v0.3o) */
   if (atom[hst_a - 1].neighbor_count == 0 && ndl_atom[ndl_a - 1].neighbor_count == 0) {
     if (!atomtypes_OK (ndl_a, hst_a))
-            return false;
+            return isfalse;
     /* p2c: checkmol.pas: Note: Eliminated unused assignment statement [338] */
-    atom[hst_a - 1].tag = true;
+    atom[hst_a - 1].tag = istrue;
-    return true;
+    return istrue;
+  }
   /* and other possibilities: */
   ndl_b = get_ndl_bond (prev_ndl_a, ndl_a);
   hst_b = get_bond (prev_hst_a, hst_a);
   /* p2c: checkmol.pas, line 9529:
       * Note: Turbo Pascal conditional compilation directive was ignored [218] */
             /*$IFDEF debug */
             /*
              debugoutput('  failed match of bonds '+inttostr(ndl_b)+'/'+inttostr(hst_b)); */
            /*$ENDIF */
-            return false;
+            return isfalse;
+          }
+  }
   /* a) we reached the end of our needle fragment (and atom/bond types match) */
   if ((ndl_atom[ndl_a - 1].neighbor_count == 1) && atomtypes_OK (ndl_a, hst_a) &&
       bondtypes_OK (ndl_b, hst_b)) {
-    return true;
+    return istrue;
   /* p2c: checkmol.pas, line 9549:
   * Note: Turbo Pascal conditional compilation directive was ignored [218] */
       /*$IFDEF debug */
       /* debugoutput('  ==> end of needle fragment at atom '+inttostr(ndl_a)+' (match)'); */
       /*$ENDIF */
+  }
   /* a.1) haystack fragment forms a ring, but needle does not;  v0.3m */
   if ((matchpath_pos (ndl_a, ndl_mp) == matchpath_length (ndl_mp)) &&
         (matchpath_pos (hst_a, hst_mp) < matchpath_length (hst_mp))) {
-    return false;
+    return isfalse;
     /* p2c: checkmol.pas, line 9559:
     * Note: Turbo Pascal conditional compilation directive was ignored [218] */
       /*$IFDEF debug */
       /*
          debugoutput('  haystack forms a ring and needle does not at '+inttostr(hst_a));
               atomtypes_OK (ndl_a, hst_a) && bondtypes_OK (ndl_b, hst_b)) {
               /* 1st chirality check */
             if (!((matchpath_pos (ndl_a, ndl_mp) > 1 && (rs_search ||
                                                        ndl_atom[ndl_a -1].stereo_care)) && ndl_maybe_chiral (ndl_a))) {
                                         /* new in v0.3h */
-              return true;
+              return istrue;
             }                   /* end of 1st chirality check */
             na1 = ndl_a;                /* the (potential) chiral center (v0.3f) */
             na2 = ndl_mp[matchpath_pos (ndl_a, ndl_mp) - 2];
             na3 = ndl_mp[matchpath_pos (ndl_a, ndl_mp)];
             na4 = ndl_mp[matchpath_length (ndl_mp) - 2];
         /* p2c: checkmol.pas, line 9589:
          * Note: Turbo Pascal conditional compilation directive was ignored [218] */
                       /*$IFDEF debug */
                       //debugoutput ("chirality check failed at ring junction");
                       /*$ENDIF */
-        return false;
+        return isfalse;
+      }
       /* p2c: checkmol.pas, line 9596:
        * Note: Turbo Pascal conditional compilation directive was ignored [218] */
           /*$IFDEF debug */
           //debugoutput ("chirality check succeeded at ring junction");
           /*$ENDIF */
-      return true;
+      return istrue;
       /* p2c: checkmol.pas, line 9602:
        * Note: Turbo Pascal conditional compilation directive was ignored [218] */
             /*$IFDEF debug */
             /* debugoutput('matchpath forms ring at: '+inttostr(ndl_a)+' (match)'); */
             /*$ENDIF */
+          }
     else {
-            return false;
+            return isfalse;
       /* p2c: checkmol.pas, line 9609:
       * Note: Turbo Pascal conditional compilation directive was ignored [218] */
             /*$IFDEF debug */
             /*
                debugoutput('matchpath forms ring at: '+inttostr(ndl_a)+' (no match)'); */
     get_ndl_nextneighbors (ndl_nb, ndl_a, prev_ndl_a);
     get_nextneighbors (hst_nb, hst_a, prev_hst_a);
+  }
   /* v0.3o: mark all neighbor atoms as "visited" */
   for (i = 0; i < ndl_n_nb; i++)
-    ndl_atom[ndl_nb[i] - 1].tag = false;
+    ndl_atom[ndl_nb[i] - 1].tag = isfalse;
   /* now that the neighbor-arrays are filled, get all */
   /* combinations of matches recursively; */
   /* first, initialize the match matrix */
-  memset (mm, false, sizeof (matchmatrix));     /* new in v0.2i */
+  memset (mm, isfalse, sizeof (matchmatrix));   /* new in v0.2i */
   /* make sure there are not too many neighbors (max. max_neighbors)   */
   if (ndl_n_nb > max_neighbors || n_nb > max_neighbors) {                               /* updated in v0.2i */
     /* p2c: checkmol.pas, line 9644:
     * Note: Turbo Pascal conditional compilation directive was ignored [218] */
       /*$IFDEF debug */
       //debugoutput ("too many neighbors - exiting");
       /*$ENDIF */
-    return false;
+    return isfalse;
+  }
   /* check if matchpath is not already filled up */
   if (matchpath_length (ndl_mp) == max_matchpath_length) {
     /* p2c: checkmol.pas, line 9653:
     * Note: Turbo Pascal conditional compilation directive was ignored [218] */
       /*$IFDEF debug */
       //debugoutput ("matchpath too int - exiting");
       /*$ENDIF */
-    return false;
+    return isfalse;
+  }
   /* next, check which chain of the needle matches which chain of the haystack  */
   for (i = 0; i < ndl_n_nb; i++) {
-    emptyline = true;
+    emptyline = istrue;
     next_ndl_a = ndl_nb[i];
     for (j = 0; j < n_nb; j++) {
             next_hst_a = hst_nb[j];
             ndl_mp[ndl_mp_len] = next_ndl_a;
             hst_mp[hst_mp_len] = next_hst_a;
 #endif
                         printf
                       ("Warning: max. number of match recursions (%i) reached, reverting to non-exhaustive match\n",
                       max_match_recursion_depth);
                       //n_rings = max_rings;
-                     return true;
+                     return istrue;
+                    }
-              mm[i][j] = true;
+              mm[i][j] = istrue;
-              emptyline = false;
+              emptyline = isfalse;
+            }
+          }
     /* if a needle substituent does not match any of the haystack substituents, */
     /* stop any further work immediately */
     if (emptyline)
-            return false;
+            return isfalse;
+  }
   /* finally, check the content of the matrix */
   res = matrix_OK (mm, ndl_n_nb, n_nb);
   /* optional: chirality check */
   if (!((res && (rs_search || ndl_atom[ndl_a - 1].stereo_care)) && ndl_maybe_chiral (ndl_a)))
+                    }
+            }
             if (n_hits == 1) {                  /* a unique match ==> kick out any other match at this pos. */
               for (m = 1; m <= max_neighbors; m++) {
                       if (m != j)
-                        mm[l - 1][m - 1] = false;
+                        mm[l - 1][m - 1] = isfalse;
+                    }
+            }
+          }
+  }
   /* end of match matrix clean-up */
     /* p2c: checkmol.pas, line 9749:
      * Note: Turbo Pascal conditional compilation directive was ignored [218] */
           /*$IFDEF debug */
           //debugoutput ("chirality check failed");
           /*$ENDIF */
-          res = false;
+          res = isfalse;
+  }
   else {
 /* p2c: checkmol.pas, line 9755:
  * Note: Turbo Pascal conditional compilation directive was ignored [218] */
       /*$IFDEF debug */
 static boolean quick_match ()
+{
   /* added in v0.2c */
   int i;
-  boolean res = true;
+  boolean res = istrue;
   /* str3 ndl_atype;*/
   str2 ndl_el;                  /* v0.3l */
   int ndl_chg = 0;              /* v0.3l */
   int ndl_rad = 0;              /* v0.3x */
   int ndl_iso = 0;              /* v0.3x */
   if ((ez_search || rs_search) && ndl_n_heavyatoms > 3)
     /* v0.3f, v0.3m, v0.3o */
-    return false;
+    return isfalse;
   if (ndl_n_atoms < 1 || n_atoms < 1 || ndl_n_atoms > n_atoms ||
         ndl_n_bonds > n_bonds) {                                /* just to be sure... */
     /* p2c: checkmol.pas, line 9786:
      * Note: Turbo Pascal conditional compilation directive was ignored [218] */
           /*$IFDEF debug */
     /* p2c: checkmol.pas: Note: Eliminated unused assignment statement [338] */
           //debugoutput (" ==> quick_match failed");
           /*$ENDIF */
-    return false;
+    return isfalse;
+  }
   if (ndl_n_heavyatoms > 1) {
     for (i = 0; i < ndl_n_atoms; i++) {
-            /*if atom^[i].atype <> ndl_atom^[i].atype then res := false;    (* changed in */
+            /*if atom^[i].atype <> ndl_atom^[i].atype then res := isfalse;    (* changed in */
             if (strcmp (atom[i].element, ndl_atom[i].element))  /* v0.2k */
-              return false;
+              return isfalse;
             //  if (atom[i].formal_charge != ndl_atom[i].formal_charge) /* v0.3o */
-            //res = false;
+            //res = isfalse;
             if (opt_chg) {
               if (ndl_atom[i].formal_charge != atom[i].formal_charge)
-                      return false;
+                      return isfalse;
+            }
       /*  else {
             if (ndl_atom[i].formal_charge != 0 &&
           atom[i].formal_charge != 0 &&
           ndl_atom[i].formal_charge != atom[i].formal_charge)
-        return false;
+        return isfalse;
           } */
           /* v0.3x: isotopes must be the same */
             if (opt_iso) {
               if (ndl_atom[i].nucleon_number != atom[i].nucleon_number)
-                      return false;
+                      return isfalse;
+            }
           /*  else {
           if (ndl_atom[i].nucleon_number != 0 &&
           atom[i].nucleon_number != 0 &&
           ndl_atom[i].nucleon_number !=
           atom[i].nucleon_number)
-        return false;
+        return isfalse;
         }*/
             /* v0.3x: radicals must be the same */
             if (opt_rad) {
               if (ndl_atom[i].radical_type != atom[i].radical_type)
-                      return false;
+                      return isfalse;
+            }
       /*  else {
          if (ndl_atom[i].radical_type != 0 &&
              atom[i].radical_type != 0 &&
              ndl_atom[i].radical_type != atom[i].radical_type)
-           return false;
+           return isfalse;
        }*/
+        }
   /* p2c: checkmol.pas, line 9798:
   * Note: Turbo Pascal conditional compilation directive was ignored [218] */
       /*$ENDIF */
     if (ndl_n_bonds > 0) {
             for (i = 0; i < ndl_n_bonds; i++) {
               if (ndl_bond[i].a1 != bond[i].a1 || ndl_bond[i].a2 != bond[i].a2
                         || ndl_bond[i].btype != bond[i].btype)
-                      return false;
+                      return isfalse;
+            }
+          }
     /* p2c: checkmol.pas, line 9810:
     * Note: Turbo Pascal conditional compilation directive was ignored [218] */
          /*$IFDEF debug */
     for (i = 0; i < n_atoms; i++) {                     /* v0.3l, v0.3o */
             if (                //      !strcmp (atom[i].atype, ndl_atype) &&
                 !strcmp (atom[i].element, ndl_el)) {
               if (opt_chg || opt_strict) {
                       if (ndl_chg != atom[i].formal_charge)
-                        return false;
+                        return isfalse;
+                    }
               if (opt_iso || opt_strict) {
                       if (ndl_iso != atom[i].nucleon_number)
-                        return false;
+                        return isfalse;
+                    }
               if (opt_rad || opt_strict) {
                       if (ndl_rad != atom[i].radical_type)
-                        return false;
+                        return isfalse;
+                    }
-                    return true;
+                    return istrue;
+            }
             else {
-              res=false;
+              res=isfalse;
+            }
+          }
+  }
   /* p2c: checkmol.pas, line 9828:
   * Note: Turbo Pascal conditional compilation directive was ignored [218] */
   /*ndl_ref_atom : integer;  (* since v0.3j as a global variable */
   int ndl_n_nb, ndl_n_hc, n_nb, n_hc;
   boolean qm;                   /* v0.3l */
   /* check for NoStruct (0 atoms);  v0.3l */
   if (n_atoms == 0 || ndl_n_atoms == 0) {
-      matchresult = false;
+      matchresult = isfalse;
   /* p2c: checkmol.pas, line 9849:
   * Note: Turbo Pascal conditional compilation directive was ignored [218] */
       /*$IFDEF debug */
       //debugoutput ("NoStruct encountered - aborted match routine");
       /*$ENDIF */
+  }
   /* if we perform an exact match, needle and haystack must have */
   /* the same number of atoms, bonds, and rings */
   if (opt_exact && opt_iso)     /* 0.3x */ {
       if (n_heavyatoms != ndl_n_heavyatoms || n_heavybonds != ndl_n_heavybonds) {
-              matchresult = false;
+              matchresult = isfalse;
       /* p2c: checkmol.pas, line 9861:
       * Note: Turbo Pascal conditional compilation directive was ignored [218] */
           /*$IFDEF debug */
           //debugoutput ("different number of heavy atoms and/or bonds");
           /*$ENDIF */
+  }
   /* have a quick look if needle and haystack are identical molfiles */
   qm = quick_match ();          /* v0.3l */
   if (qm) {
-    matchresult = true;
+    matchresult = istrue;
     clear_ndl_atom_tags ();     /* v0.3o */
     return;
+  }
-  /* if we have only one heavy atom and quick_match fails, return "false";  v0.3l */
+  /* if we have only one heavy atom and quick_match fails, return "isfalse";  v0.3l */
   if (ndl_n_heavyatoms == 1) {
-    matchresult = false;
+    matchresult = isfalse;
     return;
+  }
   /* p2c: checkmol.pas, line 9881:
   * Note: Turbo Pascal conditional compilation directive was ignored [218] */
   /*$IFDEF debug */
   /* p2c: checkmol.pas, line 9886:
   * Note: Turbo Pascal conditional compilation directive was ignored [218] */
   /*$IFDEF debug */
   /* debugoutput('neighbor atoms: '+inttostr(ndl_n_nb)+'  heteroatom neighbors: '+inttostr(ndl_n_hc)); */
   /*$ENDIF */
-  matchresult = false;
+  matchresult = isfalse;
   for (j = 0; j < max_matchpath_length; j++) {
     ndl_matchpath[j] = 0;
     hst_matchpath[j] = 0;
+  }
   ndl_matchpath[0] = ndl_ref_atom;
-  while (i < n_atoms && matchresult == false) {
+  while (i < n_atoms && matchresult == isfalse) {
     i++;
     n_nb = atom[i - 1].neighbor_count;
     n_hc = hetatom_count (i);
     if (n_nb >= ndl_n_nb && n_hc >= ndl_n_hc) {
       /* p2c: checkmol.pas, line 9904:
        * Note: Turbo Pascal conditional compilation directive was ignored [218] */
           /*$IFDEF debug */
           /* if matchresult then debugoutput('matching atom in haystack: '+inttostr(i)+' ('+atom^[i].atype+')'); */
           /*$ENDIF */
       if (matchresult)  /* v0.3o; mark this fragment as matched */
-        atom[i - 1].tag = true;
+        atom[i - 1].tag = istrue;
+          }
+  }
+}
 static void clear_rings ()
   int i, FORLIM;
   n_rings = 0;
   memset (ring, 0, sizeof (ringlist));
   for (i = 0; i < max_rings; i++) {                             /* new in v0.3 */
     ringprop[i].size = 0;
-    ringprop[i].arom = false;
+    ringprop[i].arom = isfalse;
-    ringprop[i].envelope = false;
+    ringprop[i].envelope = isfalse;
+  }
   if (n_atoms > 0) {
     FORLIM = n_atoms;
     for (i = 0; i < FORLIM; i++)
             atom[i].ring_count = 0;
   int FORLIM;
   if (n_rings < 2)
     return;
   FORLIM = n_rings;
   for (i = 1; i < FORLIM; i++) {
-    found_ring = false;
+    found_ring = isfalse;
     j = 0;
     pli = ringprop[i].size;     /* path_length(ring^[i]); */
-    while (j < i && found_ring == false) {
+    while (j < i && found_ring == isfalse) {
             j++;
-            found_all_atoms = true;
+            found_all_atoms = istrue;
             pl = ringprop[j - 1].size;  /* path_length(ring^[j]); */
             for (k = 0; k < pl; k++) {
-              found_atom = false;
+              found_atom = isfalse;
               a = ring[j - 1][k];
               for (l = 0; l < pli; l++) {
                       if (ring[i][l] == a)
-                        found_atom = true;
+                        found_atom = istrue;
+                    }
-              if (found_atom == false)
+              if (found_atom == isfalse)
-                      found_all_atoms = false;
+                      found_all_atoms = isfalse;
+            }
             if (found_all_atoms)
-              found_ring = true;
+              found_ring = istrue;
+          }
     if (found_ring)
-            ringprop[i].envelope = true;
+            ringprop[i].envelope = istrue;
+  }
+}
 static void update_ringcount ()
+{
   if (n_rings <= 0)
     return;
   chk_envelopes ();
   FORLIM = n_rings;
   for (i = 0; i < FORLIM; i++) {
-      if (ringprop[i].envelope == false) {
+      if (ringprop[i].envelope == isfalse) {
             pl = ringprop[i].size;      /* path_length(ring^[i]);  (* v0.3d */
             a2 = ring[i][pl - 1];
             for (j = 0; j < pl; j++) {
               a1 = ring[i][j];
               atom[a1 - 1].ring_count++;
+{
   /* v0.3k */
   /* changed from a procedure into a function in v0.3m */
   int i, a1, a2, fc1, fc2;
   char bt;
-  boolean res = false;          /* v0.3m */
+  boolean res = isfalse;                /* v0.3m */
   int FORLIM;
   /* v0.3m */
   if (n_bonds == 0)
-    return false;
+    return isfalse;
   FORLIM = n_bonds;
   for (i = 0; i < FORLIM; i++) {
     a1 = bond[i].a1;
     a2 = bond[i].a2;
     bt = bond[i].btype;
               strcpy (atom[a2 - 1].atype, "N3 ");
             if (bt == 'D')
               bond[i].btype = 'T';
             if (bt == 'S')
               bond[i].btype = 'D';
-            res = true;         /* v0.3m */
+            res = istrue;               /* v0.3m */
+          }
+  }
-  return res;                   /* v0.3m (return true if any change was made */
+  return res;                   /* v0.3m (return istrue if any change was made */
+}
 #if 0
 static void chk_wildcard_rings ()               // new in v0.3p
 // checks if there are any wildcard atom types or bond types
   int a1, a2, b;
   boolean wcr;
   str3 at;
   char bt;
-  if (ndl_querymol == false)
+  if (ndl_querymol == isfalse)
     return;
   if (ndl_n_rings == 0)
     return;
   // now look for any not-yet-aromatic rings which contain a wildcard
   for (i = 0; i < ndl_n_rings; i++) {
-    wcr = false;
+    wcr = isfalse;
-    if (ndl_ringprop[i].arom == false) {
+    if (ndl_ringprop[i].arom == isfalse) {
             rs = ndl_ringprop[i].size;
             a2 = ndl_ring[i][rs];
             for (j = 0; j < rs; j++) {
               a1 = ndl_ring[i][j];
               b = get_ndl_bond (a1, a2);
               strcpy (at, ndl_atom[a1].atype);
               bt = ndl_bond[b].btype;
               if (!strcmp (at, "A  ") || !strcmp (at, "Q  "))
-                      wcr = true;
+                      wcr = istrue;
               if (bt == 'l' || bt == 's' || bt == 'd' || bt == 'a')
-                      wcr = true;
+                      wcr = istrue;
               a2 = a1;
+            }
             if (wcr) {                  // if yes, flag all atoms and bonds in this ring as "potentially" aromatic
               // {$IFDEF debug}
               // debugoutput('wildcard ring found');
               for (j = 0; j < rs; j++) {
                       a1 = ndl_ring[i][j];
                       b = get_ndl_bond (a1, a2);
                       strcpy (at, ndl_atom[a1].atype);
                       bt = ndl_bond[b].btype;
-                      ndl_atom[a1].q_arom = true;
+                      ndl_atom[a1].q_arom = istrue;
-                      ndl_bond[b].q_arom = true;
+                      ndl_bond[b].q_arom = istrue;
                       a2 = a1;
+                    }
+            }
+          }
+  }
   // and now undo this flagging for all rings which contain no wildcard
   for (i = 0; i < ndl_n_rings; i++) {
-    wcr = false;
+    wcr = isfalse;
     rs = ndl_ringprop[i].size;
     a2 = ndl_ring[i][rs];
     for (j = 0; j < rs; j++) {
             a1 = ndl_ring[i][j];
             b = get_ndl_bond (a1, a2);
             strcpy (at, ndl_atom[a1].atype);
             bt = ndl_bond[b].btype;
             if (!strcmp (at, "A  ") || !strcmp (at, "Q  "))
-              wcr = true;
+              wcr = istrue;
             if (bt == 'l' || bt == 's' || bt == 'd' || bt == 'a')
-              wcr = true;
+              wcr = istrue;
             a2 = a1;
+          }
     if (!wcr) {                 // if yes, unflag all atoms and bonds in this ring
             a2 = ndl_ring[i][rs];
             for (j = 0; j < rs; j++) {
               a1 = ndl_ring[i][j];
               b = get_ndl_bond (a1, a2);
               strcpy (at, ndl_atom[a1].atype);
               bt = ndl_bond[b].btype;
-              ndl_atom[a1].q_arom = false;
+              ndl_atom[a1].q_arom = isfalse;
-              ndl_bond[b].q_arom = false;
+              ndl_bond[b].q_arom = isfalse;
               a2 = a1;
+            }
+          }
+  }
   // some further refinement would be necessary here in order to unflag everything
     FORLIM = molbufindex;
     for (i = 1; i <= FORLIM; i++)
             puts (molbuf[i - 1]);
     exit (3);
+  }
-  mol_OK = true;                /* added in v0.2i */
+  mol_OK = istrue;              /* added in v0.2i */
   if (!strcmp (filetype, "alchemy"))
     read_molfile (ndl_molfilename);
   if (!strcmp (filetype, "sybyl"))
     read_mol2file (ndl_molfilename);
   if (!strcmp (filetype, "mdl"))
     if (n_rings >= max_rings) {
             if (opt_verbose)
               printf ("Warning: max. number of rings (%i) reached, reverting to SSR search\n",
                  max_rings);
             ringsearch_mode = rs_ssr;
-            auto_ssr = true;    /* v0.3n */
+            auto_ssr = istrue;  /* v0.3n */
             clear_rings ();
             max_vringsize = ssr_vringsize;      /* v0.3n (was: 10) */
             chk_ringbonds ();
             remove_redundant_rings ();
+          }
                 printf ("input structure contains query atom or query bond!\n");
                 exit (1);
+            }
             chk_functionalgroups ();
             if (opt_none)
-              opt_text = true;
+              opt_text = istrue;
             if (opt_text)
               write_fg_text ();
             if (opt_text_de)
               write_fg_text_de ();
             if (opt_code)
             /* v0.3n (was: 10) */
             readinputfile (molfilename);
             li = 1;
             get_filetype (filetype, molfilename);
             if (strcmp (filetype, "unknown")) {
-              found_arominfo = false;   /* added in v0.2b */
+              found_arominfo = isfalse; /* added in v0.2b */
-              mol_OK = true;    /* added in v0.2i */
+              mol_OK = istrue;  /* added in v0.2i */
               if (!strcmp (filetype, "alchemy"))
                       read_molfile (molfilename);
               if (!strcmp (filetype, "sybyl"))
                       read_mol2file (molfilename);
               if (!strcmp (filetype, "mdl"))
                             }   /* v0.3m */
                       /* now that we have both molecules, perform the comparison */
                       /* v0.3o: takes care of disconnected fragment... */
                       clear_atom_tags ();
                       set_ndl_atom_tags ();
-                      matchsummary = true;
+                      matchsummary = istrue;
                       perform_match ();
                       matchsummary = matchresult;
-                      if (count_tagged_ndl_heavyatoms () > 0 && matchsummary == true) {
+                      if (count_tagged_ndl_heavyatoms () > 0 && matchsummary == istrue) {
                               do {
                                 if (rs_strict)
                                         ndl_ref_atom = find_ndl_ref_atom_cv ();
                                 else
                                         ndl_ref_atom = find_ndl_ref_atom ();
                                 perform_match ();
-                                if (matchresult == false)
+                                if (matchresult == isfalse)
-                                        matchsummary = false;
+                                        matchsummary = isfalse;
+                              }
-                              while (count_tagged_ndl_heavyatoms () != 0 && matchsummary != false);
+                              while (count_tagged_ndl_heavyatoms () != 0 && matchsummary != isfalse);
+                            }
                       /* end of disconnected-fragment matching (v0.3o) */
-                      if (matchsummary == true) {       /* v0.3o */
+                      if (matchsummary == istrue) {     /* v0.3o */
                               if (opt_molout) {
                                 FORLIM = molbufindex;
                                 for (i = 1; i <= FORLIM; i++)
                                         puts (molbuf[i - 1]);
+                              }
                                 if (!opt_fp)    /* inttostr(mol_count) REPLACE!!!, */
                                         printf ("%i:T\n", mol_count);
                                 else {
                                         if (ndl_n_heavyatoms == n_heavyatoms &&
                                             ndl_n_heavybonds == n_heavybonds)
-                                          fp_exacthit = true;
+                                          fp_exacthit = istrue;
                                         else
-                                          fp_exacthit = false;
+                                          fp_exacthit = isfalse;
                                         if (fp_exacthit)
-                                          fp_exactblock = true;
+                                          fp_exactblock = istrue;
                                         if (fpformat == fpf_boolean) {
                                           if (fp_exacthit)      /* inttostr(mol_count), REPACE!!! */
                                                   printf ("%i:TX\n", mol_count);
                                           else
                                                   printf ("%i:T\n", mol_count);
                               if (fp_exactblock)
                                 fpdecimal++;
                               printf ("%lld\n", fpdecimal);
                               fpindex = 0;
                               fpdecimal = 0;
-                              fp_exactblock = false;
+                              fp_exactblock = isfalse;
+                            }
                       zap_molecule ();
                       molbufindex = 0;
+                    }
+                  }
             /* v0.3l */
             /* mol_OK */
             printf ("%i:unknown file format\n", mol_count);
+          }
+        }
-  while (mol_in_queue != false);
+  while (mol_in_queue != isfalse);
     /* if filetype <> 'unknown' */
     if (opt_fp && fpformat == fpf_decimal && fpindex > 0) {
             if (fp_exactblock)
               fpdecimal++;
             printf ("%lld\n", fpdecimal);
+{
 //printf("init_globals_dll\n");
   int i;
-  opt_verbose = false;
+  opt_verbose = isfalse;
-  opt_debug = false;
+  opt_debug = isfalse;
-  opt_stdin = false;
+  opt_stdin = isfalse;
-  opt_text = false;
+  opt_text = isfalse;
-  opt_code = false;
+  opt_code = isfalse;
-  opt_bin = false;
+  opt_bin = isfalse;
-  opt_bitstring = false;
+  opt_bitstring = isfalse;
-  opt_molout = false;
+  opt_molout = isfalse;
-  opt_molstat = false;
+  opt_molstat = isfalse;
-  opt_molstat_X = false;
+  opt_molstat_X = isfalse;
-  opt_xmdlout = false;
+  opt_xmdlout = isfalse;
-  opt_fp = false;               /* new in v0.3m */
+  opt_fp = isfalse;             /* new in v0.3m */
-  /*cm_mdlmolfile   := false; */
+  /*cm_mdlmolfile   := isfalse; */
-  found_arominfo = false;
+  found_arominfo = isfalse;
-  found_querymol = false;
+  found_querymol = isfalse;
-  ndl_querymol = false;
+  ndl_querymol = isfalse;
   opt_rs = rs_sar;              /* v0.3i */
   ringsearch_mode = opt_rs;
-  rfile_is_open = false;        /* new in v0.2g */
+  rfile_is_open = isfalse;      /* new in v0.2g */
-  ez_flag = false;              /* new in v0.3f */
+  ez_flag = isfalse;            /* new in v0.3f */
-  chir_flag = false;            /* new in v0.3f */
+  chir_flag = isfalse;          /* new in v0.3f */
   n_Ctot = 0;
   n_Otot = 0;
   n_Ntot = 0;                   /* new in v0.3g */
   //for (i = 0; i < max_fg; i++)
-  //  fg[i] = false;
+  //  fg[i] = isfalse;
   memset (fg, 0, sizeof (fglist));
   if (!yet_initialized) {
     molbuf = (void *) safe_malloc (sizeof (molbuftype));
-    opt_exact = false;
+    opt_exact = isfalse;
-    opt_strict = false; /* new in v0.2f */
+    opt_strict = isfalse;       /* new in v0.2f */
-    opt_metalrings = false;     /* new in v0.3 */
+    opt_metalrings = isfalse;   /* new in v0.3 */
-    opt_geom = false;           /* new in v0.3d */
+    opt_geom = isfalse;         /* new in v0.3d */
-    opt_chiral = false; /* new in v0.3f */
+    opt_chiral = isfalse;       /* new in v0.3f */
-    opt_iso = false;            /* new in v0.3x */
+    opt_iso = isfalse;          /* new in v0.3x */
-    opt_chg = false;            /* new in v0.3x */
+    opt_chg = isfalse;          /* new in v0.3x */
-    opt_rad = false;            /* new in v0.3x */
+    opt_rad = isfalse;          /* new in v0.3x */
-    ez_search = false;  /* new in v0.3d */
+    ez_search = isfalse;        /* new in v0.3d */
-    rs_search = false;  /* new in v0.3f */
+    rs_search = isfalse;        /* new in v0.3f */
-    rs_strict = false;  /* new in v0.3j */
+    rs_strict = isfalse;        /* new in v0.3j */
     ndl_n_Ctot = 0;
     ndl_n_Otot = 0;
     ndl_n_Ntot = 0;             /* new in v0.3g */
-    yet_initialized = true;
+    yet_initialized = istrue;
+  }
-  ether_generic = false;        /* v0.3j */
+  ether_generic = isfalse;      /* v0.3j */
-  amine_generic = false;        /* v0.3j */
+  amine_generic = isfalse;      /* v0.3j */
-  hydroxy_generic = false;      /* v0.3j */
+  hydroxy_generic = isfalse;    /* v0.3j */
   fpformat = fpf_decimal;       /* v0.3m */
   fpindex = 0;                  /* v0.3m */
-  fp_exacthit = false;          /* v0.3m */
+  fp_exacthit = isfalse;                /* v0.3m */
-  fp_exactblock = false;        /* v0.3m */
+  fp_exactblock = isfalse;      /* v0.3m */
   tmfcode = 0;                  /* v0.3m */
-  tmfmismatch = false;          /* v0.3m */
+  tmfmismatch = isfalse;                /* v0.3m */
-  auto_ssr = false;
+  auto_ssr = isfalse;
   recursion_depth = 0;
+}
 static void mm_init_mol ( )
+{
   if (strcmp (filetype, "unknown") == 0) {
     //messagebox (0,'Error in mm_ElabMol: Unknown file format','MATCHMOLDLL ERROR',0);
     exit (3);
+  }
-  if (checkmol_mode == true)
+  if (checkmol_mode == istrue)
     progmode = pmCheckMol;
   else
     progmode = pmMatchMol;
   if (strcmp (filetype, "alchemy") == 0)
     read_molfile (ndl_molfilename);
             remove_redundant_rings ();
     if (n_rings >= max_rings) {
             printf ("Warning: max. number of rings (%i) reached, reverting to SSR search\n",
                max_rings);
             ringsearch_mode = rs_ssr;
-            auto_ssr = true;
+            auto_ssr = istrue;
             clear_rings ();
             max_vringsize = ssr_vringsize;
             chk_ringbonds ();
             remove_redundant_rings ();
+          }
   //mm_ElabMol;
   copy_mol_to_needle ();
   //chk_wildcard_rings (); /* 0.3p */
   set_ndl_atom_tags ();         /* v0.3o */
   if (opt_geom)                 /* v0.3d */
-    ez_search = true;
+    ez_search = istrue;
   else if (!ez_flag && ez_search)
-    ez_search = false;          //chir_flag initialized in read_MDLmolfile, otherwise we lose that info
+    ez_search = isfalse;                //chir_flag initialized in read_MDLmolfile, otherwise we lose that info
   if (opt_chiral) {                             /* v0.3f */
-      rs_search = true;
+      rs_search = istrue;
       //printf("%i\n",rs_search);
+  }
   else
     if (!chir_flag && rs_search) {
-      rs_search = false;        //chir_flag initialized in read_MDLmolfile, otherwise we lose that info
+      rs_search = isfalse;      //chir_flag initialized in read_MDLmolfile, otherwise we lose that info
       //printf("%i\n",rs_search);
+    }
   if (opt_chiral && opt_strict && opt_exact)    /* new in v0.3j */
-    rs_strict = true;
+    rs_strict = istrue;
   else
-    rs_strict = false;
+    rs_strict = isfalse;
     /* if (rs_strict)              // v0.3j
        ndl_ref_atom = find_ndl_ref_atom_cv ();
        //ndl_ref_atom = find_ndl_ref_atom ();
        else
        ndl_ref_atom = find_ndl_ref_atom (); */
+{
 //printf("mm_read_input_line_in\n");
 //var
 //yyy:pchar;
-  mol_in_queue = false;
+  mol_in_queue = isfalse;
   if (molbufindex < (max_atoms + max_bonds + slack)) {
     //yyy:=Pchar(IntToStr(molbufindex));
     //messagebox (0,yyy,'',0);
     //printf("%i\n",molbufindex);
 //printf("mm_set_mol\n");
+}
 DLLEXPORT void cm_set_mol (const char *st, int normalize_ionic_bnds)
+{
-  mm_set_mol_dll (st, true, (normalize_ionic_bnds != FEATURE_OFF));
+  mm_set_mol_dll (st, istrue, (normalize_ionic_bnds != FEATURE_OFF));
+}
 DLLEXPORT void mm_set_mol (const char *st)
+{
-  mm_set_mol_dll (st, false, true);
+  mm_set_mol_dll (st, isfalse, istrue);
+}
 DLLEXPORT void xm_set_strict_typing (int strict_typing)
+{
   if (!yet_initialized)
     init_globals_dll ();
   opt_strict = (strict_typing != FEATURE_OFF);
-  //opt_strict=false; //This never worked right and is harmful
+  //opt_strict=isfalse; //This never worked right and is harmful
+}
 DLLEXPORT void mm_set_r_s_check (int r_s_check)
+{
   if (!yet_initialized)
   //ndl_ref_atom = find_ndl_ref_atom ();
   else
     ndl_ref_atom = find_ndl_ref_atom ();
   clear_atom_tags ();
   set_ndl_atom_tags ();
-  matchsummary = true;
+  matchsummary = istrue;
   perform_match ();
   matchsummary = matchresult;
-  if (count_tagged_ndl_heavyatoms () > 0 && matchsummary == true) {
+  if (count_tagged_ndl_heavyatoms () > 0 && matchsummary == istrue) {
     do {
             if (rs_strict)
               ndl_ref_atom = find_ndl_ref_atom_cv ();
             else
               ndl_ref_atom = find_ndl_ref_atom ();
             perform_match ();
-            if (matchresult == false)
+            if (matchresult == isfalse)
-             matchsummary = false;
+             matchsummary = isfalse;
+          }
-    while (count_tagged_ndl_heavyatoms () != 0 && matchsummary != false);
+    while (count_tagged_ndl_heavyatoms () != 0 && matchsummary != isfalse);
+  }
   //-----------------------------------------------------
   //mol_count = 0;

Subversion Repositories wimsdev

(root)/trunk/wims/src/Misc/checkmol/checkmolc.c – Rev 17891 → 18544