/*============================================================================*/
/* FILENAME: WRITE_MM2.C (WRITE_MM2.O)
/* PURPOSE: TO WRITE OUT THE CURRENT GEOMETRY AS AN MM2 INPUT FILE.
/* WRITTEN: M.V.GRIESHABER
/* MODIFICATIONS:
/*	22 JULY 1993 MVG (INCREASED RUN TIME TO MAX LIMIT).
/*	12 JULY 1993 MVG (CORRECTED SOME MM3 ONLY ATOM TYPES).
/*	8 FEBRUARY 1993 MVG (EXTENDED SYBYL ATOM TYPES, NEW MM3 TYPES).
/*============================================================================*/

#include "utility.h"
#include "newgeo.h"

#define MAX_RINGS 100			/* MAX RINGS IN A MOLECULE. */
#define MAX_CONNECTED_ATOM_LISTS 20	/* ONE LIST PER LINE. */
#define MAX_ATTACHED_ATOM_LISTS 20	/* REALLY ONLY ONE LIST, BUT SPREAD ACROSS THIS MANY LINES. */
#define MAX_ATOMS_PER_LIST 16		/* REALLY MAX ATOMS NUMBERS PER LINE. */
#define TERMINATION_ENERGY 0.00008	/* OPTIMIZATION TERMINATION (KCAL/MOLE). */
#define MM2_LONE_PAIR_TYPE 20		/* FOR AUTO ADD OF LONE PAIRS. */
#define MM2_LONE_PAIR_RADIUS 0.6	/* FOR AUTO ADD OF LONE PAIRS. */

typedef struct				/* DEFINE A LIST OF ATOMS. */
   {
   int natoms;				/* NUMBER OF ATOMS IN LIST. */
   int atoms[MAX_ATOMS];		/* ATOM INDEX. */
   } ATOM_LIST;

int nrings;				/* NUMBER OF RINGS IN LIST. */
ATOM_LIST rings[MAX_RINGS];		/* UNIQUE RINGS IN MOLECULE. */

int ring_candidate_atom[MAX_ATOMS];	/* T/F: CONSIDER ATOM IN RING SEARCH. */
int ring_check_atom[MAX_ATOMS];		/* T/F: CHECK ATOM FOR RING. */

int write_mm2_input(geometry_type,outfile)
/*============================================================================*/
/* PURPOSE: TO WRITE OUT THE CURRENT GEOMETRY AS AN MM2 OR MM3 INPUT FILE.
*/
   int geometry_type;		/* SPECIFIES MM2 OR MM3 TYPE FILE. */
   FILE *outfile;		/* MM2 FORMAT OUTPUT. */
   {
   int target_atom;		/* ATOM TO LOOK FOR. */
   int current_atom;		/* ATOM WE ARE PRESENTLY AT. */
   int previous_atom;		/* ATOM WE WERE PREVIOUSLY AT. */
   ATOM_LIST path;		/* PATH FOLLOWED DURING SEARCH. */
   int natom;			/* WHICH ATOM. */
   int aromatics_exist;		/* T/F: WHETHER AROMATIC ATOMS EXIST IN MOLECULE. */
   int nlone_pairs;		/* TOTAL ADD_LONE_PAIRS FLAGS. */
   int nconnected_atom_lists;	/* TOTAL CONNECTED ATOM LISTS. */
   int connected_atom_lists[MAX_CONNECTED_ATOM_LISTS][MAX_ATOMS_PER_LIST];
   int nattached_atoms;		/* TOTAL ATTACHED ATOMS IN MOLECULE. */
   int attached_atom_lists[MAX_ATTACHED_ATOM_LISTS][MAX_ATOMS_PER_LIST];
   char line[150];		/* MULTIPURPOSE STRING. */
   char default_title[100];	/* DEFAULT TITLE. */
   int nlist;			/* WHICH LIST. */
   int status;			/* RETURN STATUS FROM USER INTERFACE ROUTINES. */
   struct
      {
      int atom_type;		/* MM2 ATOM TYPE. */
      int aromatic;		/* T/F: AROMATIC ATOM TYPE. */
      int add_lone_pairs;	/* T/F: WHETHER TO AUTO ADD LONE PAIRS. */
      } mm2_data[MAX_ATOMS];	/* SAVED VALUES FROM MM2_ATOM_TYPE ROUTINE. */

   void find_rings();		/* FIND RINGS FROM CURRENT TO TARGET ATOM. */
   void mark_ring_atoms();	/* DETERMINE WHICH ATOMS TO CONSIDER FOR RINGS. */
   void filter_atom_type();	/* FILTER SPECIFIED ATOM TYPE. */

   /* FILTER OUT LONE PAIRS (AUTOMATICALLY ADDED AS NEEDED) AND DUMMY ATOMS. */
   /* WARN USER IF ANY DUMMY ATOMS WERE DELETED. */
   filter_atom_type("LP");
   for (natom=0; natom<atom_cnt; natom++)
      {
      if (strncmp(intco[natom].atom_name,"Du",2)==0)
         {
         filter_atom_type("Du");
         printf("Warning: Dummy atoms have been deleted from this molecule.\n");
         break;
         }
      }

   /* FIND ALL RINGS ORIGINATING AT EACH "RING CHECK" ATOM IN THE MOLECULE. */
   mark_ring_atoms();
   for (natom=0; natom<atom_cnt; natom++)
      {
      if (ring_check_atom[natom])
         {
         target_atom=current_atom=natom;	/* LOOK FOR CURRENT ATOM. */
         previous_atom= -1;			/* NO PREVIOUS ATOM. */
         path.natoms=0;				/* NOTHING ON PATH YET. */
         find_rings(target_atom,current_atom,previous_atom,path);
         }
      }

   /* CONVERT ALL THE ATOMS TO THEIR RESPECTIVE MM2 ATOM TYPES AND FLAGS. */
   aromatics_exist=FALSE;
   nlone_pairs=0;
   for (natom=0; natom<atom_cnt; natom++)
      {
      mm2_data[natom].atom_type=mm2_atom_type(geometry_type,natom,&mm2_data[natom].aromatic,&mm2_data[natom].add_lone_pairs);

      /*DEBUGprintf("Atom #%2d: SYBYL type=%2d, MM2 type=%2d",natom+1,intco[natom].source_type,mm2_data[natom].atom_type);/**/
      if (mm2_data[natom].aromatic)
         {
         aromatics_exist=TRUE;
         /*DEBUGprintf(", aromatic");/**/
         }
      if (mm2_data[natom].add_lone_pairs)
         {
         nlone_pairs++;
         /*DEBUGprintf(", lone pairs");/**/
         }
      /*DEBUGprintf("\n");/**/
      }

   /* FORM THE CONNECTED AND ATTACHED ATOM LISTS. */
   nconnected_atom_lists=make_connected_atom_lists(connected_atom_lists);
   nattached_atoms=make_attached_atom_lists(attached_atom_lists);

   /* ASK THE USER FOR A TITLE. */
   sprintf(default_title,"%s (from %s)",source_title,input_file_name);
   printf("\nDefault title: \"%s\"\n",default_title);
   status=gstring("Enter new title",NULL_OK,line);
   if (status==ABORT_ENTRY) return(FALSE);
   else if (status==NULL_ENTRY) strcpy(line,default_title);
   line[60]=0;

   /* HAVING CONVERTED ALL ATOMS, NOW PRODUCE THE ACTUAL MM2 INPUT FILE. */
   /* NOTE THAT THE COMMENTS REFLECT MM2 DOCUMENTATION TERMINOLOGY. */

   /* LINE 1 (NAME CARD). */
   fprintf(outfile,"%-60s",line);		/* TITLE. */
   fprintf(outfile,"%1d",aromatics_exist);	/* METHOD. */
   fprintf(outfile,"%4d",atom_cnt);		/* TOTAL ATOMS. */
   fprintf(outfile,"    0    099999\n");	/* PRINTOUT, ?, TIME ALLOC. */

   /* OPTIONAL LINE 1A (PI-SYSTEM INFORMATION). */
   if (aromatics_exist)
      {
      for (natom=0; natom<60; natom++)	/* MAX 60 AROMATIC FLAGS. */
         {
         if (natom<atom_cnt && mm2_data[natom].aromatic) fprintf(outfile,"T");
         else fprintf(outfile," ");	/* AROMATIC FLAG. */
         }
      fprintf(outfile,"01                  \n");	/* ?,?. */
      }

   /* LINE 2 (LISTS AND OPTIONS). */
   if (geometry_type==TYPE_MM3_INPUT) nlone_pairs=0;
   fprintf(outfile,"%5d     %10.5f     %5d    0%5d    0    0    0    0    0         1    0\n",
      nconnected_atom_lists,TERMINATION_ENERGY,nattached_atoms,nlone_pairs);

   /* LINE 3 (CONNECTED ATOM LISTS). */
   for (nlist=0; nlist<nconnected_atom_lists; nlist++)
      {
      for (natom=0; natom<MAX_ATOMS_PER_LIST; natom++)
         {
         if (connected_atom_lists[nlist][natom]>0) fprintf(outfile,"%5d",connected_atom_lists[nlist][natom]);
         else fprintf(outfile,"     ");
         }
      fprintf(outfile,"\n");
      }

   /* LINE 4 (ATTACHED ATOM LIST). */
   for (nlist=0; nlist<((nattached_atoms*2-1)/MAX_ATOMS_PER_LIST)+1; nlist++)
      {
      for (natom=0; natom<MAX_ATOMS_PER_LIST; natom++)
         {
         if (attached_atom_lists[nlist][natom]>0) fprintf(outfile,"%5d",attached_atom_lists[nlist][natom]);
         else fprintf(outfile,"     ");
         }
      fprintf(outfile,"\n");
      }

   /* LINE 5 (COORDINATES). */
   for (natom=0; natom<atom_cnt; natom++)
      {
      fprintf(outfile,"%10.5f%10.5f%10.5f%5d(%3d)                                        \n",
         intco[natom].vector[0],intco[natom].vector[1],intco[natom].vector[2],mm2_data[natom].atom_type,natom+1);
      }

   /* OPTIONAL LINE 5A (COORDINATE CALCULATION OPTIONS - ADDITION OF LONE PAIRS). */
   if (geometry_type==TYPE_MM2_INPUT)
     {
     for (natom=0; natom<atom_cnt; natom++)
       {
       if (mm2_data[natom].add_lone_pairs)
          {
          if (mm2_data[natom].atom_type==8)
             {
             /* FORMAT FOR AMINE NITROGEN (MM2 TYPE 8). */
             fprintf(outfile,"    1%5d%5d%5d%5d          %5d               %5.3f                    \n",
                natom+1,intco[natom].bonds[0]+1,intco[natom].bonds[1]+1,intco[natom].bonds[2]+1,
                MM2_LONE_PAIR_TYPE,MM2_LONE_PAIR_RADIUS);
             }
          else if (mm2_data[natom].atom_type==52 || mm2_data[natom].atom_type==37 ||
             (mm2_data[natom].atom_type==41 && mm2_data[natom].aromatic))
             {
             /* FORMAT FOR SP2 NITROGEN (MM2 TYPE 52), AROMATIC NITROGEN (MM2 TYPE 37), */
             /* AND ENOL OXYGEN (MM2 TYPE 41 AND AROMATIC FLAG). */
             fprintf(outfile,"    4%5d%5d%5d               %5d               %5.3f                    \n",
                natom+1,intco[natom].bonds[0]+1,intco[natom].bonds[1]+1,MM2_LONE_PAIR_TYPE,MM2_LONE_PAIR_RADIUS);
             }
          else if (mm2_data[natom].atom_type==6 || (mm2_data[natom].atom_type==41 && !mm2_data[natom].aromatic))
             {
             /* FORMAT FOR SP3 OXYGEN (MM2 TYPE 6) AND FURAN OXYGEN (MM2 TYPE 41 AND NOT AROMATIC FLAG). */
             fprintf(outfile,"    2%5d%5d%5d               %5d%5d          %5.3f%5.3f               \n",
                natom+1,intco[natom].bonds[0]+1,intco[natom].bonds[1]+1,MM2_LONE_PAIR_TYPE,
                MM2_LONE_PAIR_TYPE,MM2_LONE_PAIR_RADIUS,MM2_LONE_PAIR_RADIUS);
             }
          }
       }
     }

   return(TRUE);
   }

