/* getgeo.f -- translated by f2c (version 19950314).
   You must link the resulting object file with the libraries:
	-lF77 -lI77 -lm   (in that order)
*/

#include "f2c.h"

/* Common Block Declarations */

struct {
    char argz[512];
} argz_;

#define argz_1 argz_

struct {
    doublereal dummy, react[198]	/* was [3][66] */, dumm1, dumm2;
} path_;

#define path_1 path_

struct {
    doublereal atmass[86];
} atmass_;

#define atmass_1 atmass_

struct {
    char keywrd[80];
} keywrd_;

#define keywrd_1 keywrd_

/* Table of constant values */

static integer c__1 = 1;
static integer c__86 = 86;

/* Subroutine */ int getgeo_(integer *iread, integer *labels, doublereal *geo,
	 integer *lopt, integer *na, integer *nb, integer *nc, doublereal *
	ams, integer *natoms, logical *int__)
{
    /* Initialized data */

    static char elemnt[2*107] = "H " "HE" "LI" "BE" "B " "C " "N " "O " "F " 
	    "NE" "NA" "MG" "AL" "SI" "P " "S " "CL" "AR" "K " "CA" "SC" "TI" 
	    "V " "CR" "MN" "FE" "CO" "NI" "CU" "ZN" "GA" "GE" "AS" "SE" "BR" 
	    "KR" "RB" "SR" "Y " "ZR" "NB" "MO" "TC" "RU" "RH" "PD" "AG" "CD" 
	    "IN" "SN" "SB" "TE" "I " "XE" "CS" "BA" "LA" "CE" "PR" "ND" "PM" 
	    "SM" "EU" "GD" "TB" "DY" "HO" "ER" "TM" "YB" "LU" "HF" "TA" "W " 
	    "RE" "OS" "IR" "PT" "AU" "HG" "TL" "PB" "BI" "PO" "AT" "RN" "FR" 
	    "RA" "AC" "TH" "PA" "U " "NP" "PU" "AM" "CM" "BK" "CF" "XX" "FM" 
	    "MD" "CB" "++" "+ " "--" "- " "TV";
    static char comma[1] = ",";
    static char space[1] = " ";
    static char nine[1] = "9";
    static char zero[1] = "0";

    /* Format strings */
    static char fmt_210[] = "(i4,2x,3(f10.5,2x,i2,2x),3(i2,1x))";

    /* System generated locals */
    integer i__1;
    doublereal d__1, d__2;

    /* Builtin functions */
    integer i_indx(char *, char *, ftnlen, ftnlen), s_rsfe(cilist *), do_fio(
	    integer *, char *, ftnlen), e_rsfe(void), s_cmp(char *, char *, 
	    ftnlen, ftnlen), s_wsfe(cilist *), e_wsfe(void);
    /* Subroutine */ int s_stop(char *, ftnlen), s_copy(char *, char *, 
	    ftnlen, ftnlen);
    double sqrt(doublereal), d_sign(doublereal *, doublereal *), asin(
	    doublereal);

    /* Local variables */
    static integer itab;
    static doublereal real__;
    static integer khar;
    static char line[80];
    static integer ndmy;
    static char turn[1];
    static doublereal temp1, temp2;
    static integer i, j, k;
    extern doublereal reada_(char *, integer *, ftnlen);
    static integer icapa, label, iline, ilowa;
    static doublereal value[4];
    static integer numat, ilowz;
    static doublereal ca, sa;
    static integer jj;
    static doublereal degree;
    static integer icomma;
    static logical ircdrc, leadsp;
    extern /* Subroutine */ int nuchar_(char *, doublereal *, integer *, 
	    ftnlen);
    static doublereal weight;
    static integer nvalue, istart[40];
    static char string[80];
    extern /* Subroutine */ int xyzint_(doublereal *, integer *, integer *, 
	    integer *, integer *, doublereal *, doublereal *);
    static char ele[2], tab[1];
    static doublereal xyz[258]	/* was [3][86] */;

    /* Fortran I/O blocks */
    static cilist io___12 = { 1, 0, 1, "(A)", 0 };
    static cilist io___14 = { 0, 6, 0, "(//10X,'****  MAX. NUMBER OF ATOMS A"
	    "LLOWED:',I4)", 0 };
    static cilist io___26 = { 0, 6, 0, "('  ILLEGAL ATOMIC NUMBER')", 0 };
    static cilist io___29 = { 0, 6, 0, "('  UNRECOGNIZED ELEMENT NAME: (',A,"
	    "')')", 0 };
    static cilist io___30 = { 0, 6, 0, "(' FOR ATOM',I4,'  ISOTOPIC MASS:'  "
	    "                  ,F15.5)", 0 };
    static cilist io___32 = { 0, 6, 0, "(A)", 0 };
    static cilist io___33 = { 0, 6, 0, "(//10X,' WARNING: INTERNAL COORDINAT"
	    "ES ARE ASSUMED -',/10X,' FOR THREE-ATOM SYSTEMS ',//)", 0 };
    static cilist io___34 = { 0, 6, 0, "(A)", 0 };
    static cilist io___35 = { 0, 5, 0, "(A)", 0 };
    static cilist io___38 = { 0, 6, 0, "(/10X,A)", 0 };
    static cilist io___46 = { 0, 6, 0, "(A)", 0 };
    static cilist io___47 = { 0, 6, 0, "(//10X,' AN UNOPTIMIZABLE GEOMETRIC "
	    "PARAMETER HAS ',/10X,' BEEN MARKED FOR OPTIMIZATION. THIS IS A N"
	    "ON-FATAL '   ,'ERROR')", 0 };
    static cilist io___48 = { 0, 6, 0, "( ' ERROR DURING READ AT ATOM NUMBER"
	    " ', I3 )", 0 };
    static cilist io___49 = { 0, 6, 0, "(' DATA CURRENTLY READ IN ARE ')", 0 }
	    ;
    static cilist io___51 = { 0, 6, 0, fmt_210, 0 };


/* COMDECK SIZES */
/************************************************************************
****/
/*  THIS FILE CONTAINS ALL THE ARRAY SIZES FOR USE IN MOPAC.              
**/
/*                                                                        
**/
/*    THERE ARE ONLY  PARAMETERS THAT THE PROGRAMMER NEED SET:            
**/
/*    MAXHEV = MAXIMUM NUMBER OF HEAVY ATOMS (HEAVY: NON-HYDROGEN ATOMS)  
**/
/*    MAXLIT = MAXIMUM NUMBER OF HYDROGEN ATOMS.                          
**/
/*    MAXTIM = DEFAULT TIME FOR A JOB. (SECONDS)                          
**/
/*    MAXDMP = DEFAULT TIME FOR AUTOMATIC RESTART FILE GENERATION (SECS)  
**/
/*                                                                        
**/
/*                                                                        
**/
/************************************************************************
****/
/*                                                                        
**/
/*  THE FOLLOWING CODE DOES NOT NEED TO BE ALTERED BY THE PROGRAMMER      
**/
/*                                                                        
**/
/************************************************************************
****/
/*                                                                        
**/
/*   ALL OTHER PARAMETERS ARE DERIVED FUNCTIONS OF THESE TWO PARAMETERS   
**/
/*                                                                        
**/
/*     NAME                   DEFINITION                                  
**/
/*    NUMATM         MAXIMUM NUMBER OF ATOMS ALLOWED.                     
**/
/*    MAXORB         MAXIMUM NUMBER OF ORBITALS ALLOWED.                  
**/
/*    MAXPAR         MAXIMUM NUMBER OF PARAMETERS FOR OPTIMISATION.       
**/
/*    N2ELEC         MAXIMUM NUMBER OF TWO ELECTRON INTEGRALS ALLOWED.    
**/
/*    MPACK          AREA OF LOWER HALF TRIANGLE OF DENSITY MATRIX.       
**/
/*    MORB2          SQUARE OF THE MAXIMUM NUMBER OF ORBITALS ALLOWED.    
**/
/*    MAXHES         AREA OF HESSIAN MATRIX                               
**/
/************************************************************************
****/
/************************************************************************
****/
/*  FOR SHORT VERSION USE LINE WITH NMECI=1, FOR LONG VERSION USE LINE    
**/
/*  WITH NMECI=10                                                         
**/
/************************************************************************
****/
/*     PARAMETER (NMECI=1,   NPULAY=1) */
/************************************************************************
****/
/* DECK MOPAC */
/* next line added for Unix implementation for command line arguments */

/* ***********************************************************************
 */

/*   GETGEO READS IN THE GEOMETRY. THE ELEMENT IS SPECIFIED BY IT'S */
/*          CHEMICAL SYMBOL, OR, OPTIONALLY, BY IT'S ATOMIC NUMBER. */

/*  ON INPUT   IREAD  = CHANNEL NUMBER FOR READ, NORMALLY 5 */
/*             AMS    = DEFAULT ATOMIC MASSES. */

/* ON OUTPUT LABELS = ATOMIC NUMBERS OF ALL ATOMS, INCLUDING DUMMIES. */
/*           GEO    = INTERNAL COORDINATES, IN ANGSTROMS, AND DEGREES. */
/*           LOPT   = INTEGER ARRAY, A '1' MEANS OPTIMIZE THIS PARAMETER, 
*/
/*                    '0' MEANS DO NOT OPTIMIZE, AND A '-1' LABELS THE */
/*                    REACTION COORDINATE. */
/*           NA     = INTEGER ARRAY OF ATOMS (SEE DATA INPUT) */
/*           NB     = INTEGER ARRAY OF ATOMS (SEE DATA INPUT) */
/*           NC     = INTEGER ARRAY OF ATOMS (SEE DATA INPUT) */
/*           ATMASS = ATOMIC MASSES OF ATOMS. */
/* ***********************************************************************
 */
    /* Parameter adjustments */
    --ams;
    --nc;
    --nb;
    --na;
    lopt -= 4;
    geo -= 4;
    --labels;

    /* Function Body */
    *(unsigned char *)tab = '\t';
    ircdrc = i_indx(keywrd_1.keywrd, "IRC", 80L, 3L) + i_indx(keywrd_1.keywrd,
	     "DRC", 80L, 3L) != 0;
    ilowa = 'a';
    ilowz = 'z';
    icapa = 'A';
    *natoms = 0;
    numat = 0;
L10:
    io___12.ciunit = *iread;
    i__1 = s_rsfe(&io___12);
    if (i__1 != 0) {
	goto L100001;
    }
    i__1 = do_fio(&c__1, line, 80L);
    if (i__1 != 0) {
	goto L100001;
    }
    i__1 = e_rsfe();
L100001:
    if (i__1 < 0) {
	goto L90;
    }
    if (i__1 > 0) {
	goto L180;
    }
    if (s_cmp(line, " ", 80L, 1L) == 0) {
	goto L90;
    }
    ++(*natoms);
    if (*natoms > 86) {
	s_wsfe(&io___14);
	do_fio(&c__1, (char *)&c__86, (ftnlen)sizeof(integer));
	e_wsfe();
	s_stop("", 0L);
    }
/*   CLEAN THE INPUT DATA */
/* ***********************************************************************
 */
    for (i = 1; i <= 80; ++i) {
	iline = *(unsigned char *)&line[i - 1];
	if (iline >= ilowa && iline <= ilowz) {
	    *(unsigned char *)&line[i - 1] = (char) (iline + icapa - ilowa);
	}
/* L20: */
    }
/* ***********************************************************************
 */
    icomma = *(unsigned char *)&comma[0];
    itab = *(unsigned char *)tab;
    for (i = 1; i <= 80; ++i) {
	khar = *(unsigned char *)&line[i - 1];
	if (khar == icomma || khar == itab) {
	    *(unsigned char *)&line[i - 1] = *(unsigned char *)&space[0];
	}
/* L30: */
    }

/*   INITIALIZE ISTART TO INTERPRET BLANKS AS ZERO'S */
    for (i = 1; i <= 10; ++i) {
/* L40: */
	istart[i - 1] = 80;
    }
/* FIND INITIAL DIGIT OF ALL NUMBERS, CHECK FOR LEADING SPACES FOLLOWED */
/*     BY A CHARACTER AND STORE IN ISTART */
    leadsp = TRUE_;
    nvalue = 0;
    for (i = 1; i <= 80; ++i) {
	if (leadsp && *(unsigned char *)&line[i - 1] != *(unsigned char *)&
		space[0]) {
	    ++nvalue;
	    istart[nvalue - 1] = i;
	}
	leadsp = *(unsigned char *)&line[i - 1] == *(unsigned char *)&space[0]
		;
/* L50: */
    }

/* ESTABLISH THE ELEMENT'S NAME AND ISOTOPE, CHECK FOR ERRORS OR E.O.DATA 
*/

    weight = 0.;
    i__1 = istart[0] - 1;
    s_copy(string, line + i__1, 80L, istart[1] - 1 - i__1);
    if (*(unsigned char *)string >= *(unsigned char *)&zero[0] && *(unsigned 
	    char *)string <= *(unsigned char *)&nine[0]) {
/*  ATOMIC NUMBER USED: NO ISOTOPE ALLOWED */
	label = (integer) reada_(string, &c__1, 80L);
	if (label == 0) {
	    goto L80;
	}
	if (label < 0 || label > 107) {
	    s_wsfe(&io___26);
	    e_wsfe();
	    goto L190;
	}
	goto L70;
    }
/*  ATOMIC SYMBOL USED */
    real__ = (d__1 = reada_(string, &c__1, 80L), abs(d__1));
    if (real__ < 1e-15) {
/*   NO ISOTOPE */
	s_copy(ele, string, 2L, 2L);
    } else {
	weight = real__;
	if (*(unsigned char *)&string[1] >= *(unsigned char *)&zero[0] && *(
		unsigned char *)&string[1] <= *(unsigned char *)&nine[0]) {
	    s_copy(ele, string, 2L, 1L);
	} else {
	    s_copy(ele, string, 2L, 2L);
	}
    }
/*   CHECK FOR ERROR IN ATOMIC SYMBOL */
    if (*(unsigned char *)ele == '-' && *(unsigned char *)&ele[1] != '-') {
	*(unsigned char *)&ele[1] = ' ';
    }
    for (i = 1; i <= 107; ++i) {
	if (s_cmp(ele, elemnt + (i - 1 << 1), 2L, 2L) == 0) {
	    label = i;
	    goto L70;
	}
/* L60: */
    }
    s_wsfe(&io___29);
    do_fio(&c__1, ele, 2L);
    e_wsfe();
    goto L190;

/* ALL O.K. */

L70:
    if (label != 99) {
	++numat;
    }
    if (weight != 0.) {
	s_wsfe(&io___30);
	do_fio(&c__1, (char *)&(*natoms), (ftnlen)sizeof(integer));
	do_fio(&c__1, (char *)&weight, (ftnlen)sizeof(doublereal));
	e_wsfe();
	atmass_1.atmass[numat - 1] = weight;
    } else {
	if (label != 99) {
	    atmass_1.atmass[numat - 1] = ams[label];
	}
    }
    labels[*natoms] = label;
    geo[*natoms * 3 + 1] = reada_(line, &istart[1], 80L);
    geo[*natoms * 3 + 2] = reada_(line, &istart[3], 80L);
    geo[*natoms * 3 + 3] = reada_(line, &istart[5], 80L);
    if (ircdrc) {
	i__1 = istart[2] - 1;
	s_copy(turn, line + i__1, 1L, istart[2] - i__1);
	if (*(unsigned char *)turn == 'T') {
	    lopt[*natoms * 3 + 1] = 1;
	    if (*natoms == 1) {
		s_wsfe(&io___32);
		do_fio(&c__1, " IN DRC MONITOR POTENTIAL ENERGY TURNING POIN"
			"TS", 47L);
		e_wsfe();
	    }
	} else {
	    lopt[*natoms * 3 + 1] = 0;
	}
	i__1 = istart[4] - 1;
	s_copy(turn, line + i__1, 1L, istart[4] - i__1);
	if (*(unsigned char *)turn == 'T') {
	    lopt[*natoms * 3 + 2] = 1;
	} else {
	    lopt[*natoms * 3 + 2] = 0;
	}
	i__1 = istart[6] - 1;
	s_copy(turn, line + i__1, 1L, istart[6] - i__1);
	if (*(unsigned char *)turn == 'T') {
	    lopt[*natoms * 3 + 3] = 1;
	} else {
	    lopt[*natoms * 3 + 3] = 0;
	}
    } else {
	lopt[*natoms * 3 + 1] = (integer) reada_(line, &istart[2], 80L);
	lopt[*natoms * 3 + 2] = (integer) reada_(line, &istart[4], 80L);
	lopt[*natoms * 3 + 3] = (integer) reada_(line, &istart[6], 80L);
    }
    na[*natoms] = (integer) reada_(line, &istart[7], 80L);
    nb[*natoms] = (integer) reada_(line, &istart[8], 80L);
    nc[*natoms] = (integer) reada_(line, &istart[9], 80L);
    goto L10;

/* ALL DATA READ IN, CLEAN UP AND RETURN */

L80:
    --(*natoms);
L90:
    na[2] = 1;
    if (*natoms > 3) {
	*int__ = na[4] != 0;
    } else {
	if (geo[11] < 10. && *natoms == 3) {
	    s_wsfe(&io___33);
	    e_wsfe();
	}
	*int__ = TRUE_;
    }

/*     READ IN VELOCITY VECTOR, IF PRESENT */

    if (i_indx(keywrd_1.keywrd, "VELO", 80L, 4L) > 0) {
	if (*int__) {
	    s_wsfe(&io___34);
	    do_fio(&c__1, " COORDINATES MUST BE CARTESIAN WHEN VELOCITY VECT"
		    "OR IS USED.", 60L);
	    e_wsfe();
	    s_stop("", 0L);
	}
/* #      WRITE(6,'(/10X,A)')'INITIAL VELOCITY VECTOR FOR DRC' */
	i__1 = *natoms;
	for (i = 1; i <= i__1; ++i) {
	    s_rsfe(&io___35);
	    do_fio(&c__1, line, 80L);
	    e_rsfe();
	    nuchar_(line, value, &ndmy, 80L);
	    if (ndmy != 3) {
		s_wsfe(&io___38);
		do_fio(&c__1, "  THERE MUST BE EXACTLY THREE VELOCITY DATA P"
			"ER LINE", 52L);
		e_wsfe();
		s_stop("", 0L);
	    }
	    for (j = 1; j <= 3; ++j) {
/* L100: */
		path_1.react[j + (i + 2) * 3 - 4] = value[j - 1];
	    }
/* #      WRITE(6,'(2X,A2,2X,3F13.5)')ELEMNT(LABELS(I)),(VALUE(J),
J=1,3) */
/* L110: */
	}
	for (i = 1; i <= 3; ++i) {
	    for (j = 1; j <= 2; ++j) {
/* L120: */
		path_1.react[i + j * 3 - 4] = geo[i + (j + 1) * 3] - geo[i + 
			3];
	    }
	}

/*  NOW TO ROTATE VELOCITY VECTOR TO SUIT INTERNAL COORDINATE DEFINITI
ON */


/*   ROTATE AROUND THE 1-2 X-AXIS TO AS TO ELIMINATE REACT(3,2) */
/*   (PUT ATOM 2 IN X-Y PLANE) */
/* Computing 2nd power */
	d__1 = path_1.react[1];
/* Computing 2nd power */
	d__2 = path_1.react[2];
	sa = path_1.react[2] / sqrt(d__1 * d__1 + d__2 * d__2 + 1e-20);
/* Computing 2nd power */
	d__2 = sa;
	d__1 = sqrt(1. - d__2 * d__2);
	ca = d_sign(&d__1, &path_1.react[1]);
/* #      LABELS(NATOMS+1)=1 */
/* #      LABELS(NATOMS+2)=1 */
/* #      WRITE(6,*)' FIRST ROTATION, ABOUT 1-2 X-AXIS' */
	i__1 = *natoms + 2;
	for (i = 1; i <= i__1; ++i) {
	    temp1 = path_1.react[i * 3 - 2] * ca + path_1.react[i * 3 - 1] * 
		    sa;
	    temp2 = -path_1.react[i * 3 - 2] * sa + path_1.react[i * 3 - 1] * 
		    ca;
	    path_1.react[i * 3 - 2] = temp1;
	    path_1.react[i * 3 - 1] = temp2;
/* #      WRITE(6,'(2X,A2,2X,3F13.5)')ELEMNT(LABELS(I)),(REACT(J,I
),J=1,3) */
/* L130: */
	}
/*   ROTATE AROUND THE 1-2 Z-AXIS TO AS TO ELIMINATE REACT(2,2) */
/*   (PUT ATOM 2 ON X AXIS) */
/* Computing 2nd power */
	d__1 = path_1.react[1];
/* Computing 2nd power */
	d__2 = path_1.react[0];
	ca = path_1.react[0] / sqrt(d__1 * d__1 + d__2 * d__2 + 1e-20);
/* Computing 2nd power */
	d__2 = ca;
	d__1 = sqrt(1. - d__2 * d__2);
	sa = d_sign(&d__1, &path_1.react[1]);
/* #      WRITE(6,*)' SECOND ROTATION, ABOUT 1-2 Z-AXIS' */
	i__1 = *natoms + 2;
	for (i = 1; i <= i__1; ++i) {
	    temp1 = path_1.react[i * 3 - 3] * ca + path_1.react[i * 3 - 2] * 
		    sa;
	    temp2 = -path_1.react[i * 3 - 3] * sa + path_1.react[i * 3 - 2] * 
		    ca;
	    path_1.react[i * 3 - 3] = temp1;
	    path_1.react[i * 3 - 2] = temp2;
/* #      WRITE(6,'(2X,A2,2X,3F13.5)')ELEMNT(LABELS(I)),(REACT(J,I
),J=1,3) */
/* L140: */
	}
/*   ROTATE AROUND THE 2-3 X-AXIS TO AS TO ELIMINATE REACT(3,3) */
/*   (PUT ATOM 3 ON X-Y PLANE) */
/* Computing 2nd power */
	d__1 = path_1.react[4];
/* Computing 2nd power */
	d__2 = path_1.react[5];
	sa = path_1.react[5] / sqrt(d__1 * d__1 + d__2 * d__2 + 1e-20);
/* Computing 2nd power */
	d__2 = sa;
	d__1 = sqrt(1. - d__2 * d__2);
	ca = d_sign(&d__1, &path_1.react[4]);
/* #      WRITE(6,*)' THIRD ROTATION, ABOUT 2-3 X-AXIS' */
	i__1 = *natoms + 2;
	for (i = 1; i <= i__1; ++i) {
	    temp1 = path_1.react[i * 3 - 2] * ca + path_1.react[i * 3 - 1] * 
		    sa;
	    temp2 = -path_1.react[i * 3 - 2] * sa + path_1.react[i * 3 - 1] * 
		    ca;
	    path_1.react[i * 3 - 2] = temp1;
	    path_1.react[i * 3 - 1] = temp2;
/* #      WRITE(6,'(2X,A2,2X,3F13.5)')ELEMNT(LABELS(I)),(REACT(J,I
),J=1,3) */
/* L150: */
	}

/*  STRIP OFF FIRST TWO COORDINATES; THESE WERE THE COORDINATE AXIS */
/*  DEFINITIONS */

	i__1 = *natoms;
	for (i = 1; i <= i__1; ++i) {
	    for (j = 1; j <= 3; ++j) {
/* L160: */
		path_1.react[j + i * 3 - 4] = path_1.react[j + (i + 2) * 3 - 
			4];
	    }
	}
    }
    if (! (*int__)) {
	i__1 = *natoms;
	for (i = 1; i <= i__1; ++i) {
	    for (j = 1; j <= 3; ++j) {
/* L170: */
		xyz[j + i * 3 - 4] = geo[j + i * 3];
	    }
	}
	degree = 90. / asin(1.);
	xyzint_(xyz, natoms, &na[1], &nb[1], &nc[1], &degree, &geo[4]);
	if ((d__1 = geo[11] - 180., abs(d__1)) < 1e-4 || abs(geo[11]) < 1e-4) 
		{
	    s_wsfe(&io___46);
	    do_fio(&c__1, " DUE TO PROGRAM BUG, THE FIRST THREE ATOMS MUST N"
		    "OT LIE IN A STRAIGHT LINE.", 75L);
	    e_wsfe();
	    s_stop("", 0L);
	}
    } else if (! ircdrc) {
	if (lopt[4] + lopt[5] + lopt[6] + lopt[8] + lopt[9] + lopt[12] > 0) {
	    lopt[4] = 0;
	    lopt[5] = 0;
	    lopt[6] = 0;
	    lopt[8] = 0;
	    lopt[9] = 0;
	    lopt[12] = 0;
	    s_wsfe(&io___47);
	    e_wsfe();
	}
    }
    if (na[3] == 0) {
	nb[3] = 1;
	na[3] = 2;
    }
    return 0;
/* ERROR CONDITIONS */
L180:
    if (*iread == 5) {
	s_wsfe(&io___48);
	do_fio(&c__1, (char *)&(*natoms), (ftnlen)sizeof(integer));
	e_wsfe();
    } else {
	*natoms = 0;
	return 0;
    }
L190:
    j = *natoms - 1;
    s_wsfe(&io___49);
    e_wsfe();
    i__1 = j;
    for (k = 1; k <= i__1; ++k) {
/* L200: */
	s_wsfe(&io___51);
	do_fio(&c__1, (char *)&labels[k], (ftnlen)sizeof(integer));
	for (jj = 1; jj <= 3; ++jj) {
	    do_fio(&c__1, (char *)&geo[jj + k * 3], (ftnlen)sizeof(doublereal)
		    );
	    do_fio(&c__1, (char *)&lopt[jj + k * 3], (ftnlen)sizeof(integer));
	}
	do_fio(&c__1, (char *)&na[k], (ftnlen)sizeof(integer));
	do_fio(&c__1, (char *)&nb[k], (ftnlen)sizeof(integer));
	do_fio(&c__1, (char *)&nc[k], (ftnlen)sizeof(integer));
	e_wsfe();
    }
    s_stop("", 0L);
    return 0;
} /* getgeo_ */