void mark_ring_atoms()
/*============================================================================*/
/* PURPOSE: DETERMINE WHICH ATOMS TO CONSIDER IN THE RING SEARCH.  SINCE NO
/*	TERMINAL ATOM CAN POSSIBLY BE IN A RING, WE REMOVE ALL TERMINAL ATOMS
/*	FROM CONSIDERATION.  SINCE THIS CAN EXPOSE NEW ATOMS WHICH ARE NOW
/*	TERMINAL ATOMS, WE CONTINUE REMOVING TERMINAL ATOMS ITERATIVELY UNTIL
/*	NO MORE CAN BE REMOVED.  THIS DRAMATICALLY SPEEDS THE SEARCH SINCE IT
/*	REDUCES THE COMBINATORIAL COMPLEXITY.
/*	ADDITIONALLY, WE IDENTIFY THOSE ATOMS WHICH ARE THE MINIMAL SET OF
/*	ATOMS THAT *NEED* CHECKING FOR RING MEMBERSHIP AS "RING CHECK" ATOMS.
/*	AN ATOM IS A RING CHECK ATOM IF IT HAS 3 OR MORE BONDS TO "RING
/*	CANDIDATE" ATOMS.  FOR A RING TO BE PART OF A LARGER MOLECULE, AT LEAST
/*	ONE ATOM IN EACH RING HAS AT LEAST THREE BONDS (TWO IN THE RING, ONE
/*	OUTSIDE THE RING) - THUS SUCH ATOMS ARE THE PREFERENTIAL STARTING POINTS
/*	FOR RING CHECKING.  IF NO ATOM HAS AT LEAST THREE BONDS, THE MOLECULE
/*	CAN HAVE AT MOST A SINGLE RING, SO THE FIRST VALID ATOM IS LABELED AS A
/*	RING CHECK ATOM.
*/
   {
   int natom;			/* WHICH ATOM. */
   int nbond;			/* WHICH BOND. */
   int atom_was_marked;		/* T/F: AN ATOM WAS MARKED AS INVALID. */
   int nvalid_bonds;		/* NUMBER OF VALID BONDS FOR AN ATOM. */
   int nring_check_atoms;	/* NUMBER OF ATOMS WITH >=3 BONDS. */

   /* TO START, ASSUME ALL ATOMS ARE BOTH "RING" AND "RING CHECK" CANDIDATES. */
   for (natom=0; natom<atom_cnt; natom++)
      {
      ring_candidate_atom[natom]=TRUE;
      ring_check_atom[natom]=TRUE;
      }

   /* ITERATIVELY MARK ALL TERMINAL ATOMS (THOSE WITH ONLY ONE BOND TO A */
   /* RING CANDIDATE ATOM) AS INVALID RING CANDIDATES. */
   do
      {
      atom_was_marked=FALSE;
      nring_check_atoms=atom_cnt;
      for (natom=0; natom<atom_cnt; natom++)
         {
         if (ring_candidate_atom[natom])
            {
            /* COUNT ALL BONDS FROM THIS RING CANDIDATE ATOM TO OTHER RING CANDIDATE ATOMS. */
            nvalid_bonds=0;
            for (nbond=0; nbond<intco[natom].bond_cnt; nbond++)
               {
               if (ring_candidate_atom[intco[natom].bonds[nbond]]) nvalid_bonds++;
               }

            if (nvalid_bonds<3)
               {
               /* WITH < 3 BONDS, THIS ATOM CANNOT BE A RING CHECK ATOM. */
               ring_check_atom[natom]=FALSE;
               nring_check_atoms--;
               }
            if (nvalid_bonds<2)
               {
               /* WITH < 2 BONDS, THIS ATOM CANNOT BE IN A RING. */
               ring_candidate_atom[natom]=FALSE;
               atom_was_marked=TRUE;
               }
            }
         else nring_check_atoms--;
         }
      } while (atom_was_marked);

   /* CHECK SPECIAL CASE OF ZERO RING CHECK ATOMS. */
   if (nring_check_atoms==0)
      {
      /* LABEL FIRST RING CANDIDATE ATOM AS THE SOLE RING CHECK ATOM. */
      for (natom=0; natom<atom_cnt; natom++)
         {
         if (ring_candidate_atom[natom])
            {
            ring_check_atom[natom]=TRUE;
            break;
            }
         }
      }

   return;
   }

void find_rings(target_atom,current_atom,previous_atom,path)
/*============================================================================*/
/* PURPOSE: FIND ALL PATHS FROM CURRENT_ATOM TO TARGET_ATOM.  THIS IS ALMOST
/*	A GENERALIZED "PATH" FINDING ALGORITHM, BUT IS SPECIFICALLY LOOKING
/*	FOR RINGS.
*/
   int target_atom;		/* ATOM TO LOOK FOR. */
   int current_atom;		/* ATOM WE ARE PRESENTLY AT. */
   int previous_atom;		/* ATOM WE WERE PREVIOUSLY AT. */
   ATOM_LIST path;		/* LIST OF ATOMS VISITED SO FAR. */
   {
   ATOM_LIST path_copy;		/* COPY OF PATH. */
   int new_current_atom;	/* ATOM WE ARE MOVING TO. */
   int nbond;			/* WHICH BOND. */

   void log_ring();		/* LOG RING IN THE GLOBAL RING LIST. */
   int already_visited();	/* CHECK IF ATOM HAS BEEN VISITED. */	

   if (current_atom==target_atom && path.natoms>0)
      {
      /* HAVE A (POSSIBLY UNIQUE) RING, LOG IT. */
      log_ring(path);
      }
   else if (already_visited(current_atom,path))
      {
      /* ALREADY VISITED THIS ATOM, CAN'T CROSS PATH SO NO FURTHER ACTION. */
      }
   else
      {
      /* FOLLOW EACH BOND THAT IS AVAILABLE FROM THE CURRENT ATOM. */
      for (nbond=0; nbond<intco[current_atom].bond_cnt; nbond++)
         {
         new_current_atom=intco[current_atom].bonds[nbond];
         if (ring_candidate_atom[new_current_atom] && new_current_atom!=previous_atom)
            {
            /* DUPLICATE PATH SINCE WE DIVERGE DOWN A SIDE PATH HERE. */
            memcpy((char *)&path_copy,(char *)&path,sizeof(ATOM_LIST));

            /* ADD THE CURRENT ATOM TO THE PATH_COPY AND KEEP LOOKING. */
            path_copy.atoms[path_copy.natoms++]=current_atom;
            find_rings(target_atom,new_current_atom,current_atom,path_copy);
            }
         }
      }

   return;
   }

void log_ring(path)
/*============================================================================*/
/* PURPOSE: LOG THE DISCOVERY OF A RING.  IF IT DUPLICATES A PREVIOUSLY FOUND
/*	RING, NO ACTION IS TAKEN.  IF IT IS NEW, THE RING IS ADDED TO THE LIST
/*	OF KNOWN RINGS.
*/
   ATOM_LIST path;	/* PATH CONTAINING A POSSIBLY UNIQUE RING. */
   {
   int nring;		/* WHICH RING. */
   int natom;		/* WHICH ATOM. */
   int found;		/* T/F; RING EXISTS IN LIST ALREADY. */

   void qsort();	/* QUICK SORT. */
   int intcmp();	/* COMPARE TWO INTEGERS FOR QSORT. */

   /* SORT THE RING DEFINITION (ATOM LIST) TO MAKE IT EASIER TO COMPARE. */
   qsort((char *)path.atoms,(unsigned)path.natoms,sizeof(int),intcmp);

   /* SEARCH THE LIST OF KNOWN RINGS; ADD THIS RING IF NOT ALREADY IN LIST. */
   found=FALSE;
   for (nring=0; nring<nrings && !found; nring++)
      {
      if (rings[nring].natoms == path.natoms)
         {
         /* RIGHT NUMBER OF ATOMS, CHECK MATCH OF ATOMS. */
         found=TRUE;
         for (natom=0; natom<rings[nring].natoms; natom++)
            {
            if (rings[nring].atoms[natom] != path.atoms[natom]) found=FALSE;
            }
         }
      }

   /* IF THE RING WAS NOT FOUND AND THERE IS ROOM, ADD IT TO THE LIST. */
   if (!found && nrings<MAX_RINGS)
      {
      for (natom=0; natom<path.natoms; natom++)
         {
         rings[nrings].atoms[natom]=path.atoms[natom];
         }
      rings[nrings].natoms=path.natoms;
      nrings++;
      }

   return;
   }

int intcmp(int1,int2)
/*============================================================================*/
/* PURPOSE: COMPARE TWO INTEGERS FOR THE QSORT FUNCTION.
*/
   int *int1;
   int *int2;
   {
   if (*int1 < *int2) return(-1);
   else if (*int1 == *int2) return(0);
   else return(1);
   }

int already_visited(atom,path)
/*============================================================================*/
/* PURPOSE: DETERMINE IF THE SPECIFIED ATOM HAS ALREADY BEEN VISITED.
*/
   int atom;		/* ATOM IN QUESTION. */
   ATOM_LIST path;	/* PATH FOLLOWED SO FAR. */
   {
   int natom;		/* WHICH ATOM. */

   /* EXAMINE ALL THE ATOMS IN THE PATH FOR INCLUSION OF THIS ATOM. */
   for (natom=0; natom<path.natoms; natom++)
      {
      if (path.atoms[natom] == atom) return(TRUE);
      }

   return(FALSE);
   }

int mm2_atom_type(geometry_type,index,set_aromatic_flag,add_lone_pairs)
/*============================================================================*/
/* PURPOSE: CONVERT THE SPECIFIED ATOM TO THE APPROPRIATE MM2/MM3 ATOM TYPE.
/*	FOR SYBYL INPUT GEOMETRY, WE CAN DO A GOOD JOB; FOR ALL OTHERS WE DO
/*	NOTHING YET (NOT YET IMPLEMENTED).
*/
   int geometry_type;		/* SPECIFIES MM2 OR MM3 TYPES DESIRED. */
   int index;			/* INDEX NUMBER OF ATOM. */
   int *set_aromatic_flag;	/* T/F TO SET MM2 AROMATIC FLAG. */
   int *add_lone_pairs;		/* T/F TO AUTOMATICALLY ADD LONE PAIRS. */
   {
   int mm2_type;		/* RESOLVED MM2 ATOM TYPE. */

   if (geometry_source==TYPE_SYBYL_MOL)
      {
      *set_aromatic_flag=FALSE;
      *add_lone_pairs=FALSE;

      switch (intco[index].source_type)
         {
         case 1:		/* SYBYL TYPE C.3 (SP3 CARBON) */
            if (in_three_member_ring(index))
               mm2_type=22;	/* CYCLOPROPANE. */
            else if (geometry_type==TYPE_MM3_INPUT && in_four_member_ring(index))
               mm2_type=56;	/* MM3 ONLY: CYCLOBUTANE SP3 CARBON. */
            else
               mm2_type=1;	/* SP3 CARBON. */
            break;

         case 2:		/* SYBYL TYPE C.2 (SP2 CARBON) */
            if (in_three_member_ring(index))
               {
               if (connected_to("9",index,-1))
                  mm2_type=67;	/* CYCLOPROPANONE C=O. */
               else
                  mm2_type=38;	/* CYCLOPROPENE. */
               }
            else if (in_non_carbonyl_non_c3_ring(6,index) || in_hetero_non_c3_ring(5,index))
               {
               mm2_type=2;	/* AROMATIC. */
               *set_aromatic_flag=TRUE;
               }
            else if (connected_to("9 13",index,-1))
               mm2_type=71;	/* KETONIUM CARBON. */
            else if (connected_to("9",index,-1))
               {
               if (geometry_type==TYPE_MM3_INPUT && in_four_member_ring(index))
                  mm2_type=58;	/* MM3 ONLY: CYCLOBUTANE C=O. */
               else
                  mm2_type=3;	/* CARBONYL. */
               }
            else if (connected_to("6",index,-1))
               mm2_type=3;	/* IMINE/OXIME CARBON. */
            else if (geometry_type==TYPE_MM3_INPUT && in_four_member_ring(index))
               mm2_type=57;	/* MM3 ONLY: CYCLOBUTENE SP2 CARBON. */
            else
               mm2_type=2;	/* SP2 CARBON. */
            break;

         case 3:		/* SYBYL TYPE C.ar (AROMATIC CARBON). */
            mm2_type=2;		/* AROMATIC CARBON. */
            *set_aromatic_flag=TRUE;
            break;

         case 4:		/* C.1 (SP CARBON). */
            if (geometry_type==TYPE_MM3_INPUT && connected_to("9",index,-1))
               mm2_type=106;	/* KETENE. */
            else if (intco[index].bond_cnt==2 && (connected_to("4",index,-1)==2 || connected_to("2",index,-1)==2))
               mm2_type=68;	/* CUMULENE C SP (=C=). */
            else
               mm2_type=4;	/* SP CARBON. */
            break;

         case 5:		/* SYBYL TYPE N.3 (SP3 AMINE NITROGEN). */
            if (in_non_c3_ring(5,index) || in_non_c3_ring(6,index))
               {
               if (intco[index].bond_cnt==3)
                  {
                  mm2_type=40;	/* PYROLE NITROGEN. */
                  *set_aromatic_flag=TRUE;
                  }
               else
                  {
                  mm2_type=37;	/* PYRIDINE NITROGEN. */
                  *set_aromatic_flag=TRUE;
                  *add_lone_pairs=TRUE;
                  }
               }
            else if (connected_to("2 9",index,-1) || connected_to("2 18",index,-1))
               mm2_type=9;	/* AMIDE NITROGEN. */
            else
               {
               mm2_type=8;	/* SP3 AMINE NITROGEN. */
               *add_lone_pairs=TRUE;
               }
            break;

         case 6:		/* SYBYL TYPE N.2 (SP2 NITROGEN). */
            if (in_non_c3_ring(5,index) || in_non_c3_ring(6,index))
               {
               if (intco[index].bond_cnt==3)
                  {
                  mm2_type=40;	/* PYROLE NITROGEN. */
                  *set_aromatic_flag=TRUE;
                  }
               else
                  {
                  mm2_type=37;	/* PYRIDINE NITROGEN. */
                  *set_aromatic_flag=TRUE;
                  *add_lone_pairs=TRUE;
                  }
               }
            else if (geometry_type==TYPE_MM3_INPUT &&
               (connected_to("6",index,-1) || connected_to("11",index,-1) || connected_to("19",index,-1)))
               {
               if (connected_to("8",index,-1))
                  mm2_type=109;	/* AZOXY NITROGEN. */
               else
                  mm2_type=107;	/* AZO NITROGEN. */
               }
            else
               {
               if (geometry_type==TYPE_MM3_INPUT && connected_to("8",index,-1))
                  mm2_type=108;	/* OXIME NITROGEN. */
               else
                  mm2_type=72;	/* IMINE NITROGEN. */
               *add_lone_pairs=TRUE;
               }
            break;

         case 7:		/* SYBYL TYPE N.1 (SP NITRILE NITROGEN). */
            mm2_type=10;	/* SP NITRILE NITROGEN. */
            break;

         case 8:		/* SYBYL TYPE O.3 (SP3 OXYGEN). */
            if (in_three_member_ring(index))
               mm2_type=49;	/* EPOXY. */
            else if (in_non_c3_ring(5,index))
               {
               mm2_type=41;	/* FURAN. */
               *add_lone_pairs=TRUE;
               *set_aromatic_flag=TRUE;
               }
            else if (connected_to("2 9",index,-1) || connected_to("2 18",index,-1) || connected_to("2 6",index,-1))
               {
               if (intco[index].bond_cnt==1)
                  mm2_type=47;	/* CARBOXYLATE. */
               else
                  {
                  mm2_type=6;	/* SP3 OXYGEN. */
                  *add_lone_pairs=TRUE;
                  }
               }
            else if (connected_to("2",index,-1))
               {
               mm2_type=41;	/* ENOL. */
               *add_lone_pairs=TRUE;
               }
            else
               {
               mm2_type=6;	/* SP3 OXYGEN. */
               *add_lone_pairs=TRUE;
               }
            break;

         case 9:		/* SYBYL TYPE O.2 (SP2 OXYGEN). */
            if (in_non_c3_ring(5,index))
               {
               mm2_type=41;	/* FURAN. */
               *add_lone_pairs=TRUE;
               *set_aromatic_flag=TRUE;
               }
            else if (intco[index].bond_cnt==1)
               {
               if (connected_to("5",index,-1) || connected_to("6",index,-1) || connected_to("7",index,-1) || connected_to("11",index,-1) || connected_to("19",index,-1))
                  mm2_type=69;	/* AMINE OXIDE OXYGEN. */
               else
                  mm2_type=7;	/* SP2 OXYGEN. */
               }
            else
               {
               mm2_type=6;	/* SP3 OXYGEN. */
               *add_lone_pairs=TRUE;
               }
            break;

         case 10:		/* SYBYL TYPE S.3 (SP3 SULFUR). */
            if (intco[index].bond_cnt==3)
               mm2_type=16;	/* SULFONIUM. */
            else if (in_non_c3_ring(5,index))
               {
               mm2_type=42;	/* THIOPHENE. */
               *set_aromatic_flag=TRUE;
               }
            else if (geometry_type==TYPE_MM3_INPUT) 
               {
               if (connected_to("10",index,-1)==2)
                  mm2_type=105;	/* POLYSULFIDE. */
               else if (connected_to("10",index,-1))
                  mm2_type=104;	/* DISULFIDE. */
               else
                  mm2_type=15;	/* SULFIDE. */
               }
            else
               mm2_type=15;	/* SULFIDE. */
            break;

         case 11:		/* SYBYL TYPE N.ar (AROMATIC NITROGEN). */
            if (in_non_c3_ring(5,index) || in_non_c3_ring(6,index))
               {
               if (intco[index].bond_cnt==3)
                  {
                  mm2_type=40;	/* PYROLE NITROGEN. */
                  *set_aromatic_flag=TRUE;
                  }
               else
                  {
                  mm2_type=37;	/* PYRIDINE NITROGEN. */
                  *set_aromatic_flag=TRUE;
                  *add_lone_pairs=TRUE;
                  }
               }
            else
               {
               mm2_type=37;	/* AROMATIC NITROGEN. */
               *add_lone_pairs=TRUE;
               *set_aromatic_flag=TRUE;
               }
            break;

         case 12:		/* SYBYL TYPE P.3 (SP3 PHOSPHORUS). */
            if (geometry_type==TYPE_MM3_INPUT && intco[index].bond_cnt>3)
               mm2_type=60;	/* MM3 ONLY: P(V). */
            else
               mm2_type=25;	/* PHOSPHINE. */
            break;

         case 13:		/* SYBYL TYPE H (HYDROGEN). */
            if (connected_to("5",index,-1) || connected_to("6",index,-1) || connected_to("19",index,-1))
               mm2_type=23;	/* AMINE. */
            else if (connected_to("28",index,-1))
               mm2_type=28;	/* AMIDE. */
            else if (connected_to("31",index,-1))
               mm2_type=48;	/* AMMONIUM. */
            else if (connected_to("8 2 9",index,-1))
               mm2_type=24;	/* ACID. */
            else if (connected_to("8 2",index,-1))
               mm2_type=73;	/* ENOL. */
            else if (connected_to("8",index,-1))
               mm2_type=21;	/* ALCOHOL. */
            else if (geometry_type==TYPE_MM3_INPUT &&
               (connected_to("10",index,-1) || connected_to("18",index,-1) ||
               connected_to("29",index,-1) || connected_to("30",index,-1)))
               mm2_type=44;	/* MM3 ONLY: THIOL. */
            else
               mm2_type=5;	/* PLAIN HYDROGEN. */
            break;

         case 14:		/* SYBYL TYPE Br (BROMINE). */
            mm2_type=13;	/* BROMINE. */
            break;

         case 15:		/* SYBYL TYPE Cl (CHLORINE). */
            mm2_type=12;	/* CHLORINE. */
            break;

         case 16:		/* SYBYL TYPE F (FLUORINE). */
            mm2_type=11;	/* FLUORINE. */
            break;

         case 17:		/* SYBYL TYPE I (IODINE). */
            mm2_type=14;	/* IODINE. */
            break;

         case 18:		/* SYBYL TYPE S.2 (SP2 SULFUR). */
            if (in_non_c3_ring(5,index))
               {
               mm2_type=42;	/* THIOPHENE. */
               *set_aromatic_flag=TRUE;
               }
            else if (connected_to("2",index,-1) && intco[index].bond_cnt==1)
               mm2_type=17;	/* THIOCARBONYL SULFUR. */
            else
               mm2_type=15;	/* SP3 SULFUR. */
            break;

         case 19:		/* SYBYL TYPE N.pl3 (PLANAR TRIGONAL NITROGEN). */
            if (in_non_c3_ring(5,index) || in_non_c3_ring(6,index))
               {
               if (intco[index].bond_cnt==3)
                  {
                  mm2_type=40;	/* PYROLE NITROGEN. */
                  *set_aromatic_flag=TRUE;
                  }
               else
                  {
                  mm2_type=37;	/* PYRIDINE NITROGEN. */
                  *set_aromatic_flag=TRUE;
                  *add_lone_pairs=TRUE;
                  }
               }
            else if (connected_to("9",index,-1)==2)
               mm2_type=46;	/* NITRO. */
            else if (geometry_type==TYPE_MM3_INPUT &&
               (connected_to("6",index,-1) || connected_to("11",index,-1) || connected_to("19",index,-1)))
               {
               if (connected_to("8",index,-1))
                  mm2_type=109;	/* AZOXY NITROGEN. */
               else
                  mm2_type=107;	/* AZO NITROGEN. */
               }
            else
               {
               mm2_type=8;	/* SP3 NITROGEN. */
               *add_lone_pairs=TRUE;
               }
            break;

         case 20:		/* SYBYL TYPE LP (LONE PAIR). */
            /* ALL LONE PAIRS WERE INITIALLY DELETED AND REPLACED AS NEEDED. */
            mm2_type=99;	/* THIS CASE SHOULD NEVER BE EXECUTED. */
            break;

         case 21:		/* SYBYL TYPE Na (SODIUM). */
         case 22:		/* SYBYL TYPE K (POTASSIUM). */
         case 23:		/* SYBYL TYPE Ca (CALCIUM). */
         case 24:		/* SYBYL TYPE Li (LITHIUM). */
         case 25:		/* SYBYL TYPE Al (ALUMINUM). */
            /* NO CORRESPONDING MM2 TYPE. */
            printf("Warning: Atom #%d (SYBYL type %d) has no corresponding MM2 atom type.\n",index+1,intco[index].source_type);
            printf("         MM2 type 99 has been used; manual editing of file is required.\n");
            mm2_type=99;
            break;

         case 26:		/* SYBYL TYPE Du (DUMMY). */
            /* ALL DUMMIES WERE PREVIOUSLY DELETED. */
            mm2_type=99;	/* THIS CASE SHOULD NEVER BE EXECUTED. */
            break;

         case 27:		/* SYBYL TYPE Si (SILICON). */
            mm2_type=19;	/* SILANE. */
            break;

         case 28:		/* SYBYL TYPE N.am (AMIDE NITROGEN). */
            mm2_type=9;		/* AMIDE. */
            break;

         case 29:		/* SYBYL TYPE S.O (SULFOXIDE). */
            mm2_type=17;	/* SULFOXIDE. */
            break;

         case 30:		/* SYBYL TYPE S.O2 (SULFONE). */
            mm2_type=18;	/* SULFONE. */
            break;

         case 31:		/* SYBYL TYPE N.4 (AMMONIUM). */
            mm2_type=39;	/* AMMONIUM. */
            break;

         case 32:		/* SYBYL TYPE O.co2 (CARBOXYLATE). */
            mm2_type=47;	/* CARBOXYLATE. */
            break;

         case 33:		/* SYBYL TYPE C.cat (CARBOCATION). */
            mm2_type=30;	/* CARBOCATION. */
            break;

         case 906:		/* SYBYL TYPE Co.oh (COBALT). */
            mm2_type=66;	/* COBALT (III). */
            break;

         case 910:		/* SYBYL TYPE Fe (IRON). */
            mm2_type=62;	/* IRON (III). */
            break;

         case 911:		/* SYBYL TYPE Ni (NICKEL). */
            mm2_type=63;	/* NICKEL (II). */
            break;

         case 915:		/* SYBYL TYPE Ge (GERMANIUM). */
            mm2_type=31;	/* GERMANIUM. */
            break;

         case 917:		/* SYBYL TYPE Se (SELENIUM). */
            mm2_type=34;	/* SELENIUM. */
            break;

         case 918:		/* SYBYL TYPE Kr (KRYPTON). */
            mm2_type=54;	/* KRYPTON. */
            break;

         case 931:		/* SYBYL TYPE Sn (TIN). */
            mm2_type=32;	/* TIN. */
            break;

         case 933:		/* SYBYL TYPE Te (TELLURIUM). */
            mm2_type=35;	/* TELLURIUM. */
            break;

         case 934:		/* SYBYL TYPE Xe (XENON). */
            mm2_type=55;	/* XENON. */
            break;

         case 948:		/* SYBYL TYPE Pb (LEAD). */
            mm2_type=33;	/* LEAD. */
            break;

         case 984:		/* SYBYL TYPE He (HELIUM). */
            mm2_type=51;	/* HELIUM. */
            break;

         case 987:		/* SYBYL TYPE Ne (NEON). */
            mm2_type=52;	/* NEON. */
            break;

         case 988:		/* SYBYL TYPE Mg (MAGNESIUM). */
            mm2_type=59;	/* MAGNESIUM. */
            break;

         case 990:		/* SYBYL TYPE Ar (ARGON). */
            mm2_type=53;	/* ARGON. */
            break;

         default:		/* UNKNOWN SYBYL ATOM TYPE. */
            printf("Warning: Atom #%d (SYBYL type %d) is an unknown SYBYL atom type.\n",index+1,intco[index].source_type);
            printf("         MM2/MM3 type 99 has been used; manual editing of file is required.\n");
            mm2_type=99;
            break;
         }
         return(mm2_type);
      }
   else
      {
      /* DO A CRUDE CONVERSION FROM A NON SYBYL SOURCE TYPE TO MM2 ATOM TYPE. */
      printf("Error: Non SYBYL source type to MM2/MM3 conversion not yet implemented.\n");
      return(-1);
      }
   }

int in_three_member_ring(index)
/*============================================================================*/
/* PURPOSE: DETERMINE WHETHER OR NOT THE SPECIFIED ATOM IS CONTAINED IN A
/*	THREE MEMBER RING.
*/
   int index;	/* ATOM INDEX. */
   {
   int nring;	/* WHICH RING. */
   int natom;	/* WHICH ATOM. */

   /* EXAMINE EACH THREE MEMBER RING FOR INCLUSION OF INDEX ATOM. */
   for (nring=0; nring<nrings; nring++)
      {
      if (rings[nring].natoms==3)
         {
         /* CHECK EACH ATOM IN THIS THREE MEMBER RING. */
         for (natom=0; natom<rings[nring].natoms; natom++)
            {
            if (rings[nring].atoms[natom]==index) return(TRUE);
            }
         }
      }

   /* FELL THROUGH, SO NOT IN A THREE MEMBER RING. */
   return(FALSE);
   }

int in_four_member_ring(index)
/*============================================================================*/
/* PURPOSE: DETERMINE WHETHER OR NOT THE SPECIFIED ATOM IS CONTAINED IN A
/*	FOUR MEMBER RING.
*/
   int index;	/* ATOM INDEX. */
   {
   int nring;	/* WHICH RING. */
   int natom;	/* WHICH ATOM. */

   /* EXAMINE EACH FOUR MEMBER RING FOR INCLUSION OF INDEX ATOM. */
   for (nring=0; nring<nrings; nring++)
      {
      if (rings[nring].natoms==4)
         {
         /* CHECK EACH ATOM IN THIS FOUR MEMBER RING. */
         for (natom=0; natom<rings[nring].natoms; natom++)
            {
            if (rings[nring].atoms[natom]==index) return(TRUE);
            }
         }
      }

   /* FELL THROUGH, SO NOT IN A FOUR MEMBER RING. */
   return(FALSE);
   }

int in_non_c3_ring(ring_size,index)
/*============================================================================*/
/* PURPOSE: DETERMINE IF THE SPECIFIED ATOM IS CONTAINED IN A RING
/*	OF THE REQUIRED SIZE WHICH DOES NOT CONTAIN C.3 ATOMS.
*/
   int ring_size;	/* DESIRED NUMBER OF ATOMS IN RING. */
   int index;		/* ATOM INDEX NUMBER. */
   {
   int nring;		/* WHICH RING. */
   int natom;		/* WHICH ATOM. */
   int ring_atom;	/* INDEX NUMBER OF ATOM IN RING. */
   int atom_found;	/* T/F: ATOM INDEX FOUND IN RING. */
   int c3_found;	/* T/F: SYBYL C.3 ATOM TYPE FOUND IN RING. */

   /* EXAMINE EACH "RING_SIZE" RING FOR INCLUSION OF INDEX ATOM AND EXCLUSION */
   /* OF ANY SYBYL TYPE C.3 (TYPE 1) ATOMS. */
   for (nring=0; nring<nrings; nring++)
      {
      if (rings[nring].natoms==ring_size)
         {
         /* LOOK FOR THE "INDEX" AND C.3 ATOMS IN THIS CORRECTLY SIZED RING. */
         atom_found=c3_found=FALSE;
         for (natom=0; natom<rings[nring].natoms; natom++)
            {
            ring_atom=rings[nring].atoms[natom];	/* EXAMINED ATOM. */
            if (ring_atom==index) atom_found=TRUE;
            if (intco[ring_atom].source_type==1) c3_found=TRUE;
            }
         if (atom_found && !c3_found) return(TRUE);
         }
      }

   /* FELL THROUGH, SO NOT IN A NON C.3 RING OF THE SPECIFIED SIZE. */
   return(FALSE);
   }

int in_non_carbonyl_non_c3_ring(ring_size,index)
/*============================================================================*/
/* PURPOSE: DETERMINE IF THE SPECIFIED ATOM IS CONTAINED IN A RING
/*	OF THE REQUIRED SIZE WHICH DOES NOT CONTAIN C.3 ATOMS AND IN WHICH
/*	ALL C.2 ATOMS ARE *NOT* CONNECTED TO ANY EXTERNAL CARBONYL TYPE ATOMS
/*	(O.2, N.2, OR S.2).
*/
   int ring_size;	/* DESIRED NUMBER OF ATOMS IN RING. */
   int index;		/* ATOM INDEX NUMBER. */
   {
   int nring;		/* WHICH RING. */
   int natom;		/* WHICH ATOM. */
   int ring_atom;	/* INDEX NUMBER OF ATOM IN RING. */
   int connected_atom;	/* INDEX NUMBER OF CONNECTED ATOM. */
   int connected_atom_type;	/* TYPE OF CONNECTED ATOM. */
   int atom_found;	/* T/F: ATOM INDEX FOUND IN RING. */
   int c3_found;	/* T/F: SYBYL C.3 ATOM TYPE FOUND IN RING. */
   int carbonyl_found;	/* T/F: SYBYL C.2 CONNECTED TO EXTERNAL CARBONYL TYPE. */
   int i;		/* LOOP INDEX. */
   int j;		/* LOOP INDEX. */

   /* EXAMINE EACH "RING_SIZE" RING FOR INCLUSION OF INDEX ATOM AND EXCLUSION */
   /* OF ANY SYBYL TYPE C.3 (TYPE 1) ATOMS. */
   for (nring=0; nring<nrings; nring++)
      {
      if (rings[nring].natoms==ring_size)
         {
         /* LOOK FOR THE "INDEX" AND C.3 ATOMS AND THE EXCLUSION OF C.2 ATOMS */
         /* CONNECTED TO EXTERNAL CARBONYL TYPES IN THIS CORRECTLY SIZED RING. */
         atom_found=c3_found=carbonyl_found=FALSE;
         for (natom=0; natom<rings[nring].natoms; natom++)
            {
            ring_atom=rings[nring].atoms[natom];	/* EXAMINED ATOM. */

            if (ring_atom==index) atom_found=TRUE;
            if (intco[ring_atom].source_type==1) c3_found=TRUE;
            if (intco[ring_atom].source_type==2)
               {
               /* GOT A C.2, CHECK FOR CONNECTION TO AN EXTERNAL CARBONYL TYPE. */
               for (i=0; i<intco[ring_atom].bond_cnt; i++)
                  {
                  connected_atom=intco[ring_atom].bonds[i];	/* EXAMINED ATOM. */
                  connected_atom_type=intco[connected_atom].source_type;

                  if (connected_atom_type==9 || connected_atom_type==18 || connected_atom_type==6)
                     {
                     /* GOT A CARBONYL TYPE, DETERMINE IF IT IS EXTERNAL. */
                     carbonyl_found=TRUE;
                     for (j=0; j<rings[nring].natoms; j++)
                        {
                        if (rings[nring].atoms[j]==connected_atom) carbonyl_found=FALSE;	/* INTERNAL TO RING. */
                        }
                     }
                  }
               }
            }
         /* DONE CHECKING THIS RING - DOES IT MEET THE REQUIREMENTS? */
         if (atom_found && !c3_found && !carbonyl_found) return(TRUE);
         }
      }

   /* FELL THROUGH, SO NOT IN A NON C.3 RING OF THE SPECIFIED SIZE. */
   return(FALSE);
   }

int in_hetero_non_c3_ring(ring_size,index)
/*============================================================================*/
/* PURPOSE: DETERMINE IF THE SPECIFIED ATOM IS CONTAINED IN A RING OF THE
/*	REQUIRED SIZE WHICH DOES NOT CONTAIN C.3 ATOMS AND WHICH *DOES*
/*	CONTAIN A HETEROATOM (N.pl3, N.ar, N.2, N.3, O.2, O.3, S.2, OR S.3).
*/
   int ring_size;	/* DESIRED NUMBER OF ATOMS IN RING. */
   int index;		/* ATOM INDEX NUMBER. */
   {
   int nring;		/* WHICH RING. */
   int natom;		/* WHICH ATOM. */
   int ring_atom;	/* INDEX NUMBER OF ATOM IN RING. */
   int ring_atom_type;	/* TYPE OF ATOM IN RING. */
   int atom_found;	/* T/F: ATOM INDEX FOUND IN RING. */
   int c3_found;	/* T/F: SYBYL C.3 ATOM TYPE FOUND IN RING. */
   int hetero_found;	/* T/F: HETEROATOM FOUND IN RING. */

   /* EXAMINE EACH "RING_SIZE" RING FOR INCLUSION OF INDEX ATOM AND EXCLUSION */
   /* OF ANY SYBYL TYPE C.3 (TYPE 1) ATOMS. */
   for (nring=0; nring<nrings; nring++)
      {
      if (rings[nring].natoms==ring_size)
         {
         /* LOOK FOR THE "INDEX", C.3, AND HETERO ATOMS IN THIS CORRECTLY SIZED RING. */
         atom_found= c3_found= hetero_found= FALSE;
         for (natom=0; natom<rings[nring].natoms; natom++)
            {
            ring_atom=rings[nring].atoms[natom];	/* EXAMINED ATOM. */
            ring_atom_type=intco[ring_atom].source_type;

            if (ring_atom==index) atom_found=TRUE;
            if (ring_atom_type==1) c3_found=TRUE;
            if (ring_atom_type==19 || ring_atom_type==11 || ring_atom_type==6 ||
               ring_atom_type==5 || ring_atom_type==9 || ring_atom_type==8 ||
               ring_atom_type==18 || ring_atom_type==10) hetero_found=TRUE;
            }

         /* DONE CHECKING THIS RING - DOES IT MEET THE REQUIREMENTS? */
         if (atom_found && !c3_found && hetero_found) return(TRUE);
         }
      }

   /* FELL THROUGH, SO NOT IN A NON C.3 RING OF THE SPECIFIED SIZE. */
   return(FALSE);
   }

int connected_to(chain,current_atom,last_atom)
/*============================================================================*/
/* PURPOSE: DETERMINE IF THE CURRENT_ATOM IS CONNECTED SEQUENTIALLY TO THE
/*	SPECIFIED CHAIN OF ATOM TYPES.
*/
   char chain[];	/* CHAIN OF ATOM TYPES EXPECTED FROM HERE. */
   int current_atom;	/* INDEX OF ATOM CURRENTLY BEING EXAMINED. */
   int last_atom;	/* INDEX OF ATOM LAST VISITED (PARENT OF CURRENT). */
   {
   int target_type;	/* FIRST TYPE FROM CHAIN TO BE LOOKED FOR. */
   int nconnections;	/* NUMBER OF CONNECTIONS FOUND FROM HERE DOWN. */
   int nbond;		/* WHICH BOND FROM CURRENT ATOM. */
   int new_atom;	/* NEWLY SELECTED ATOM BEING EXAMINED. */

   nconnections=0;
   target_type=(int)strtol(chain,&chain,10);

   /* CHECK EACH BOND FROM THIS ATOM TO A NEW ATOM. */
   for (nbond=0; nbond<intco[current_atom].bond_cnt; nbond++)
      {
      new_atom=intco[current_atom].bonds[nbond];

      if (new_atom!=last_atom && intco[new_atom].source_type==target_type)
         {
         /* MATCHED THIS ATOM, DESCEND ANOTHER LEVEL IF POSSIBLE. */
         if (strlen(chain)>0) nconnections+=connected_to(chain,new_atom,current_atom);
         else nconnections++;
         }
      }

   /* RETURN NUMBER OF DIFFERENT SUBPATHS FROM THE CURRENT ATOM THAT MEET */
   /* THE REST OF THE CHAIN ORDER. */
   return(nconnections);
   }

int make_connected_atom_lists(connected_atom_lists)
/*============================================================================*/
/* PURPOSE: CREATE THE "CONNECTED" ATOM LISTS FOR MM2 FROM THE CURRENT MOLECULE.
/*	A "CONNECTED" ATOM IS ANY ATOM WITH AT LEAST TWO BONDS TO IT.  ALL BONDS
/*	IN THE MOLECULE MUST SHOW UP IN THE CONNECTED LISTS (EXCEPT THOSE TO
/*	"ATTACHED" ATOMS).
*/
   int connected_atom_lists[MAX_CONNECTED_ATOM_LISTS][MAX_ATOMS_PER_LIST];
   {
   int natom;			/* WHICH ATOM. */
   int nbond;			/* WHICH BOND. */
   int nlist;			/* WHICH LIST. */
   int first_unused_atom;	/* FIRST ATOM WITH UNUSED BONDS. */
   int bonds_used[MAX_ATOMS][MAX_BONDS_PER_ATOM];	/* T/F; BOND USED IN LIST. */

   void mark_all_attached_atom_bonds();	/* MARK ATTACHED ATOM BONDS AS USED. */
   void make_connected_atom_list();	/* FORM SINGLE CHAIN FROM ROOT ATOM. */

   for (nlist=0; nlist<MAX_CONNECTED_ATOM_LISTS; nlist++)
      {
      for (natom=0; natom<MAX_ATOMS_PER_LIST; natom++)
         {
         connected_atom_lists[nlist][natom]=0;	/* EMPTY LISTS TO START. */
         }
      }
   for (natom=0; natom<atom_cnt; natom++)
      {
      for (nbond=0; nbond<MAX_BONDS_PER_ATOM; nbond++)
         {
         bonds_used[natom][nbond]=FALSE;	/* NO BONDS USED TO START. */
         }
      }

   /* ELIMINATE ATTACHED ATOMS BEFORE LOOKING FOR CONNECTED ATOMS. */
   mark_all_attached_atom_bonds(bonds_used);

   /* KEEP MAKING CONNECTED ATOM LISTS WHILE THERE ARE UNUSED BONDS. */
   nlist= -1;
   while (!all_bonds_used(&first_unused_atom,bonds_used))
      {
      /* START THE LIST WITH FIRST_UNUSED_ATOM AND FOLLOW THE CONNECTIONS. */
      nlist++;
      natom=0;
      connected_atom_lists[nlist][natom]=first_unused_atom+1;	/* INDEX FROM ONE FOR MM2. */
      make_connected_atom_list(first_unused_atom,nlist,natom,connected_atom_lists,bonds_used);
      }

   /* NO MORE UNUSED BONDS, VERIFY THAT WE HAVE CREATED AT LEAST ONE */
   /* CONNECTED ATOM LIST.  THIS IS TO REMEDY A SMALL HOLE IN THE ABOVE */
   /* ALGORITHM: IF A MOLECULE (EG METHANE) HAS ONLY ONE CONNECTED ATOM, */
   /* THE ACT OF MARKING ALL ATTACHED ATOM BONDS AS USED WILL LEAVE THAT */
   /* ATOM WITH *ALL* BONDS MARKED AS USED, SO IT DROPS THROUGH THE ABOVE */
   /* WHILE LOOP.  IF THIS HAPPENED, WE FORCE THE MULTIPLY CONNECTED ATOM */
   /* INTO THE FIRST CONNECTED ATOM LIST (THERE CAN ONLY BE ONE SUCH ATOM). */
   if (nlist<0)
      {
      /* FIND THE MULTIPLY CONNECTED ATOM AND ADD IT IN. */
      for (natom=0; natom<atom_cnt; natom++)
         {
         if (intco[natom].bond_cnt>1)
            {
            nlist++;
            connected_atom_lists[nlist][0]=natom+1;	/* INDEX FROM ONE FOR MM2. */
            break;	/* THERE CAN ONLY BE ONE SUCH ATOM. */
            }
         }
      }

   return(nlist+1);	/* RETURN TOTAL NUMBER OF CONNECTION LISTS USED. */
   }

void mark_all_attached_atom_bonds(bonds_used)
/*============================================================================*/
/* PURPOSE: MARK ALL BONDS TO OR FROM AN ATTACHED ATOM (ANY ATOM WITH ONLY ONE
/*	BOND IS AN ATTACHED ATOM) AS USED SO THEY WILL NOT BE CONSIDERED IN
/*	THE SEARCH FOR CONNECTED ATOMS.
*/
   int bonds_used[MAX_ATOMS][MAX_BONDS_PER_ATOM];	/* T/F; BOND USED IN LIST. */
   {
   int natom;			/* WHICH ATOM. */

   void mark_bond_used();	/* MARK BOND AND RECIPROCAL BOND AS USED. */

   for (natom=0; natom<atom_cnt; natom++)
      {
      if (intco[natom].bond_cnt==1) mark_bond_used(natom,intco[natom].bonds[0],bonds_used);
      }
   }

void mark_bond_used(atom1,atom2,bonds_used)
/*============================================================================*/
/* PURPOSE: MARK THE BOND BETWEEN THE TWO SPECIFIED ATOMS AS BEING "USED".
/*	NOTE THAT EACH BOND IS REPRESENTED TWICE IN THE LIST (BEING DIRECTED)
/*	AS TWO RECIPROCAL BONDS.  BOTH MUST BE MARKED.
*/
   int atom1;		/* FIRST ATOM OF BOND. */
   int atom2;		/* SECOND ATOM OF BOND. */
   int bonds_used[MAX_ATOMS][MAX_BONDS_PER_ATOM];	/* T/F; BOND USED IN LIST. */
   {
   int nbond;		/* WHICH BOND. */

   /* MARK THE DIRECTED BOND FROM ATOM1 TO ATOM2 AS USED. */
   for (nbond=0; nbond<intco[atom1].bond_cnt; nbond++)
      {
      if (intco[atom1].bonds[nbond]==atom2) bonds_used[atom1][nbond]=TRUE;
      }

   /* MARK THE DIRECTED BOND FROM ATOM2 TO ATOM1 AS USED. */
   for (nbond=0; nbond<intco[atom2].bond_cnt; nbond++)
      {
      if (intco[atom2].bonds[nbond]==atom1) bonds_used[atom2][nbond]=TRUE;
      }

   return;
   }

int all_bonds_used(first_unused_atom,bonds_used)
/*============================================================================*/
/* PURPOSE: CHECK TO SEE IF ALL BONDS TO ALL ATOMS ARE "USED".  IF ANY UNUSED
/*	BOND IS FOUND, RETURN THE NUMBER OF THE ATOM.
*/
   int *first_unused_atom;	/* FIRST ATOM FOUND WITH >= 1 UNUSED BOND. */
   int bonds_used[MAX_ATOMS][MAX_BONDS_PER_ATOM];	/* T/F; BOND USED IN LIST. */
   {
   int natom;			/* WHICH ATOM. */
   int nbond;			/* WHICH BOND. */

   /* SCAN EACH BOND OF EACH ATOM FOR THE FIRST UNUSED BOND. */
   for (natom=0; natom<atom_cnt; natom++)
      {
      for (nbond=0; nbond<intco[natom].bond_cnt; nbond++)
         {
         if (!bonds_used[natom][nbond])
            {
            *first_unused_atom=natom;
            return(FALSE);	/* FOUND AN UNUSED BOND. */
            }
         }
      }

   return(TRUE);	/* ALL BONDS FOR ALL ATOMS WERE USED. */
   }

void make_connected_atom_list(last_atom_added,nlist,natom,connected_atom_lists,bonds_used)
/*============================================================================*/
/* PURPOSE: ADD TO A SINGLE CONNECTED ATOM LIST BY FOLLOWING THE BONDS AWAY
/*	FROM THE LAST_ATOM_ADDED.
*/
   int last_atom_added;		/* LAST ATOM ADDED TO THIS LIST (PARENT ATOM). */
   int nlist;			/* WHICH LIST WE ARE ADDING TO. */
   int natom;			/* WHICH ATOM SLOT IN CONNECTED LIST (0..MAX_ATOMS_PER_LIST). */
   int connected_atom_lists[MAX_CONNECTED_ATOM_LISTS][MAX_ATOMS_PER_LIST];
   int bonds_used[MAX_ATOMS][MAX_BONDS_PER_ATOM];	/* T/F; BOND USED IN LIST. */
   {
   int nbond;			/* WHICH BOND. */
   int new_atom;		/* NEXT ATOM IN LINK ADDED TO LIST. */

   void mark_bond_used();	/* MARK BOND AND RECIPROCAL BOND AS USED. */

   if (natom+1>=MAX_ATOMS_PER_LIST) return;	/* LIST IS FULL, STOP HERE. */

   for (nbond=0; nbond<intco[last_atom_added].bond_cnt; nbond++)
      {
      /* FOLLOW THE FIRST UNUSED BOND FROM THE LAST_ATOM_ADDED. */
      if (!bonds_used[last_atom_added][nbond])
         {
         /* GOT UNUSED BOND, ADD TO LIST, MARK AS USED, AND FOLLOW LINKS. */
         new_atom=intco[last_atom_added].bonds[nbond];
         natom++;
         connected_atom_lists[nlist][natom]=new_atom+1;	/* INDEX FROM ONE FOR MM2. */
         mark_bond_used(last_atom_added,new_atom,bonds_used);
         make_connected_atom_list(new_atom,nlist,natom,connected_atom_lists,bonds_used);
         return;	/* DONE WITH THIS LIST (CHAIN EXHAUSTED OR LIST FILLED IN SUBSEQUENT CALL). */
         }
      }

   return;	/* USED UP ALL BONDS LEADING AWAY FROM LAST_ATOM_ADDED. */
   }

int make_attached_atom_lists(attached_atom_lists)
/*============================================================================*/
/* PURPOSE: CREATE THE ATTACHED ATOM LISTS AND RETURN THE TOTAL NUMBER OF
/*	ATTACHED ATOMS FOUND.  AN ATTACHED ATOM IS ONE WITH ONLY ONE BOND.
/*	THE LIST IS REALLY PAIRS OF ATOMS TO SHOW CONNECTIONS (ROOT ATOM FIRST).
*/
   int attached_atom_lists[MAX_ATTACHED_ATOM_LISTS][MAX_ATOMS_PER_LIST];
   {
   int i;
   int natom;
   int nlist;
   int natoms_in_list;
   int nattached_atoms;	/* TOTAL NUMBER OF ATTACHED ATOMS. */

   /* ZERO THE LISTS TO START. */
   nattached_atoms=0;
   for (nlist=0; nlist<MAX_ATTACHED_ATOM_LISTS; nlist++)
      {
      for (i=0; i<MAX_ATOMS_PER_LIST; i++)
         {
         attached_atom_lists[nlist][i]=0;
         }
      }

   /* CHECK EACH ATOM TO SEE IF IT IS "ATTACHED" (ONLY ONE BOND). */
   nlist=0;
   natoms_in_list=0;
   for (natom=0; natom<atom_cnt; natom++)
      {
      if (intco[natom].bond_cnt==1)
         {
         /* THIS IS AN ATTACHED ATOM, ADD IT TO THE LIST. */
         nattached_atoms++;
         natoms_in_list++;
         if (natoms_in_list*2 > MAX_ATOMS_PER_LIST)
            {
            nlist++;	/* FILLED UP ONE LIST, ROLL OVER TO THE NEXT ONE. */
            natoms_in_list=1;
            if (nlist+1 > MAX_ATTACHED_ATOM_LISTS)
               {
               printf("Error: Maximum number of attached atom lists exceeded, file is incorrect.\n");
               return(nlist);	/* TRUNCATE AT THE MAXIMUM. */
               }
            }
         /* ADD ROOT AND ATTACHED ATOM (ADJUST TO INDEX FROM ONE FOR MM2). */
         attached_atom_lists[nlist][(natoms_in_list-1)*2]=intco[natom].bonds[0]+1;
         attached_atom_lists[nlist][(natoms_in_list-1)*2+1]=natom+1;
         }
      }

   return(nattached_atoms);	/* RETURN TOTAL NUMBER OF ATTACHED ATOMS. */
   }