#! /bin/sh
# This is a shell archive.  Remove anything before this line, then unpack
# it by saving it into a file and typing "sh file".  To overwrite existing
# files, type "sh file -c".  You can also feed this as standard input via
# unshar, or by typing "sh <file", e.g..  If this archive is complete, you
# will see the following message at the end:
#		"End of shell archive."
# Contents:  README driver.f pzeros.f a1 a1.res a2 a2.res a3 a3.res a4
#   a4.res b1 b1.res b2 b2.res b3 b3.res c1 c1.res c2 c2.res c3 c3.res
#   iv-40 iv-40.res vii-80 vii-80.res
# Wrapped by michela@diane on Sat Feb 15 10:34:35 1997
PATH=/bin:/usr/bin:/usr/ucb ; export PATH
if test -f 'README' -a "${1}" != "-c" ; then 
  echo shar: Will not clobber existing file \"'README'\"
else
echo shar: Extracting \"'README'\" \(5588 characters\)
sed "s/^X//" >'README' <<'END_OF_FILE'
X
X  ***************************************************************************
X  * All the software  contained in this library  is protected by copyright. *
X  * Permission  to use, copy, modify, and  distribute this software for any *
X  * purpose without fee is hereby granted, provided that this entire notice *
X  * is included  in all copies  of any software which is or includes a copy *
X  * or modification  of this software  and in all copies  of the supporting *
X  * documentation for such software.                                        *
X  ***************************************************************************
X  * THIS SOFTWARE IS BEING PROVIDED "AS IS", WITHOUT ANY EXPRESS OR IMPLIED *
X  * WARRANTY. IN NO EVENT, NEITHER  THE AUTHORS, NOR THE PUBLISHER, NOR ANY *
X  * MEMBER  OF THE EDITORIAL BOARD OF  THE JOURNAL  "NUMERICAL ALGORITHMS", *
X  * NOR ITS EDITOR-IN-CHIEF, BE  LIABLE FOR ANY ERROR  IN THE SOFTWARE, ANY *
X  * MISUSE  OF IT  OR ANY DAMAGE ARISING OUT OF ITS USE. THE ENTIRE RISK OF *
X  * USING THE SOFTWARE LIES WITH THE PARTY DOING SO.                        *
X  ***************************************************************************
X  * ANY USE  OF THE SOFTWARE  CONSTITUTES  ACCEPTANCE  OF THE TERMS  OF THE *
X  * ABOVE STATEMENT.                                                        *
X  ***************************************************************************
X
X   AUTHOR:
X
X       DARIO ANDREA BINI
X       UNIVERSITY OF PISA, ITALY
X       E-MAIL: bini@dm.unipi.it
X
X   REFERENCE:
X
X    -  NUMERICAL COMPUTATION OF POLYNOMIAL ZEROS BY MEANS OF 
X       ABERTH'S METHOD
X       NUMERICAL ALGORITHMS, 13 (1996), PP. 179-200   
X
X   SOFTWARE REVISION DATE:
X
X       JUNE, 1996
X
X   SOFTWARE LANGUAGE:
X
X       FORTRAN
X
X  ***************************************************************************
X
X
XFiles related to the paper
X
XREADME   :  this file
Xpzeros.f :  source fortran code of the routines for polynomial zeros
Xdriver.f :  driver program
X
Xthe following files of data corresponding to the homonymous polynomials in 
Xsection 5 of the paper:
X
Xa1
Xa2
Xa3
Xa4
Xb1
Xb2
Xb3
Xc1
Xc2
Xc3
Xiv-40    :  (polynomial of degree 40 in the class iv)
Xvii-80   :  (polynomial of degree 80 in the class vii)
X
Xand the output files containing the corresponding results
X
Xa1.res
Xa2.res
Xa3.res
Xa4.res
Xb1.res
Xb2.res
Xb3.res
Xc1.res
Xc2.res
Xc3.res
Xiv-40.res
Xvii-80.res
X
X
X
X                         Using the software:
X
X  The driver program for numerically computing all the roots of the    
X  polynomial p(x)=a(n+1)x^n+a(n)x^(n-1)+...+a(1) having complex        
X  coefficients a(i), i=1,...,n+1 and degree n, where a(1) and a(n+1)   
X  are nonzero, reads from the standard input the file  name  of  the   
X  input data. This file should contain on each line the degree N, the  
X  real part and the imaginary part of the coefficients a(1),...,a(n+1) 
X  of p(x).                                                             
X  The program creates the file '<input file name>.out' containing the  
X  values of                                                            
X  I, ERR(I), ROOT(I), RADIUS(I), RADIUS(I)/ABS(ROOT(I)),   I=1,...,N.  
X  where:                                                               
X           ROOT(I) is the computed approximation to the I-th root;     
X           RADIUS(I) is the absolute error bound;                      
X           RADIUS(I)/ABS(ROOT(I)) is the relative error bound.         
X           ERR(I) is .FALSE. for successful approx. of the I-th root.  
X  More specifically, the disk of center ROOT(i) and radius RADIUS(i),  
X  in the complex plane  contains a root of p(x)  for i=1,...,n.        
X  The output vector ERR contains informations about the computed       
X  approximations, i.e.,                                                
X    ERR(I)=.FALSE. if the approximation of the I-th root has  been     
X           carried out successfully, i.e., the computed approximation  
X           can be viewed as the exact root of a slightly perturbed     
X           polynomial.                                                 
X    ERR(I)=.TRUE. if more iterations are needed for the I-th  root.    
X  The file contains also the number ITER of iterations needed by the   
X  algorithm.                                                           
X  If there exist roots which cannot be represented without overflow or 
X  underflow, then the corresponding components of RADIUS are set to -1 
X                                                   
X  The parameter MAXDEG equals the maximum allowed degree; this value,  
X  which is set to 500 by default, can be adjusted according to the     
X  user needs.                                                          
X  The parameters EPS, SMALL, BIG are related to the floating point     
X  arithmetic used by the computer and have the following meaning and   
X  default values (standard IEEE arithmetic)                            
X       EPS  =1.1102230246252D-16  : machine precision                  
X       SMALL=4.9406564584126D-324 : smallest positive real*8           
X       BIG  =1.7976931348622D+308 : largest real*8                     
X  The parameter NITMAX is the maximum number of allowed iterations.    
X  This value is set to 30 by default.                                  
X                                             
X  WARNING: 2 is the output unit, 3 is the input unit    
X
X  The files *.res contain the outputs obtained by running the program
X  on a 586 (standard IEEE arithmetic) under the Linux operating system
X  where the programs have been compiled with the f2c compiler.
X 
END_OF_FILE
if test 5588 -ne `wc -c <'README'`; then
    echo shar: \"'README'\" unpacked with wrong size!
fi
# end of 'README'
fi
if test -f 'driver.f' -a "${1}" != "-c" ; then 
  echo shar: Will not clobber existing file \"'driver.f'\"
else
echo shar: Extracting \"'driver.f'\" \(8147 characters\)
sed "s/^X//" >'driver.f' <<'END_OF_FILE'
X*************************************************************************
X*    NUMERICAL COMPUTATION OF THE ROOTS OF A POLYNOMIAL HAVING          *
X*        COMPLEX COEFFICIENTS, BASED ON ABERTH'S METHOD.                *
X*                    Version 1.4,  June   1996                          *
X*    (D. Bini, Dipartimento di Matematica, Universita' di Pisa)         *
X*                       (bini@dm.unipi.it)                              *
X*************************************************************************
X* Work performed under the support of the ESPRIT BRA project 6846 POSSO *
X*************************************************************************
X********                     DRIVER PROGRAM                      ********
X*************************************************************************
X*  This is the driver program for numerically computing all the roots   *
X*  of the polynomial p(x)=a(n+1)x^n+a(n)x^(n-1)+...+a(1) having complex *
X*  coefficients a(i), i=1,...,n+1 and degree n, where a(1) and a(n+1)   *
X*  are nonzero.                                                         *
X*                       *******************                             *
X*  The input vector POLY contains the coefficients of the polynomial p, *
X*  that is, POLY(i)=a(i), i=1,...,n+1.                                  *
X*  The output vectors ROOT and RADIUS contain approximations to the     *
X*  roots and the corresponding error bounds, respectively, that is, the *
X*  disk of center ROOT(i) and radius RADIUS(i), in the complex plane    *
X*  contains a root  for i=1,...,n.                                      *
X*  The output vector ERR contains informations about the computed       *
X*  approximations, i.e.,                                                *
X*    ERR(I)=.FALSE. if the approximation of the I-th root has  been     *
X*           carried out successfully, i.e., the computed approximation  *
X*           can be viewed as the exact root of a slightly perturbed     *
X*           polynomial.                                                 *
X*    ERR(I)=.TRUE. if more iterations are needed for the I-th  root.    *
X*                       ********************                            *
X*  This program reads from the standard input the file  name  of  the   *
X*  input data. This file should contain on each line the degree N, the  *
X*  real part and the imaginary part of the coefficients POLY(1),...,    *
X*  POLY(N+1) of p(x).                                                   *
X*                       ********************                            *
X*  The program creates the file '<input file name>.out' containing the  *
X*  values of                                                            *
X*  I, ERR(I), ROOT(I), RADIUS(I), RADIUS(I)/ABS(ROOT(I)),   I=1,...,N.  *
X*           ROOT(I) is the computed approximation to the I-th root;     *
X*           RADIUS(I) is the absolute error bound;                      *
X*           RADIUS(I)/ABS(ROOT(I)) is the relative error bound.         *
X*           ERR(I) is .FALSE. for successful approx. of the I-th root.  *
X*  The file contains also the number ITER of iterations needed by the   *
X*  algorithm.                                                           *
X*  If there exist roots which cannot be represented without overflow or *
X*  underflow, then the corresponding components of RADIUS are set to -1 *
X*                       ********************                            *
X*  The parameter MAXDEG equals the maximum allowed degree; this value,  *
X*  which is set to 500 by default, can be adjusted according to the     *
X*  user needs.                                                          *
X*  The parameters EPS, SMALL, BIG are related to the floating point     *
X*  arithmetic used by the computer and have the following meaning and   *
X*  default values (standard IEEE arithmetic)                            *
X*       EPS  =1.1102230246252D-16  : machine precision                  *
X*       SMALL=4.9406564584126D-324 : smallest positive real*8           *
X*       BIG  =1.7976931348622D+308 : largest real*8                     *
X*  The parameter NITMAX is the maximum number of allowed iterations.    *
X*  This value is set to 30 by default.                                  *
X*                       ********************                            *
X*  The auxiliary vectors APOLY, APOLYR are used.                        *
X*                       ********************                            *
X*  The following subroutines are directly called                        *
X*    POLZEROS: main subroutine for approximating polynomial zeros,      *
X*    SORT    : subroutine which sorts the results (optional).           *
X*  Related modules:                                                     *
X*    ABERTH  :  used by POLZEROS                                        *
X*    NEWTON  :  used by POLZEROS                                        *
X*    START   :  used by POLZEROS                                        *
X*    CNVEX   :  used by START                                           *
X*    CMERGE  :  used by CNVEX                                           *
X*    LEFT    :  used by CMERGE                                          *
X*    RIGHT   :  used by CMERGE                                          *
X*    CTEST   :  used by CMERGE                                          *
X*************************************************************************
X****      WARNING: 2 is the output unit, 3 is the input unit         ****
X*************************************************************************
X      INTEGER MAXDEG, NITMAX
X      REAL*8 EPS, SMALL, BIG
X      PARAMETER (MAXDEG=25600)
X      PARAMETER (EPS=1.1102230246252D-16)
X      PARAMETER (SMALL=4.9406564584126D-324, BIG=1.7976931348622D+308)
X      PARAMETER (NITMAX=30)
X      COMPLEX*16 POLY(MAXDEG+1),ROOT(MAXDEG)
X      REAL*8 RADIUS(MAXDEG),APOLY(MAXDEG+1),APOLYR(MAXDEG+1)
X      REAL*8 PR,PI
X      LOGICAL ERR(MAXDEG+1)
X      CHARACTER*12  INPTFI
X      INTEGER I, J, N, ITER
X      WRITE(*,400) 
X      READ(*,*,ERR=200) INPTFI
X      OPEN(3,FILE=INPTFI,STATUS='OLD',ERR=200)
X      J = INDEX(INPTFI,'.')
X      IF (J.EQ.0) J = INDEX(INPTFI,' ')
X      READ(3,*,ERR=100,END=100) N
X      DO 20 I=1,N+1
X         READ(3,*,END=100,ERR=100) PR,PI
X         POLY(I)=PR+(0,1)*PI
X  20  CONTINUE
X      OPEN(2,FILE=INPTFI(1:J-1)//'.out',STATUS='UNKNOWN')
X      CALL POLZEROS (N, POLY, EPS, BIG, SMALL, NITMAX, 
X     * ROOT, RADIUS, ERR, ITER, APOLY, APOLYR)
X      CALL SORT(N,ROOT,RADIUS,ERR)
X      DO 30 I=1,N
X         PR=ABS(ROOT(I))
X         IF(PR.NE.0.) PR=RADIUS(I)/PR
X         IF(RADIUS(I).LE.0) PR=-1
X         WRITE(*,300)I,ERR(I),ROOT(I),RADIUS(I),PR
X         WRITE(2,300)I,ERR(I),ROOT(I),RADIUS(I),PR
X  30  CONTINUE
X      WRITE(*,*)' ITERATIONS =',ITER
X      WRITE(2,*)' ITERATIONS =',ITER
X      STOP
X 100  WRITE(*,*)' ERROR READING INPUT DATA FILE'
X      STOP 
X 200  WRITE(*,*)' ERROR IN FILE NAME'
X      STOP
X 300  FORMAT(1X,I4,' ERR=',L1,' X=',E21.15,',',E21.15,' R=',
X     *E7.1,' RR=',E7.1)
X 400  FORMAT(' INSERT INPUT FILE NAME = ',$)
X      END
X 
X
X*************************************************************************
X*                             SUBROUTINE SORT                           *
X*************************************************************************
X*   SORT  the vector X, according to nonincreasing real parts,          *
X*   the same permutation is applied to vectors Y and E.                 *
X*************************************************************************
X      SUBROUTINE SORT(N,X,Y,E)
X      INTEGER N,K,I,IMAX
X      COMPLEX*16 X(N),TEMP
X      REAL*8  Y(N),YT,AMAX,RXI
X      LOGICAL E(N),ET
X      DO 10 K=1,N-1
X         AMAX=REAL(X(K))
X         IMAX=K
X         DO 20 I=K+1,N
X            RXI=REAL(X(I))
X            IF (AMAX.LT.RXI) THEN
X               AMAX=RXI
X               IMAX=I
X            ENDIF
X  20     CONTINUE
X         TEMP=X(K)
X         X(K)=X(IMAX)
X         X(IMAX)=TEMP
X         YT=Y(K)
X         ET=E(K)
X         Y(K)=Y(IMAX)
X         Y(IMAX)=YT
X         E(K)=E(IMAX)
X         E(IMAX)=ET
X  10  CONTINUE
X      END
X
END_OF_FILE
if test 8147 -ne `wc -c <'driver.f'`; then
    echo shar: \"'driver.f'\" unpacked with wrong size!
fi
# end of 'driver.f'
fi
if test -f 'pzeros.f' -a "${1}" != "-c" ; then 
  echo shar: Will not clobber existing file \"'pzeros.f'\"
else
echo shar: Extracting \"'pzeros.f'\" \(31647 characters\)
sed "s/^X//" >'pzeros.f' <<'END_OF_FILE'
X*************************************************************************
X*    NUMERICAL COMPUTATION OF THE ROOTS OF A POLYNOMIAL HAVING          *
X*        COMPLEX COEFFICIENTS, BASED ON ABERTH'S METHOD.                *
X*                      Version 1.4, June   1996                         *
X*    (D. Bini, Dipartimento di Matematica, Universita' di Pisa)         *
X*                         (bini@dm.unipi.it)                            *
X*************************************************************************
X* Work performed under the support of the ESPRIT BRA project 6846 POSSO *
X*************************************************************************
X***********         SUBROUTINES AND FUNCTIONS                 ***********
X*************************************************************************
X*  The following modules are listed:                                    *
X*  POLZEROS  :  computes polynomial roots by means of Aberth's method   *
X*    ABERTH  :  computes the Aberth correction                          *
X*    NEWTON  :  computes p(x)/p'(x) by means of Ruffini-Horner's rule   *
X*    START   :  Selects N starting points by means of Rouche's theorem  *
X*    CNVEX   :  Computes the convex hull, used by START                 *
X*    CMERGE  :  Used by CNVEX                                           *
X*    LEFT    :  Used by CMERGE                                          *
X*    RIGHT   :  Used by CMERGE                                          *
X*    CTEST   :  Convexity test, Used by CMERGE                          *
X*************************************************************************
X*                                                                       *
X*                                                                       *
X*************************************************************************
X*********************** SUBROUTINE POLZEROS *****************************
X*************************************************************************
X*                        GENERAL COMMENTS                               *
X*************************************************************************
X*  This routine approximates the roots of   the  polynomial             *
X*  p(x)=a(n+1)x^n+a(n)x^(n-1)+...+a(1), a(j)=cr(j)+I ci(j), I**2=-1,    *
X*  where a(1) and a(n+1) are nonzero.                                   *
X*  The coefficients are complex*16 numbers. The routine is fast, robust *
X*  against overflow, and allows to deal with polynomials of any degree. *
X*  Overflow situations are very unlikely and may occurr if there exist  *
X*  simultaneously coefficients of moduli close to BIG and close to      *
X*  SMALL, i.e., the greatest and the smallest positive real*8 numbers,  *
X*  respectively. In this limit situation the program outputs a warning  *
X*  message. The computation can be speeded up by performing some side   *
X*  computations in single precision, thus slightly reducing the         *
X*  robustness of the program (see the comments in the routine ABERTH).  *
X*  Besides a set of approximations to the roots, the program delivers a *
X*  set of a-posteriori error bounds which are guaranteed in the most    *
X*  part of cases. In the situation where underflow does not allow to    *
X*  compute a guaranteed bound, the program outputs a warning message    *
X*  and sets the bound to 0. In the situation where the root cannot be   *
X*  represented as a complex*16 number the error bound is set to -1.     *
X*************************************************************************
X*  The computation is performed by means of Aberth's method             *
X*  according to the formula                                             *
X*           x(i)=x(i)-newt/(1-newt*abcorr), i=1,...,n             (1)   *
X*  where newt=p(x(i))/p'(x(i)) is the Newton correction and abcorr=     *
X*  =1/(x(i)-x(1))+...+1/(x(i)-x(i-1))+1/(x(i)-x(i+1))+...+1/(x(i)-x(n)) *
X*  is the Aberth correction to the Newton method.                       *
X*************************************************************************
X*  The value of the Newton correction is computed by means of the       *
X*  synthetic division algorithm (Ruffini-Horner's rule) if |x|<=1,      *
X*  otherwise the following more robust (with respect to overflow)       *
X*  formula is applied:                                                  *
X*                    newt=1/(n*y-y**2 R'(y)/R(y))                 (2)   *
X*  where                                                                *
X*                    y=1/x                                              *
X*                    R(y)=a(1)*y**n+...+a(n)*y+a(n+1)            (2')   *
X*  This computation is performed by the routine NEWTON.                 *
X*************************************************************************
X*  The starting approximations are complex numbers that are             *
X*  equispaced on circles of suitable radii. The radius of each          *
X*  circle, as well as the number of roots on each circle and the        *
X*  number of circles, is determined by applying Rouche's theorem        *
X*  to the functions a(k+1)*x**k and p(x)-a(k+1)*x**k, k=0,...,n.        *
X*  This computation is performed by the routine START.                  *
X*************************************************************************
X*                              STOP CONDITION                           *
X*************************************************************************
X* If the condition                                                      *
X*                     |p(x(j))|<EPS s(|x(j)|)                      (3)  *
X* is satisfied,    where      s(x)=s(1)+x*s(2)+...+x**n * s(n+1),       *
X* s(i)=|a(i)|*(1+3.8*(i-1)),  EPS is the machine precision (EPS=2**-53  *
X* for the IEEE arithmetic), then the approximation x(j) is not updated  *
X* and the subsequent iterations (1)  for i=j are skipped.               *
X* The program stops if the condition (3) is satisfied for j=1,...,n,    *
X* or if the maximum number NITMAX of  iterations   has   been reached.  *
X* The condition (3) is motivated by a backward rounding error analysis  *
X* of the Ruffini-Horner rule, moreover the condition (3) guarantees     *
X* that the computed approximation x(j) is an exact root of a slightly   *
X* perturbed polynomial.                                                 *
X*************************************************************************
X*             INCLUSION DISKS, A-POSTERIORI ERROR BOUNDS                *
X*************************************************************************
X* For each approximation x of a root, an a-posteriori absolute error    *
X* bound r is computed according to the formula                          *
X*                   r=n(|p(x)|+EPS s(|x|))/|p'(x)|                 (4)  *
X* This provides an inclusion disk of center x and radius r containing a *
X* root.                                                                 *
X*************************************************************************
X*************************************************************************
X**************       MEANING OF THE INPUT VARIABLES         *************
X*************************************************************************
X*************************************************************************
X*                                                                       *
X*  -- N     : degree of the polynomial.                                 *
X*  -- POLY  : complex vector of N+1 components, POLY(i) is the          *
X*           coefficient of x**(i-1), i=1,...,N+1 of the polynomial p(x) *
X*  -- EPS   : machine precision of the floating point arithmetic used   *
X*            by the computer, EPS=2**(-53)  for the IEEE standard.      *
X*  -- BIG   : the max real*8, BIG=2**1023 for the IEEE standard.        *
X*  -- SMALL : the min positive real*8, SMALL=2**(-1074) for the IEEE.   *
X*  -- NITMAX: the max number of allowed iterations.                     *
X*************************************************************************
X*************************************************************************
X**************      MEANING OF THE OUTPUT VARIABLES         *************
X*************************************************************************
X*************************************************************************
X*  ROOT   : complex vector of N components, containing the              *
X*           approximations to the roots of p(x).                        *
X*  RADIUS : real vector of N components, containing the error bounds to *
X*           the approximations of the roots, i.e. the disk of center    *
X*           ROOT(i) and radius RADIUS(i) contains a root of p(x), for   *
X*           i=1,...,N. RADIUS(i) is set to -1 if the corresponding root *
X*           cannot be represented as floating point due to overflow or  *
X*           underflow.                                                  *
X*  ERR    : vector of N components detecting an error condition;        *
X*           ERR(j)=.TRUE. if after NITMAX iterations the stop condition *
X*                         (3) is not satisfied for x(j)=ROOT(j);        *
X*           ERR(j)=.FALSE.  otherwise, i.e., the root is reliable,      *
X*                         i.e., it can be viewed as an exact root of a  *
X*                         slightly perturbed polynomial.                *
X*           The vector ERR is used also in the routine convex hull for  *
X*           storing the abscissae of the vertices of the convex hull.   *
X*  ITER   : number of iterations peformed.                              *
X*************************************************************************
X*************************************************************************
X*************    MEANING OF THE AUXILIARY VARIABLES         *************
X*************************************************************************
X*************************************************************************
X*  APOLY  : real vector of N+1 components used to store the moduli of   *
X*           the coefficients of p(x) and the coefficients of s(x) used  *
X*           to test the stop condition (3).                             *
X*  APOLYR : real vector of N+1 components used to test the stop         *
X*           condition                                                   *
X*************************************************************************
X******         WARNING:   2 is the output unit                    *******
X*************************************************************************
X      SUBROUTINE POLZEROS (N, POLY, EPS, BIG, SMALL, NITMAX, 
X     * ROOT, RADIUS, ERR, ITER, APOLY,APOLYR)
X      INTEGER N,I,NZEROS,ITER,NITMAX
X      COMPLEX*16 POLY(N+1),ROOT(N)
X      COMPLEX*16 CORR,ABCORR
X      REAL*8 RADIUS(N),APOLY(N+1),APOLYR(N+1)
X      REAL*8 AMAX,EPS,SMALL,BIG
X      LOGICAL ERR(N+1)
XC Check consistency of data
X      IF (ABS(POLY(N+1)) .EQ. 0.0D0)THEN
X        WRITE(*,*)'Inconsistent data: the leading coefficient is zero'
X        STOP
X      ENDIF
X      IF (ABS(POLY(1)) .EQ. 0.0D0)THEN
X        WRITE(*,*)'The constant term is zero: deflate the polynomial'
X        STOP
X      ENDIF
XC Compute the moduli of the coefficients
X      AMAX=0
X      DO 10 I=1,N+1
X        APOLY(I)=ABS(POLY(I))
X        AMAX=MAX(AMAX,APOLY(I))
X        APOLYR(I)=APOLY(I)
X10    CONTINUE
X      IF((AMAX).GE.(BIG/(N+1)))THEN
X        WRITE(*,*)'WARNING: COEFFICIENTS TOO BIG, OVERFLOW IS LIKELY'
X        WRITE(2,*)'WARNING: COEFFICIENTS TOO BIG, OVERFLOW IS LIKELY'
X      ENDIF
XC Initialize
X      DO 20 I=1,N
X        RADIUS(I)=0
X        ERR(I)=.TRUE.
X20    CONTINUE
XC Select the starting points
X      CALL START(N,APOLYR,ROOT,RADIUS,NZEROS,SMALL,BIG,ERR)
XC Compute the coefficients of the backward-error polynomial
X      DO 30 I=1,N+1
X        APOLYR(N-I+2)=EPS*APOLY(I)*(3.8*(N-I+1)+1)
X        APOLY(I)=EPS*APOLY(I)*(3.8*(I-1)+1)
X30    CONTINUE
X      IF((APOLY(1).EQ.0).OR.(APOLY(N+1).EQ.0))THEN
X        WRITE(*,*)'WARNING: THE COMPUTATION OF SOME INCLUSION RADIUS'
X        WRITE(*,*)'MAY FAIL. THIS IS REPORTED BY RADIUS=0'
X        WRITE(2,*)'WARNING: THE COMPUTATION OF SOME INCLUSION RADIUS'
X        WRITE(2,*)'MAY FAIL. THIS IS REPORTED BY RADIUS=0'
X      ENDIF
X      DO 40 I=1,N
X        ERR(I)=.TRUE.
X        IF(RADIUS(I).EQ.-1)ERR(I)=.FALSE.
X40    CONTINUE
XC Starts Aberth's iterations
X      DO 50 ITER=1,NITMAX
X        DO 50 I=1,N
X          IF (ERR(I)) THEN
X            CALL NEWTON(N,POLY,APOLY,APOLYR,ROOT(I),SMALL,RADIUS(I),
X     *           CORR,ERR(I))
X            IF (ERR(I)) THEN
X              CALL ABERTH(N,I,ROOT,ABCORR)
X              ROOT(I)=ROOT(I)-CORR/(1-CORR*ABCORR)
X            ELSE
X              NZEROS=NZEROS+1
X              IF (NZEROS.EQ.N) RETURN
X            ENDIF
X          ENDIF
X50    CONTINUE
X      END
X
X
X
X
X*************************************************************************
X*                             SUBROUTINE NEWTON                         *
X*************************************************************************
X* Compute  the Newton's correction, the inclusion radius (4) and checks *
X* the stop condition (3)                                                *
X*************************************************************************
X* Input variables:                                                      *
X*     N     : degree of the polynomial p(x)                             *
X*     POLY  : coefficients of the polynomial p(x)                       *
X*     APOLY : upper bounds on the backward perturbations on the         *
X*             coefficients of p(x) when applying Ruffini-Horner's rule  *
X*     APOLYR: upper bounds on the backward perturbations on the         *
X*             coefficients of p(x) when applying (2), (2')              *
X*     Z     : value at which the Newton correction is computed          *
X*     SMALL : the min positive real*8, SMALL=2**(-1074) for the IEEE.   *
X*************************************************************************
X* Output variables:                                                     *
X*     RADIUS: upper bound to the distance of Z from the closest root of *
X*             the polynomial computed according to (4).                 *
X*     CORR  : Newton's correction                                       *
X*     AGAIN : this variable is .true. if the computed value p(z) is     *
X*             reliable, i.e., (3) is not satisfied in Z. AGAIN is       *
X*             .false., otherwise.                                       *
X*************************************************************************
X      SUBROUTINE NEWTON(N,POLY,APOLY,APOLYR,Z,SMALL,RADIUS,CORR,AGAIN)
X      INTEGER N,I
X      COMPLEX*16 POLY(N+1)
X      COMPLEX*16 Z,P,P1,CORR,ZI,DEN,PPSP
X      REAL*8 RADIUS,APOLY(N+1),APOLYR(N+1)
X      REAL*8 AP,AZ,AZI,ABSP
X      REAL*8 SMALL
X      LOGICAL AGAIN
X      AZ=ABS(Z)
XC If |z|<=1 then apply Ruffini-Horner's rule for p(z)/p'(z) 
XC and for the computation of the inclusion radius
X      IF(AZ.LE.1)THEN
X        P=POLY(N+1)
X        AP=APOLY(N+1)
X        P1=P
X        DO 10 I=N,2,-1
X          P=P*Z+POLY(I)
X          P1=P1*Z+P
X          AP=AP*AZ+APOLY(I)
X10      CONTINUE
X        P=P*Z+POLY(1)
X        AP=AP*AZ+APOLY(1)
X        CORR=P/P1
X        ABSP=ABS(P)
X        AP=AP
X        AGAIN=(ABSP.GT.(SMALL+AP))
X        IF(.NOT.AGAIN) RADIUS=N*(ABSP+AP)/ABS(P1)
X        RETURN
X      ELSE
XC If |z|>1 then apply Ruffini-Horner's rule to the reversed polynomial
XC and use formula (2) for p(z)/p'(z). Analogously do for the inclusion
XC radius.
X        ZI=1/Z
X        AZI=1/AZ
X        P=POLY(1)
X        P1=P
X        AP=APOLYR(N+1)
X        DO 20 I=N,2,-1
X          P=P*ZI+POLY(N-I+2)
X          P1=P1*ZI+P
X          AP=AP*AZI+APOLYR(I)
X20      CONTINUE
X        P=P*ZI+POLY(N+1)
X        AP=AP*AZI+APOLYR(1)
X        ABSP=ABS(P)  
X        AGAIN=(ABSP.GT.(SMALL+AP))
X        PPSP=(P*Z)/P1
X        DEN=N*PPSP-1
X        CORR=Z*(PPSP/DEN)
X        IF(AGAIN)RETURN
X        RADIUS=ABS(PPSP)+(AP*AZ)/ABS(P1)
X        RADIUS=N*RADIUS/ABS(DEN)
X        RADIUS=RADIUS*AZ
X      ENDIF
X      END
X 
X
X 
X*************************************************************************
X*                             SUBROUTINE ABERTH                         *
X*************************************************************************
X* Compute  the Aberth correction. To save time, the reciprocation of    *
X* ROOT(J)-ROOT(I) could be performed in single precision (complex*8)    *
X* In principle this might cause overflow if both ROOT(J) and ROOT(I)    *
X* have too small moduli.                                                *
X*************************************************************************
X* Input variables:                                                      *
X*     N     : degree of the polynomial                                  *
X*     ROOT  : vector containing the current approximations to the roots *
X*     J     : index of the component of ROOT with respect to which the  *
X*             Aberth correction is computed                             *
X*************************************************************************
X* Output variable:                                                      *
X*     ABCORR: Aberth's correction (compare (1))                         *
X*************************************************************************
X      SUBROUTINE ABERTH(N,J,ROOT,ABCORR)
X      INTEGER N,I,J
X      COMPLEX*16 ABCORR,ZJ
X      COMPLEX*16 ROOT(N)
XC The next variable Z could be defined as complex*8 to speed up the
XC computation, this slightly reduces the robustness of the program
X      COMPLEX*16 Z
X      ABCORR=0
X      ZJ=ROOT(J)
X      DO 10 I=1,J-1
X        Z=ZJ-ROOT(I)
X        ABCORR=ABCORR+1/Z
X10    CONTINUE
X      DO 20 I=J+1,N
X        Z=ZJ-ROOT(I)
X        ABCORR=ABCORR+1/Z
X20    CONTINUE
X      END
X 
X*************************************************************************
X*                             SUBROUTINE START                          *
X*************************************************************************
X* Compute  the starting approximations of the roots                     *
X*************************************************************************
X* Input variables:                                                      *
X*     N     :  number of the coefficients of the polynomial             *
X*     A     :  moduli of the coefficients of the polynomial             *
X*     SMALL : the min positive real*8, SMALL=2**(-1074) for the IEEE.   *
X*     BIG   : the max real*8, BIG=2**1023 for the IEEE standard.        *
X* Output variables:                                                     *
X*     Y     :  starting approximations                                  *
X*     RADIUS:  if a component is -1 then the corresponding root has a   *
X*              too big or too small modulus in order to be represented  *
X*              as double float with no overflow/underflow               *
X*     NZ    :  number of roots which cannot be represented without      *
X*              overflow/underflow                                       *
X* Auxiliary variables:                                                  *
X*     H     :  needed for the computation of the convex hull            *
X*************************************************************************
X* This routines selects starting approximations along circles center at *
X* 0 and having suitable radii. The computation of the number of circles *
X* and of the corresponding radii is performed by computing the upper    *
X* convex hull of the set (i,log(A(i))), i=1,...,n+1.                    *
X************************************************************************* 
X      SUBROUTINE START(N,A,Y,RADIUS,NZ,SMALL,BIG,H)
X      INTEGER N,NZ,I,IOLD,NZEROS,J,JJ
X      LOGICAL H(N+1)
X      COMPLEX*16 Y(N)
X      REAL*8 A(N+1),RADIUS(N)
X      REAL*8 R,TH,ANG,TEMP,SIGMA,PI2
X      REAL*8 SMALL,BIG,XSMALL,XBIG
X      PARAMETER(PI2=6.2831853071796,SIGMA=0.7)
X      XSMALL=LOG(SMALL)
X      XBIG=LOG(BIG)
X      NZ=0
XC Compute the logarithm A(I) of the moduli of the coefficients of
XC the polynomial and then the upper covex hull of the set (A(I),I)
X      DO 10 I=1,N+1
X        IF(A(I).NE.0)THEN
X          A(I)=LOG(A(I))
X          ELSE
X          A(I)=-1.D30
X        ENDIF
X10    CONTINUE
X      CALL CNVEX(N+1,A,H)
XC Given the upper convex hull of the set (A(I),I) compute the moduli
XC of the starting approximations by means of Rouche's theorem
X      IOLD=1
X      TH=PI2/N
X      DO 20 I=2,N+1
X        IF (H(I)) THEN
X          NZEROS=I-IOLD
X          TEMP=(A(IOLD)-A(I))/NZEROS
XC Check if the modulus is too small
X          IF((TEMP.LT.-XBIG).AND.(TEMP.GE.XSMALL))THEN
X            WRITE(*,*)'WARNING:',NZEROS,' ZERO(S) ARE TOO SMALL TO'
X            WRITE(*,*)'REPRESENT THEIR INVERSES AS COMPLEX*16, THEY'
X            WRITE(*,*)'ARE REPLACED BY SMALL NUMBERS, THE CORRESPONDING'
X            WRITE(*,*)'RADII ARE SET TO -1'
X            WRITE(2,*)'WARNING:',NZEROS,' ZERO(S) ARE TOO SMALL TO '
X            WRITE(2,*)'REPRESENT THEIR INVERSES AS COMPLEX*16, THEY'
X            WRITE(2,*)'ARE REPLACED BY SMALL NUMBERS, THE CORRESPONDING'
X            WRITE(2,*)'RADII ARE SET TO -1'
X            NZ=NZ+NZEROS
X            R=1.0D0/BIG
X          ENDIF
X          IF(TEMP.LT.XSMALL)THEN
X            NZ=NZ+NZEROS
X            WRITE(*,*)'WARNING: ',NZEROS,' ZERO(S) ARE TOO SMALL TO BE'
X            WRITE(*,*)'REPRESENTED AS COMPLEX*16, THEY ARE SET TO 0'
X            WRITE(*,*)'THE CORRESPONDING RADII ARE SET TO -1'
X            WRITE(2,*)'WARNING: ',NZEROS,' ZERO(S) ARE TOO SMALL TO BE'
X            WRITE(2,*)'REPRESENTED AS COMPLEX*16, THEY ARE SET 0'
X            WRITE(2,*)'THE CORRESPONDING RADII ARE SET TO -1'
X          ENDIF
XC Check if the modulus is too big
X          IF(TEMP.GT.XBIG)THEN
X            R=BIG
X            NZ=NZ+NZEROS
X            WRITE(*,*)'WARNING: ',NZEROS,' ZEROS(S) ARE TOO BIG TO BE'
X            WRITE(*,*)'REPRESENTED AS COMPLEX*16,'
X            WRITE(*,*)'THE CORRESPONDING RADII ARE SET TO -1'
X            WRITE(2,*)'WARNING: ',NZEROS,' ZERO(S) ARE TOO BIG TO BE'
X            WRITE(2,*)'REPRESENTED AS COMPLEX*16,'
X            WRITE(2,*)'THE CORRESPONDING RADII ARE SET TO -1'
X          ENDIF
X          IF((TEMP.LE.XBIG).AND.(TEMP.GT.MAX(-XBIG,XSMALL)))THEN
X            R=EXP(TEMP)
X          ENDIF
XC Compute NZEROS approximations equally distributed in the disk of
XC radius R
X          ANG=PI2/NZEROS
X          DO 30 J=IOLD,I-1
X            JJ=J-IOLD+1
X            IF((R.LE.(1.0D0/BIG)).OR.(R.EQ.BIG))RADIUS(J)=-1             
X            Y(J)=R*(COS(ANG*JJ+TH*I+SIGMA)+(0,1)*SIN(ANG*JJ+TH*I+SIGMA))
X30        CONTINUE
X          IOLD=I
X        ENDIF
X20    CONTINUE
X      END
X 
X
X*************************************************************************
X*                             SUBROUTINE CNVEX                          *
X*************************************************************************
X* Compute  the upper convex hull of the set (i,a(i)), i.e., the set of  *
X* vertices (i_k,a(i_k)), k=1,2,...,m, such that the points (i,a(i)) lie *
X* below the straight lines passing through two consecutive vertices.    *
X* The abscissae of the vertices of the convex hull equal the indices of *
X* the TRUE  components of the logical output vector H.                  *
X* The used method requires O(nlog n) comparisons and is based on a      *
X* divide-and-conquer technique. Once the upper convex hull of two       *
X* contiguous sets  (say, {(1,a(1)),(2,a(2)),...,(k,a(k))} and           *
X* {(k,a(k)), (k+1,a(k+1)),...,(q,a(q))}) have been computed, then       *
X* the upper convex hull of their union is provided by the subroutine    *
X* CMERGE. The program starts with sets made up by two consecutive       *
X* points, which trivially constitute a convex hull, then obtains sets   *
X* of 3,5,9... points,  up to  arrive at the entire set.                 *
X* The program uses the subroutine  CMERGE; the subroutine CMERGE uses   *
X* the subroutines LEFT, RIGHT and CTEST. The latter tests the convexity *
X* of the angle formed by the points (i,a(i)), (j,a(j)), (k,a(k)) in the *
X* vertex (j,a(j)) up to within a given tolerance TOLER, where i<j<k.    *
X*************************************************************************
X      SUBROUTINE CNVEX(N,A,H)
X      INTEGER N,I,J,K,M,NJ,JC
X      LOGICAL H(N)
X      REAL*8 A(N)
X      DO 10 I=1,N
X        H(I)=.TRUE.
X10    CONTINUE
XC compute K such that N-2<=2**K<N-1
X      K=INT(LOG(N-2.0D0)/LOG(2.0D0))
X      IF(2**(K+1).LE.(N-2)) K=K+1
XC For each M=1,2,4,8,...,2**K, consider the NJ pairs of consecutive 
XC sets made up by M+1 points having the common vertex
XC (JC,A(JC)), where JC=M*(2*J+1)+1 and J=0,...,NJ,
XC NJ=MAX(0,INT((N-2-M)/(M+M))).
XC Compute the upper convex hull of their union by means of the
XC subroutine CMERGE 
X      M=1
X      DO 20 I=0,K
X        NJ=MAX(0,INT((N-2-M)/(M+M)))
X        DO 30 J=0,NJ
X          JC=(J+J+1)*M+1
X          CALL CMERGE(N,A,JC,M,H)
X30      CONTINUE
X        M=M+M
X20    CONTINUE
X      END
X
X*************************************************************************
X*                             SUBROUTINE LEFT                           *
X************************************************************************* 
X* Given as input the integer I and the vector H of logical, compute the *
X* the maximum integer IL such that IL<I and H(IL) is TRUE.              *
X************************************************************************* 
X* Input variables:                                                      *
X*     N   : length of the vector H                                      *
X*     H   : vector of logical                                           *
X*     I   : integer                                                     *
X************************************************************************* 
X* Output variable:                                                      *
X*     IL  : maximum integer such that IL<I, H(IL)=.TRUE.                *
X************************************************************************* 
X      SUBROUTINE LEFT(N,H,I,IL)
X      INTEGER N,I,IL
X      LOGICAL H(N)
X      DO 10 IL=I-1,0,-1
X        IF (H(IL)) RETURN
X10    CONTINUE
X      END
X
X*************************************************************************
X*                             SUBROUTINE RIGHT                          *
X*************************************************************************
X************************************************************************* 
X* Given as input the integer I and the vector H of logical, compute the *
X* the minimum integer IR such that IR>I and H(IL) is TRUE.              *
X*************************************************************************
X************************************************************************* 
X* Input variables:                                                      *
X*     N   : length of the vector H                                      *
X*     H   : vector of logical                                           *
X*     I   : integer                                                     *
X************************************************************************* 
X* Output variable:                                                      *
X*     IR  : minimum integer such that IR>I, H(IR)=.TRUE.                *
X************************************************************************* 
X      SUBROUTINE RIGHT(N,H,I,IR)
X      INTEGER N,I,IR
X      LOGICAL H(N)
X      DO 10 IR=I+1,N
X        IF (H(IR)) RETURN
X10    CONTINUE
X      END
X
X*************************************************************************
X*                             SUBROUTINE CMERGE                         *
X*************************************************************************
X* Given the upper convex hulls of two consecutive sets of pairs         *
X* (j,A(j)), compute the upper convex hull of their union                *
X*************************************************************************
X* Input variables:                                                      *
X*     N    : length of the vector A                                     *
X*     A    : vector defining the points (j,A(j))                        *
X*     I    : abscissa of the common vertex of the two sets              *
X*     M    : the number of elements of each set is M+1                  *
X*************************************************************************
X* Input/Output variable:                                                *
X*     H    : vector defining the vertices of the convex hull, i.e.,     *
X*            H(j) is .TRUE. if (j,A(j)) is a vertex of the convex hull  *
X*            This vector is used also as output.                        *
X*************************************************************************
X      SUBROUTINE CMERGE(N,A,I,M,H)
X      INTEGER N,M,I,IR,IL,IRR,ILL
X      LOGICAL H(N)
X      LOGICAL TSTL,TSTR,CTEST
X      REAL*8 A(N)
XC at the left and the right of the common vertex (I,A(I)) determine
XC the abscissae IL,IR, of the closest vertices of the upper convex 
XC hull of the left and right sets, respectively 
X      CALL LEFT(N,H,I,IL)
X      CALL RIGHT(N,H,I,IR)
XC check the convexity of the angle formed by IL,I,IR
X      IF (CTEST(N,A,IL,I,IR)) THEN
X        RETURN
X      ELSE
XC continue the search of a pair of vertices in the left and right
XC sets which yield the upper convex hull
X        H(I)=.FALSE.
X10      CONTINUE
X        IF (IL.EQ.(I-M)) THEN
X          TSTL=.TRUE.        
X          ELSE
X          CALL LEFT(N,H,IL,ILL)
X          TSTL=CTEST(N,A,ILL,IL,IR)
X        ENDIF
X        IF (IR.EQ.MIN(N,I+M))THEN
X          TSTR=.TRUE.
X        ELSE
X          CALL RIGHT(N,H,IR,IRR)
X          TSTR=CTEST(N,A,IL,IR,IRR)
X        ENDIF
X        H(IL)=TSTL
X        H(IR)=TSTR
X        IF (TSTL.AND.TSTR) RETURN
X        IF(.NOT.TSTL) IL=ILL
X        IF(.NOT.TSTR) IR=IRR
X        GOTO 10
X      ENDIF
X      END 
X
X*************************************************************************
X*                             FUNCTION CTEST                            *
X************************************************************************* 
X* Test the convexity of the angle formed by (IL,A(IL)), (I,A(I)),       *
X* (IR,A(IR)) at the vertex (I,A(I)), up to within the tolerance         *
X* TOLER. If convexity holds then the function is set to .TRUE.,         *
X* otherwise CTEST=.FALSE. The parameter TOLER is set to 0.4 by default. *
X************************************************************************* 
X* Input variables:                                                      *
X*     N       : length of the vector A                                  *
X*     A       : vector of double                                        *
X*     IL,I,IR : integers such that IL<I<IR                              *
X*************************************************************************
X* Output:                                                               *
X*     .TRUE. if the angle formed by (IL,A(IL)), (I,A(I)), (IR,A(IR)) at *
X*            the vertex (I,A(I)), is convex up to within the tolerance  *
X*            TOLER, i.e., if                                            *
X*            (A(I)-A(IL))*(IR-I)-(A(IR)-A(I))*(I-IL)>TOLER.             *
X*     .FALSE.,  otherwise.                                              *
X*************************************************************************
X      FUNCTION CTEST(N,A,IL,I,IR)
X      INTEGER N,I,IL,IR
X      REAL*8 A(N)
X      REAL*8 S1,S2,TOLER      
X      LOGICAL CTEST
X      PARAMETER(TOLER=0.4)
X      S1=A(I)-A(IL)
X      S2=A(IR)-A(I)
X      S1=S1*(IR-I)
X      S2=S2*(I-IL)
X      CTEST=.FALSE.
X      IF(S1.GT.(S2+TOLER)) CTEST=.TRUE.
X      END
END_OF_FILE
if test 31647 -ne `wc -c <'pzeros.f'`; then
    echo shar: \"'pzeros.f'\" unpacked with wrong size!
fi
# end of 'pzeros.f'
fi
if test -f 'a1' -a "${1}" != "-c" ; then 
  echo shar: Will not clobber existing file \"'a1'\"
else
echo shar: Extracting \"'a1'\" \(92 characters\)
sed "s/^X//" >'a1' <<'END_OF_FILE'
X20
X1 0 
X0 0
X0 0
X0 0
X0 0
X1 0
X0 0
X0 0
X0 0
X0 0
X0 0
X0 0
X0 0
X0 0
X1d200 0
X0 0
X0 0
X0 0
X0 0
X0 0
X1 0
END_OF_FILE
if test 92 -ne `wc -c <'a1'`; then
    echo shar: \"'a1'\" unpacked with wrong size!
fi
# end of 'a1'
fi
if test -f 'a1.res' -a "${1}" != "-c" ; then 
  echo shar: Will not clobber existing file \"'a1.res'\"
else
echo shar: Extracting \"'a1.res'\" \(1597 characters\)
sed "s/^X//" >'a1.res' <<'END_OF_FILE'
X    1 ERR=F X= .186579517236206E+34, .107721734501594E+34 R= .3E+20 RR= .1E-13
X    2 ERR=F X= .186579517236206E+34,-.107721734501594E+34 R= .2E+20 RR= .1E-13
X    3 ERR=F X= .504961443522151E-14, .115254154302561E-14 R= .5E-28 RR= .1E-13
X    4 ERR=F X= .504961443522151E-14,-.115254154302561E-14 R= .5E-28 RR= .1E-13
X    5 ERR=F X= .404947636686896E-14,-.322934964148620E-14 R= .5E-28 RR= .1E-13
X    6 ERR=F X= .404947636686896E-14, .322934964148620E-14 R= .5E-28 RR= .1E-13
X    7 ERR=F X= .224728984048955E-14,-.466654543807619E-14 R= .5E-28 RR= .1E-13
X    8 ERR=F X= .224728984048955E-14, .466654543807619E-14 R= .5E-28 RR= .1E-13
X    9 ERR=F X=-.717464813734306E-42, .517947467923121E-14 R= .5E-28 RR= .9E-14
X   10 ERR=F X=-.805050753816017E-30,-.517947467923121E-14 R= .6E-28 RR= .1E-13
X   11 ERR=F X=-.224728984048955E-14, .466654543807619E-14 R= .5E-28 RR= .1E-13
X   12 ERR=F X=-.224728984048955E-14,-.466654543807619E-14 R= .5E-28 RR= .1E-13
X   13 ERR=F X=-.404947636686896E-14, .322934964148620E-14 R= .5E-28 RR= .1E-13
X   14 ERR=F X=-.404947636686896E-14,-.322934964148620E-14 R= .5E-28 RR= .1E-13
X   15 ERR=F X=-.504961443522151E-14,-.115254154302561E-14 R= .5E-28 RR= .1E-13
X   16 ERR=F X=-.504961443522151E-14, .115254154302561E-14 R= .5E-28 RR= .1E-13
X   17 ERR=F X=-.655360000000000E+05, .215443469003188E+34 R= .2E+20 RR= .9E-14
X   18 ERR=F X=-.945204327687913E+18,-.215443469003188E+34 R= .4E+20 RR= .2E-13
X   19 ERR=F X=-.186579517236206E+34, .107721734501594E+34 R= .3E+20 RR= .1E-13
X   20 ERR=F X=-.186579517236206E+34,-.107721734501594E+34 R= .3E+20 RR= .1E-13
X  ITERATIONS = 7
END_OF_FILE
if test 1597 -ne `wc -c <'a1.res'`; then
    echo shar: \"'a1.res'\" unpacked with wrong size!
fi
# end of 'a1.res'
fi
if test -f 'a2' -a "${1}" != "-c" ; then 
  echo shar: Will not clobber existing file \"'a2'\"
else
echo shar: Extracting \"'a2'\" \(92 characters\)
sed "s/^X//" >'a2' <<'END_OF_FILE'
X20
X1 0 
X0 0
X0 0
X0 0
X0 0
X1 0
X0 0
X0 0
X0 0
X0 0
X0 0
X0 0
X0 0
X0 0
X1d250 0
X0 0
X0 0
X0 0
X0 0
X0 0
X1 0
END_OF_FILE
if test 92 -ne `wc -c <'a2'`; then
    echo shar: \"'a2'\" unpacked with wrong size!
fi
# end of 'a2'
fi
if test -f 'a2.res' -a "${1}" != "-c" ; then 
  echo shar: Will not clobber existing file \"'a2.res'\"
else
echo shar: Extracting \"'a2.res'\" \(1597 characters\)
sed "s/^X//" >'a2.res' <<'END_OF_FILE'
X    1 ERR=F X= .401973384383085E+42, .232079441680639E+42 R= .5E+28 RR= .1E-13
X    2 ERR=F X= .401973384383085E+42,-.232079441680639E+42 R= .5E+28 RR= .1E-13
X    3 ERR=F X= .263882790666240E+14, .464158883361278E+42 R= .5E+28 RR= .1E-13
X    4 ERR=F X= .135465794131525E-17, .309191835136001E-18 R= .1E-31 RR= .9E-14
X    5 ERR=F X= .135465794131525E-17,-.309191835136001E-18 R= .1E-31 RR= .1E-13
X    6 ERR=F X= .108635132224840E-17,-.866336270470311E-18 R= .1E-31 RR= .9E-14
X    7 ERR=F X= .108635132224840E-17, .866336270470311E-18 R= .1E-31 RR= .9E-14
X    8 ERR=F X= .602879500585617E-18,-.125189218252088E-17 R= .1E-31 RR= .9E-14
X    9 ERR=F X= .602879500585617E-18, .125189218252088E-17 R= .1E-31 RR= .9E-14
X   10 ERR=F X=-.350324616081204E-45, .138949549437314E-17 R= .1E-31 RR= .9E-14
X   11 ERR=F X=-.215976515812456E-33,-.138949549437314E-17 R= .2E-31 RR= .1E-13
X   12 ERR=F X=-.602879500585617E-18,-.125189218252088E-17 R= .1E-31 RR= .9E-14
X   13 ERR=F X=-.602879500585617E-18, .125189218252088E-17 R= .1E-31 RR= .9E-14
X   14 ERR=F X=-.108635132224840E-17,-.866336270470311E-18 R= .1E-31 RR= .9E-14
X   15 ERR=F X=-.108635132224840E-17, .866336270470311E-18 R= .1E-31 RR= .9E-14
X   16 ERR=F X=-.135465794131525E-17, .309191835136001E-18 R= .1E-31 RR= .1E-13
X   17 ERR=F X=-.135465794131525E-17,-.309191835136001E-18 R= .1E-31 RR= .1E-13
X   18 ERR=F X=-.203638095000176E+27,-.464158883361278E+42 R= .8E+28 RR= .2E-13
X   19 ERR=F X=-.401973384383085E+42, .232079441680639E+42 R= .5E+28 RR= .1E-13
X   20 ERR=F X=-.401973384383085E+42,-.232079441680639E+42 R= .5E+28 RR= .1E-13
X  ITERATIONS = 7
END_OF_FILE
if test 1597 -ne `wc -c <'a2.res'`; then
    echo shar: \"'a2.res'\" unpacked with wrong size!
fi
# end of 'a2.res'
fi
if test -f 'a3' -a "${1}" != "-c" ; then 
  echo shar: Will not clobber existing file \"'a3'\"
else
echo shar: Extracting \"'a3'\" \(92 characters\)
sed "s/^X//" >'a3' <<'END_OF_FILE'
X20
X1 0 
X0 0
X0 0
X0 0
X0 0
X1 0
X0 0
X0 0
X0 0
X0 0
X0 0
X0 0
X0 0
X0 0
X1d300 0
X0 0
X0 0
X0 0
X0 0
X0 0
X1 0
END_OF_FILE
if test 92 -ne `wc -c <'a3'`; then
    echo shar: \"'a3'\" unpacked with wrong size!
fi
# end of 'a3'
fi
if test -f 'a3.res' -a "${1}" != "-c" ; then 
  echo shar: Will not clobber existing file \"'a3.res'\"
else
echo shar: Extracting \"'a3.res'\" \(1597 characters\)
sed "s/^X//" >'a3.res' <<'END_OF_FILE'
X    1 ERR=F X= .866025403784439E+50, .500000000000000E+50 R= .1E+37 RR= .1E-13
X    2 ERR=F X= .866025403784439E+50,-.500000000000000E+50 R= .1E+37 RR= .1E-13
X    3 ERR=F X= .236118324143482E+22, .100000000000000E+51 R= .1E+37 RR= .1E-13
X    4 ERR=F X= .363413516320872E-21, .829467636054173E-22 R= .4E-35 RR= .1E-13
X    5 ERR=F X= .363413516320872E-21,-.829467636054173E-22 R= .4E-35 RR= .1E-13
X    6 ERR=F X= .291435012439235E-21,-.232411667008902E-21 R= .4E-35 RR= .9E-14
X    7 ERR=F X= .291435012439235E-21, .232411667008902E-21 R= .4E-35 RR= .9E-14
X    8 ERR=F X= .161734230128138E-21,-.335844589419232E-21 R= .3E-35 RR= .9E-14
X    9 ERR=F X= .161734230128138E-21, .335844589419232E-21 R= .3E-35 RR= .9E-14
X   10 ERR=F X= .000000000000000E+01,-.100000000000000E+51 R= .1E+37 RR= .1E-13
X   11 ERR=F X=-.855284707229503E-49, .372759372031494E-21 R= .3E-35 RR= .9E-14
X   12 ERR=F X=-.579395884979276E-37,-.372759372031494E-21 R= .4E-35 RR= .1E-13
X   13 ERR=F X=-.161734230128138E-21, .335844589419232E-21 R= .3E-35 RR= .9E-14
X   14 ERR=F X=-.161734230128138E-21,-.335844589419232E-21 R= .3E-35 RR= .9E-14
X   15 ERR=F X=-.291435012439235E-21,-.232411667008902E-21 R= .4E-35 RR= .9E-14
X   16 ERR=F X=-.291435012439235E-21, .232411667008902E-21 R= .4E-35 RR= .9E-14
X   17 ERR=F X=-.363413516320872E-21,-.829467636054173E-22 R= .4E-35 RR= .1E-13
X   18 ERR=F X=-.363413516320872E-21, .829467636054173E-22 R= .4E-35 RR= .1E-13
X   19 ERR=F X=-.866025403784439E+50,-.500000000000000E+50 R= .1E+37 RR= .1E-13
X   20 ERR=F X=-.866025403784439E+50, .500000000000000E+50 R= .1E+37 RR= .1E-13
X  ITERATIONS = 7
END_OF_FILE
if test 1597 -ne `wc -c <'a3.res'`; then
    echo shar: \"'a3.res'\" unpacked with wrong size!
fi
# end of 'a3.res'
fi
if test -f 'a4' -a "${1}" != "-c" ; then 
  echo shar: Will not clobber existing file \"'a4'\"
else
echo shar: Extracting \"'a4'\" \(95 characters\)
sed "s/^X//" >'a4' <<'END_OF_FILE'
X20
X1d-10 0 
X1d10 0
X0 0
X0 0
X0 0
X0 0
X0 0
X0 0
X0 0
X0 0
X0 0
X1 0
X0 0
X0 0
X0 0
X0 0
X0 0
X0 0
X0 0
X0 0
X1 0
END_OF_FILE
if test 95 -ne `wc -c <'a4'`; then
    echo shar: \"'a4'\" unpacked with wrong size!
fi
# end of 'a4'
fi
if test -f 'a4.res' -a "${1}" != "-c" ; then 
  echo shar: Will not clobber existing file \"'a4.res'\"
else
echo shar: Extracting \"'a4.res'\" \(1597 characters\)
sed "s/^X//" >'a4.res' <<'END_OF_FILE'
X    1 ERR=F X= .331399394835854E+01,-.553011056370842E+00 R= .3E-13 RR= .1E-13
X    2 ERR=F X= .331399394835854E+01, .553011056370842E+00 R= .3E-13 RR= .1E-13
X    3 ERR=F X= .295487418688552E+01,-.159909436972584E+01 R= .3E-13 RR= .1E-13
X    4 ERR=F X= .295487418688552E+01, .159909436972584E+01 R= .3E-13 RR= .1E-13
X    5 ERR=F X= .227553994362799E+01, .247189970118315E+01 R= .4E-13 RR= .1E-13
X    6 ERR=F X= .227553994362799E+01,-.247189970118315E+01 R= .3E-13 RR= .1E-13
X    7 ERR=F X= .134962683036687E+01,-.307683250248579E+01 R= .4E-13 RR= .1E-13
X    8 ERR=F X= .134962683036687E+01, .307683250248579E+01 R= .3E-13 RR= .1E-13
X    9 ERR=F X= .277449037144209E+00,-.334834081257857E+01 R= .4E-13 RR= .1E-13
X   10 ERR=F X= .277449037144209E+00, .334834081257857E+01 R= .4E-13 RR= .1E-13
X   11 ERR=F X=-.100000000000000E-19, .000000000000000E+01 R= .1E-33 RR= .1E-13
X   12 ERR=F X=-.824785326692249E+00,-.325701170853473E+01 R= .4E-13 RR= .1E-13
X   13 ERR=F X=-.824785326692249E+00, .325701170853473E+01 R= .3E-13 RR= .1E-13
X   14 ERR=F X=-.183764615564275E+01,-.281272401209743E+01 R= .3E-13 RR= .9E-14
X   15 ERR=F X=-.183764615564275E+01, .281272401209743E+01 R= .3E-13 RR= .9E-14
X   16 ERR=F X=-.265137048674462E+01,-.206364581727879E+01 R= .3E-13 RR= .9E-14
X   17 ERR=F X=-.265137048674462E+01, .206364581727879E+01 R= .3E-13 RR= .9E-14
X   18 ERR=F X=-.317777121350687E+01, .109092967149114E+01 R= .4E-13 RR= .1E-13
X   19 ERR=F X=-.317777121350687E+01,-.109092967149114E+01 R= .4E-13 RR= .1E-13
X   20 ERR=F X=-.335982152759328E+01, .000000000000000E+01 R= .3E-13 RR= .9E-14
X  ITERATIONS = 5
END_OF_FILE
if test 1597 -ne `wc -c <'a4.res'`; then
    echo shar: \"'a4.res'\" unpacked with wrong size!
fi
# end of 'a4.res'
fi
if test -f 'b1' -a "${1}" != "-c" ; then 
  echo shar: Will not clobber existing file \"'b1'\"
else
echo shar: Extracting \"'b1'\" \(97 characters\)
sed "s/^X//" >'b1' <<'END_OF_FILE'
X20
X1d-200 0 
X1d200 0
X0 0
X0 0
X0 0
X0 0
X0 0
X0 0
X0 0
X0 0
X0 0
X1 0
X0 0
X0 0
X0 0
X0 0
X0 0
X0 0
X0 0
X0 0
X1 0
END_OF_FILE
if test 97 -ne `wc -c <'b1'`; then
    echo shar: \"'b1'\" unpacked with wrong size!
fi
# end of 'b1'
fi
if test -f 'b1.res' -a "${1}" != "-c" ; then 
  echo shar: Will not clobber existing file \"'b1.res'\"
else
echo shar: Extracting \"'b1.res'\" \(1720 characters\)
sed "s/^X//" >'b1.res' <<'END_OF_FILE'
X WARNING:  1 ZERO(S) ARE TOO SMALL TO BE
X REPRESENTED AS COMPLEX*16, THEY ARE SET 0
X THE CORRESPONDING RADII ARE SET TO -1
X    1 ERR=F X= .331399474405517E+11,-.553007914248597E+10 R= .3E-03 RR= .9E-14
X    2 ERR=F X= .331399474405517E+11, .553007914248597E+10 R= .3E-03 RR= .9E-14
X    3 ERR=F X= .295487199161016E+11,-.159909675443505E+11 R= .3E-03 RR= .1E-13
X    4 ERR=F X= .295487199161016E+11, .159909675443505E+11 R= .3E-03 RR= .1E-13
X    5 ERR=F X= .227554300931118E+11, .247189864873580E+11 R= .4E-03 RR= .1E-13
X    6 ERR=F X= .227554300931118E+11,-.247189864873580E+11 R= .3E-03 RR= .9E-14
X    7 ERR=F X= .134962363326558E+11,-.307683196898659E+11 R= .3E-03 RR= .9E-14
X    8 ERR=F X= .134962363326558E+11, .307683196898659E+11 R= .3E-03 RR= .9E-14
X    9 ERR=F X= .277451594987288E+10, .334834280343066E+11 R= .4E-03 RR= .1E-13
X   10 ERR=F X= .277451594987288E+10,-.334834280343066E+11 R= .3E-03 RR= .1E-13
X   11 ERR=F X= .000000000000000E+01, .000000000000000E+01 R=-.1E+01 RR=-.1E+01
X   12 ERR=F X=-.824786628712939E+10, .325700874023132E+11 R= .4E-03 RR= .1E-13
X   13 ERR=F X=-.824786628712939E+10,-.325700874023132E+11 R= .4E-03 RR= .1E-13
X   14 ERR=F X=-.183764642330896E+11,-.281272724233024E+11 R= .4E-03 RR= .1E-13
X   15 ERR=F X=-.183764642330896E+11, .281272724233024E+11 R= .3E-03 RR= .1E-13
X   16 ERR=F X=-.265136871391730E+11,-.206364310376271E+11 R= .3E-03 RR= .1E-13
X   17 ERR=F X=-.265136871391730E+11, .206364310376271E+11 R= .4E-03 RR= .1E-13
X   18 ERR=F X=-.317777406414828E+11, .109093121418053E+11 R= .3E-03 RR= .1E-13
X   19 ERR=F X=-.317777406414828E+11,-.109093121418053E+11 R= .3E-03 RR= .1E-13
X   20 ERR=F X=-.335981828628378E+11, .346944695195361E-17 R= .4E-03 RR= .1E-13
X  ITERATIONS = 5
END_OF_FILE
if test 1720 -ne `wc -c <'b1.res'`; then
    echo shar: \"'b1.res'\" unpacked with wrong size!
fi
# end of 'b1.res'
fi
if test -f 'b2' -a "${1}" != "-c" ; then 
  echo shar: Will not clobber existing file \"'b2'\"
else
echo shar: Extracting \"'b2'\" \(97 characters\)
sed "s/^X//" >'b2' <<'END_OF_FILE'
X20
X1d-250 0 
X1d250 0
X0 0
X0 0
X0 0
X0 0
X0 0
X0 0
X0 0
X0 0
X0 0
X1 0
X0 0
X0 0
X0 0
X0 0
X0 0
X0 0
X0 0
X0 0
X1 0
END_OF_FILE
if test 97 -ne `wc -c <'b2'`; then
    echo shar: \"'b2'\" unpacked with wrong size!
fi
# end of 'b2'
fi
if test -f 'b2.res' -a "${1}" != "-c" ; then 
  echo shar: Will not clobber existing file \"'b2.res'\"
else
echo shar: Extracting \"'b2.res'\" \(1720 characters\)
sed "s/^X//" >'b2.res' <<'END_OF_FILE'
X WARNING:  1 ZERO(S) ARE TOO SMALL TO BE
X REPRESENTED AS COMPLEX*16, THEY ARE SET 0
X THE CORRESPONDING RADII ARE SET TO -1
X    1 ERR=F X= .141883130669092E+14,-.236761070002075E+13 R= .1E+00 RR= .1E-13
X    2 ERR=F X= .141883130669092E+14, .236761070002075E+13 R= .1E+00 RR= .1E-13
X    3 ERR=F X= .126507891917491E+14,-.684626474344983E+13 R= .1E+00 RR= .1E-13
X    4 ERR=F X= .126507891917491E+14, .684626474344983E+13 R= .1E+00 RR= .1E-13
X    5 ERR=F X= .974235601044340E+13,-.105830197711833E+14 R= .1E+00 RR= .1E-13
X    6 ERR=F X= .974235601044340E+13, .105830197711833E+14 R= .1E+00 RR= .1E-13
X    7 ERR=F X= .577818738717729E+13,-.131729403942379E+14 R= .1E+00 RR= .1E-13
X    8 ERR=F X= .577818738717729E+13, .131729403942379E+14 R= .1E+00 RR= .1E-13
X    9 ERR=F X= .118786250269545E+13,-.143353685263466E+14 R= .1E+00 RR= .9E-14
X   10 ERR=F X= .118786250269545E+13, .143353685263466E+14 R= .1E+00 RR= .9E-14
X   11 ERR=F X= .000000000000000E+01, .000000000000000E+01 R=-.1E+01 RR=-.1E+01
X   12 ERR=F X=-.353118571553925E+13,-.139443370424646E+14 R= .1E+00 RR= .9E-14
X   13 ERR=F X=-.353118571553925E+13, .139443370424646E+14 R= .1E+00 RR= .9E-14
X   14 ERR=F X=-.786757516950348E+13,-.120422202713491E+14 R= .1E+00 RR= .9E-14
X   15 ERR=F X=-.786757516950348E+13, .120422202713491E+14 R= .1E+00 RR= .9E-14
X   16 ERR=F X=-.113513907758451E+14,-.883514207953315E+13 R= .1E+00 RR= .9E-14
X   17 ERR=F X=-.113513907758451E+14, .883514207953315E+13 R= .1E+00 RR= .9E-14
X   18 ERR=F X=-.136051070566482E+14, .467063915204540E+13 R= .1E+00 RR= .9E-14
X   19 ERR=F X=-.136051070566482E+14,-.467063915204540E+13 R= .1E+00 RR= .9E-14
X   20 ERR=F X=-.143844988828766E+14,-.355271367880050E-14 R= .1E+00 RR= .1E-13
X  ITERATIONS = 5
END_OF_FILE
if test 1720 -ne `wc -c <'b2.res'`; then
    echo shar: \"'b2.res'\" unpacked with wrong size!
fi
# end of 'b2.res'
fi
if test -f 'b3' -a "${1}" != "-c" ; then 
  echo shar: Will not clobber existing file \"'b3'\"
else
echo shar: Extracting \"'b3'\" \(97 characters\)
sed "s/^X//" >'b3' <<'END_OF_FILE'
X20
X1d-300 0 
X1d300 0
X0 0
X0 0
X0 0
X0 0
X0 0
X0 0
X0 0
X0 0
X0 0
X1 0
X0 0
X0 0
X0 0
X0 0
X0 0
X0 0
X0 0
X0 0
X1 0
END_OF_FILE
if test 97 -ne `wc -c <'b3'`; then
    echo shar: \"'b3'\" unpacked with wrong size!
fi
# end of 'b3'
fi
if test -f 'b3.res' -a "${1}" != "-c" ; then 
  echo shar: Will not clobber existing file \"'b3.res'\"
else
echo shar: Extracting \"'b3.res'\" \(1720 characters\)
sed "s/^X//" >'b3.res' <<'END_OF_FILE'
X WARNING:  1 ZERO(S) ARE TOO SMALL TO BE
X REPRESENTED AS COMPLEX*16, THEY ARE SET 0
X THE CORRESPONDING RADII ARE SET TO -1
X    1 ERR=F X= .607448844165321E+16, .101365283975536E+16 R= .6E+02 RR= .1E-13
X    2 ERR=F X= .607448844165321E+16,-.101365283975536E+16 R= .7E+02 RR= .1E-13
X    3 ERR=F X= .541622336360044E+16, .293111350563420E+16 R= .1E+03 RR= .2E-13
X    4 ERR=F X= .541622336360044E+16,-.293111350563421E+16 R= .7E+02 RR= .1E-13
X    5 ERR=F X= .417102644273699E+16,-.453094254226549E+16 R= .6E+02 RR= .1E-13
X    6 ERR=F X= .417102644273699E+16, .453094254226549E+16 R= .6E+02 RR= .1E-13
X    7 ERR=F X= .247383408665939E+16,-.563977364962501E+16 R= .6E+02 RR= .1E-13
X    8 ERR=F X= .247383408665939E+16, .563977364962501E+16 R= .6E+02 RR= .1E-13
X    9 ERR=F X= .508563421801392E+15,-.613744777194300E+16 R= .6E+02 RR= .1E-13
X   10 ERR=F X= .508563421801392E+15, .613744777194300E+16 R= .6E+02 RR= .1E-13
X   11 ERR=F X= .000000000000000E+01, .000000000000000E+01 R=-.1E+01 RR=-.1E+01
X   12 ERR=F X=-.151181798098333E+16, .597003419585667E+16 R= .7E+02 RR= .1E-13
X   13 ERR=F X=-.151181798098333E+16,-.597003419585667E+16 R= .7E+02 RR= .1E-13
X   14 ERR=F X=-.336837044725555E+16, .515567478002424E+16 R= .7E+02 RR= .1E-13
X   15 ERR=F X=-.336837044725555E+16,-.515567478002424E+16 R= .7E+02 RR= .1E-13
X   16 ERR=F X=-.485990770991502E+16,-.378261800323943E+16 R= .6E+02 RR= .1E-13
X   17 ERR=F X=-.485990770991502E+16, .378261800323943E+16 R= .7E+02 RR= .1E-13
X   18 ERR=F X=-.582479856296739E+16, .199965587243793E+16 R= .7E+02 RR= .1E-13
X   19 ERR=F X=-.582479856296739E+16,-.199965587243793E+16 R= .7E+02 RR= .1E-13
X   20 ERR=F X=-.615848211066026E+16,-.181898940354586E-11 R= .6E+02 RR= .9E-14
X  ITERATIONS = 5
END_OF_FILE
if test 1720 -ne `wc -c <'b3.res'`; then
    echo shar: \"'b3.res'\" unpacked with wrong size!
fi
# end of 'b3.res'
fi
if test -f 'c1' -a "${1}" != "-c" ; then 
  echo shar: Will not clobber existing file \"'c1'\"
else
echo shar: Extracting \"'c1'\" \(101 characters\)
sed "s/^X//" >'c1' <<'END_OF_FILE'
X20
X1d200 0 
X0 0
X0 0
X0 0
X0 0
X0 0
X0 0
X0 0
X0 0
X0 0
X0 0
X0 0
X0 0
X0 0
X0 0
X0 0
X0 0
X0 0
X0 0
X1d200 0
X1d-200 0
END_OF_FILE
if test 101 -ne `wc -c <'c1'`; then
    echo shar: \"'c1'\" unpacked with wrong size!
fi
# end of 'c1'
fi
if test -f 'c1.res' -a "${1}" != "-c" ; then 
  echo shar: Will not clobber existing file \"'c1.res'\"
else
echo shar: Extracting \"'c1.res'\" \(1703 characters\)
sed "s/^X//" >'c1.res' <<'END_OF_FILE'
X WARNING:  1 ZERO(S) ARE TOO BIG TO BE
X REPRESENTED AS COMPLEX*16,
X THE CORRESPONDING RADII ARE SET TO -1
X    1 ERR=F X= .949782283767209+308, .152630738076333+309 R=-.1E+01 RR=-.1E+01
X    2 ERR=F X= .986361303402722E+00,-.164594590280734E+00 R= .1E-13 RR= .1E-13
X    3 ERR=F X= .986361303402722E+00, .164594590280734E+00 R= .1E-13 RR= .1E-13
X    4 ERR=F X= .879473751206489E+00,-.475947393037074E+00 R= .1E-13 RR= .1E-13
X    5 ERR=F X= .879473751206489E+00, .475947393037074E+00 R= .1E-13 RR= .1E-13
X    6 ERR=F X= .677281571625741E+00,-.735723910673132E+00 R= .1E-13 RR= .1E-13
X    7 ERR=F X= .677281571625741E+00, .735723910673132E+00 R= .9E-14 RR= .9E-14
X    8 ERR=F X= .401695424652969E+00,-.915773326655057E+00 R= .1E-13 RR= .1E-13
X    9 ERR=F X= .401695424652969E+00, .915773326655057E+00 R= .1E-13 RR= .1E-13
X   10 ERR=F X= .825793454723323E-01,-.996584493006670E+00 R= .9E-14 RR= .9E-14
X   11 ERR=F X= .825793454723323E-01, .996584493006670E+00 R= .9E-14 RR= .9E-14
X   12 ERR=F X=-.245485487140799E+00,-.969400265939330E+00 R= .1E-13 RR= .1E-13
X   13 ERR=F X=-.245485487140799E+00, .969400265939330E+00 R= .1E-13 RR= .1E-13
X   14 ERR=F X=-.546948158122427E+00, .837166478262529E+00 R= .1E-13 RR= .1E-13
X   15 ERR=F X=-.546948158122427E+00,-.837166478262529E+00 R= .1E-13 RR= .1E-13
X   16 ERR=F X=-.789140509396394E+00, .614212712689668E+00 R= .9E-14 RR= .9E-14
X   17 ERR=F X=-.789140509396394E+00,-.614212712689668E+00 R= .9E-14 RR= .9E-14
X   18 ERR=F X=-.945817241700635E+00, .324699469204684E+00 R= .1E-13 RR= .1E-13
X   19 ERR=F X=-.945817241700635E+00,-.324699469204683E+00 R= .1E-13 RR= .1E-13
X   20 ERR=F X=-.100000000000000E+01, .161558713389263E-26 R= .9E-14 RR= .9E-14
X  ITERATIONS = 6
END_OF_FILE
if test 1703 -ne `wc -c <'c1.res'`; then
    echo shar: \"'c1.res'\" unpacked with wrong size!
fi
# end of 'c1.res'
fi
if test -f 'c2' -a "${1}" != "-c" ; then 
  echo shar: Will not clobber existing file \"'c2'\"
else
echo shar: Extracting \"'c2'\" \(101 characters\)
sed "s/^X//" >'c2' <<'END_OF_FILE'
X20
X1d200 0 
X0 0
X0 0
X0 0
X0 0
X0 0
X0 0
X0 0
X0 0
X0 0
X0 0
X0 0
X0 0
X0 0
X0 0
X0 0
X0 0
X0 0
X0 0
X1d100 0
X1d-200 0
END_OF_FILE
if test 101 -ne `wc -c <'c2'`; then
    echo shar: \"'c2'\" unpacked with wrong size!
fi
# end of 'c2'
fi
if test -f 'c2.res' -a "${1}" != "-c" ; then 
  echo shar: Will not clobber existing file \"'c2.res'\"
else
echo shar: Extracting \"'c2.res'\" \(1597 characters\)
sed "s/^X//" >'c2.res' <<'END_OF_FILE'
X    1 ERR=F X= .180798124304873E+06, .301698709091953E+05 R= .2E-08 RR= .1E-13
X    2 ERR=F X= .180798124304873E+06,-.301698709091953E+05 R= .2E-08 RR= .1E-13
X    3 ERR=F X= .161205842164494E+06,-.872402390807940E+05 R= .2E-08 RR= .1E-13
X    4 ERR=F X= .161205842164494E+06, .872402390807940E+05 R= .2E-08 RR= .1E-13
X    5 ERR=F X= .124144405659226E+06, .134856773676206E+06 R= .2E-08 RR= .1E-13
X    6 ERR=F X= .124144405659226E+06,-.134856773676206E+06 R= .2E-08 RR= .1E-13
X    7 ERR=F X= .736299965018537E+05, .167859484325357E+06 R= .2E-08 RR= .1E-13
X    8 ERR=F X= .736299965018537E+05,-.167859484325357E+06 R= .2E-08 RR= .1E-13
X    9 ERR=F X= .151366347363953E+05, .182672015239595E+06 R= .2E-08 RR= .1E-13
X   10 ERR=F X= .151366347363953E+05,-.182672015239595E+06 R= .2E-08 RR= .1E-13
X   11 ERR=F X=-.449970162718389E+05,-.177689198854263E+06 R= .2E-08 RR= .1E-13
X   12 ERR=F X=-.449970162718389E+05, .177689198854263E+06 R= .2E-08 RR= .1E-13
X   13 ERR=F X=-.100254542366374E+06,-.153451000641074E+06 R= .2E-08 RR= .1E-13
X   14 ERR=F X=-.100254542366374E+06, .153451000641074E+06 R= .2E-08 RR= .1E-13
X   15 ERR=F X=-.144647933186007E+06,-.112584005470823E+06 R= .2E-08 RR= .1E-13
X   16 ERR=F X=-.144647933186007E+06, .112584005470823E+06 R= .2E-08 RR= .1E-13
X   17 ERR=F X=-.173366476001000E+06, .595167863869715E+05 R= .2E-08 RR= .1E-13
X   18 ERR=F X=-.173366476001000E+06,-.595167863869715E+05 R= .2E-08 RR= .1E-13
X   19 ERR=F X=-.183298071083244E+06,-.423516473627150E-21 R= .2E-08 RR= .1E-13
X   20 ERR=F X=-.100000000000000+301, .356374811635373+276 R= .1+287 RR= .1E-13
X  ITERATIONS = 6
END_OF_FILE
if test 1597 -ne `wc -c <'c2.res'`; then
    echo shar: \"'c2.res'\" unpacked with wrong size!
fi
# end of 'c2.res'
fi
if test -f 'c3' -a "${1}" != "-c" ; then 
  echo shar: Will not clobber existing file \"'c3'\"
else
echo shar: Extracting \"'c3'\" \(97 characters\)
sed "s/^X//" >'c3' <<'END_OF_FILE'
X20
X1 0 
X1d300 0
X0 0
X0 0
X0 0
X0 0
X0 0
X0 0
X0 0
X0 0
X0 0
X0 0
X0 0
X0 0
X0 0
X0 0
X0 0
X0 0
X0 0
X0 0
X1d-300 0
END_OF_FILE
if test 97 -ne `wc -c <'c3'`; then
    echo shar: \"'c3'\" unpacked with wrong size!
fi
# end of 'c3'
fi
if test -f 'c3.res' -a "${1}" != "-c" ; then 
  echo shar: Will not clobber existing file \"'c3.res'\"
else
echo shar: Extracting \"'c3.res'\" \(1597 characters\)
sed "s/^X//" >'c3.res' <<'END_OF_FILE'
X    1 ERR=F X= .374096283993338E+32,-.624256288005333E+31 R= .3E+18 RR= .9E-14
X    2 ERR=F X= .374096283993338E+32, .624256288005333E+31 R= .3E+18 RR= .9E-14
X    3 ERR=F X= .333557146920735E+32,-.180512100887630E+32 R= .4E+18 RR= .1E-13
X    4 ERR=F X= .333557146920735E+32, .180512100887630E+32 R= .4E+18 RR= .1E-13
X    5 ERR=F X= .256871917306867E+32,-.279037285909716E+32 R= .4E+18 RR= .9E-14
X    6 ERR=F X= .256871917306867E+32, .279037285909716E+32 R= .5E+18 RR= .1E-13
X    7 ERR=F X= .152350629674334E+32,-.347324451293888E+32 R= .4E+18 RR= .9E-14
X    8 ERR=F X= .152350629674334E+32, .347324451293888E+32 R= .4E+18 RR= .1E-13
X    9 ERR=F X= .313197873530004E+31, .377973623086227E+32 R= .3E+18 RR= .9E-14
X   10 ERR=F X= .313197873530004E+31,-.377973623086227E+32 R= .3E+18 RR= .9E-14
X   11 ERR=F X=-.100000000000000-299, .000000000000000E+01 R= .2-313 RR= .2E-13
X   12 ERR=F X=-.931050399046037E+31,-.367663487952133E+32 R= .4E+18 RR= .1E-13
X   13 ERR=F X=-.931050399046037E+31, .367663487952133E+32 R= .4E+18 RR= .1E-13
X   14 ERR=F X=-.207440491415000E+32,-.317511309011616E+32 R= .4E+18 RR= .1E-13
X   15 ERR=F X=-.207440491415000E+32, .317511309011616E+32 R= .4E+18 RR= .1E-13
X   16 ERR=F X=-.299296546909715E+32, .232951853044115E+32 R= .4E+18 RR= .1E-13
X   17 ERR=F X=-.299296546909715E+32,-.232951853044115E+32 R= .4E+18 RR= .1E-13
X   18 ERR=F X=-.358719177482343E+32, .123148449178857E+32 R= .4E+18 RR= .9E-14
X   19 ERR=F X=-.358719177482343E+32,-.123148449178857E+32 R= .3E+18 RR= .9E-14
X   20 ERR=F X=-.379269019073225E+32, .214220800000000E+07 R= .3E+18 RR= .9E-14
X  ITERATIONS = 5
END_OF_FILE
if test 1597 -ne `wc -c <'c3.res'`; then
    echo shar: \"'c3.res'\" unpacked with wrong size!
fi
# end of 'c3.res'
fi
if test -f 'iv-40' -a "${1}" != "-c" ; then 
  echo shar: Will not clobber existing file \"'iv-40'\"
else
echo shar: Extracting \"'iv-40'\" \(199 characters\)
sed "s/^X//" >'iv-40' <<'END_OF_FILE'
X40
X0 1
X2 0
X3 0
X4 0
X5 0
X6 0
X7 0
X8 0
X9 0
X10 0
X11 0
X12 0
X13 0
X14 0
X15 0
X16 0
X17 0
X18 0
X19 0
X20 0
X21 0
X22 0
X23 0
X24 0
X25 0
X26 0
X27 0
X28 0
X29 0
X30 0
X31 0
X32 0
X33 0
X34 0
X35 0
X36 0
X37 0
X38 0
X39 0
X40 0
X41 0
END_OF_FILE
if test 199 -ne `wc -c <'iv-40'`; then
    echo shar: \"'iv-40'\" unpacked with wrong size!
fi
# end of 'iv-40'
fi
if test -f 'iv-40.res' -a "${1}" != "-c" ; then 
  echo shar: Will not clobber existing file \"'iv-40.res'\"
else
echo shar: Extracting \"'iv-40.res'\" \(3177 characters\)
sed "s/^X//" >'iv-40.res' <<'END_OF_FILE'
X    1 ERR=F X= .936665619919049E+00, .170329180328558E+00 R= .7E-13 RR= .8E-13
X    2 ERR=F X= .935365255755624E+00,-.171186409053095E+00 R= .1E-12 RR= .1E-12
X    3 ERR=F X= .889037692567520E+00, .308923342954917E+00 R= .2E-12 RR= .2E-12
X    4 ERR=F X= .885061587282176E+00,-.311346706695128E+00 R= .2E-12 RR= .2E-12
X    5 ERR=F X= .827012688560357E+00, .438513110180335E+00 R= .2E-12 RR= .3E-12
X    6 ERR=F X= .818992513546479E+00,-.442165553788823E+00 R= .3E-12 RR= .3E-12
X    7 ERR=F X= .748526759793279E+00, .558039943761192E+00 R= .3E-12 RR= .4E-12
X    8 ERR=F X= .735583319866396E+00,-.561995039539344E+00 R= .4E-12 RR= .4E-12
X    9 ERR=F X= .653744854105400E+00, .665142349254124E+00 R= .7E-12 RR= .7E-12
X   10 ERR=F X= .635620256878192E+00,-.668321638344507E+00 R= .5E-12 RR= .6E-12
X   11 ERR=F X= .543975682376868E+00, .757222879890228E+00 R= .5E-12 RR= .5E-12
X   12 ERR=F X= .520954612444977E+00,-.758644711204107E+00 R= .6E-12 RR= .7E-12
X   13 ERR=F X= .421323485263325E+00, .831869416225496E+00 R= .6E-12 RR= .6E-12
X   14 ERR=F X= .394092198208585E+00,-.830713786380842E+00 R= .7E-12 RR= .8E-12
X   15 ERR=F X= .288461617053692E+00, .887061532329415E+00 R= .6E-12 RR= .7E-12
X   16 ERR=F X= .257957788335064E+00,-.882653404390678E+00 R= .8E-12 RR= .9E-12
X   17 ERR=F X= .223113012984982E+00,-.321797126452792E+00 R= .2E-13 RR= .5E-13
X   18 ERR=F X= .148460324408413E+00, .921272240629710E+00 R= .7E-12 RR= .7E-12
X   19 ERR=F X= .115740141922569E+00,-.913067498903418E+00 R= .9E-12 RR= .1E-11
X   20 ERR=F X= .464880706387112E-02, .933518453004258E+00 R= .7E-12 RR= .8E-12
X   21 ERR=F X=-.292056530790398E-01,-.921113561814414E+00 R= .9E-12 RR= .1E-11
X   22 ERR=F X=-.139502162495655E+00, .923384309222814E+00 R= .8E-12 RR= .8E-12
X   23 ERR=F X=-.173434319031497E+00,-.906533286137248E+00 R= .1E-11 RR= .1E-11
X   24 ERR=F X=-.280485631065098E+00, .891026864046375E+00 R= .8E-12 RR= .9E-12
X   25 ERR=F X=-.313490325747984E+00,-.869650871519275E+00 R= .1E-11 RR= .1E-11
X   26 ERR=F X=-.414856108408314E+00, .837167477309061E+00 R= .9E-12 RR= .9E-12
X   27 ERR=F X=-.445995022122900E+00,-.811353956180147E+00 R= .1E-11 RR= .1E-11
X   28 ERR=F X=-.539320894436779E+00, .763070092598726E+00 R= .9E-12 RR= .1E-11
X   29 ERR=F X=-.567735233881568E+00,-.733063809790573E+00 R= .1E-11 RR= .1E-11
X   30 ERR=F X=-.650824946268481E+00, .670507053013805E+00 R= .1E-11 RR= .1E-11
X   31 ERR=F X=-.675747943580427E+00,-.636695876754208E+00 R= .1E-11 RR= .1E-11
X   32 ERR=F X=-.746628348980432E+00, .561713162145778E+00 R= .1E-11 RR= .1E-11
X   33 ERR=F X=-.767397719141330E+00,-.524610434610198E+00 R= .1E-11 RR= .1E-11
X   34 ERR=F X=-.824375119815620E+00, .439328949691201E+00 R= .1E-11 RR= .1E-11
X   35 ERR=F X=-.840444842699137E+00,-.399553515459951E+00 R= .1E-11 RR= .1E-11
X   36 ERR=F X=-.882152007291021E+00, .306334390379572E+00 R= .1E-11 RR= .1E-11
X   37 ERR=F X=-.893102691626112E+00,-.264588894923818E+00 R= .1E-11 RR= .1E-11
X   38 ERR=F X=-.918536036110189E+00, .165974594800320E+00 R= .1E-11 RR= .1E-11
X   39 ERR=F X=-.924083233445308E+00,-.123022479167232E+00 R= .1E-11 RR= .1E-11
X   40 ERR=F X=-.932629735207491E+00, .216792193439127E-01 R= .1E-11 RR= .1E-11
X  ITERATIONS = 8
END_OF_FILE
if test 3177 -ne `wc -c <'iv-40.res'`; then
    echo shar: \"'iv-40.res'\" unpacked with wrong size!
fi
# end of 'iv-40.res'
fi
if test -f 'vii-80' -a "${1}" != "-c" ; then 
  echo shar: Will not clobber existing file \"'vii-80'\"
else
echo shar: Extracting \"'vii-80'\" \(328 characters\)
sed "s/^X//" >'vii-80' <<'END_OF_FILE'
X80
X0 1 
X0 0
X0 0
X0 0
X0 0
X0 0
X0 0
X0 0
X0 0
X0 0
X0 0
X0 0
X0 0
X0 0
X0 0
X0 0
X0 0
X0 0
X0 0
X0 0
X0 0
X0 0
X0 0
X0 0
X0 0
X0 0
X0 0
X0 0
X0 0
X0 0
X0 0
X0 0
X0 0
X0 0
X0 0
X0 0
X0 0
X0 0
X0 0
X0 0
X0 0
X0 0
X0 0
X0 0
X0 0
X0 0
X0 0
X0 0
X0 0
X0 0
X0 0
X0 0
X0 0
X0 0
X0 0
X0 0
X0 0
X0 0
X0 0
X0 0
X0 0
X0 0
X0 0
X0 0
X0 0
X0 0
X0 0
X0 0
X0 0
X0 0
X0 0
X0 0
X0 0
X0 0
X0 0
X0 0
X0 0
X0 0
X0 0
X0 0
X1 0
END_OF_FILE
if test 328 -ne `wc -c <'vii-80'`; then
    echo shar: \"'vii-80'\" unpacked with wrong size!
fi
# end of 'vii-80'
fi
if test -f 'vii-80.res' -a "${1}" != "-c" ; then 
  echo shar: Will not clobber existing file \"'vii-80.res'\"
else
echo shar: Extracting \"'vii-80.res'\" \(6337 characters\)
sed "s/^X//" >'vii-80.res' <<'END_OF_FILE'
X    1 ERR=F X= .999807240482065E+00,-.196336924606283E-01 R= .4E-13 RR= .4E-13
X    2 ERR=F X= .998265610184716E+00, .588708036511890E-01 R= .4E-13 RR= .4E-13
X    3 ERR=F X= .995184726672197E+00,-.980171403295606E-01 R= .4E-13 RR= .4E-13
X    4 ERR=F X= .990569340443577E+00, .137012341681968E+00 R= .3E-13 RR= .3E-13
X    5 ERR=F X= .984426568089892E+00,-.175796279934355E+00 R= .4E-13 RR= .4E-13
X    6 ERR=F X= .976765881320872E+00, .214309153065051E+00 R= .4E-13 RR= .4E-13
X    7 ERR=F X= .967599092360260E+00,-.252491577015158E+00 R= .4E-13 RR= .4E-13
X    8 ERR=F X= .956940335732209E+00, .290284677254462E+00 R= .4E-13 RR= .4E-13
X    9 ERR=F X= .944806046466878E+00,-.327630179561693E+00 R= .4E-13 RR= .4E-13
X   10 ERR=F X= .931214934758804E+00, .364470499879150E+00 R= .4E-13 RR= .4E-13
X   11 ERR=F X= .916187957117136E+00,-.400748833103141E+00 R= .4E-13 RR= .4E-13
X   12 ERR=F X= .899748284052221E+00, .436409240673342E+00 R= .4E-13 RR= .4E-13
X   13 ERR=F X= .881921264348355E+00,-.471396736825998E+00 R= .4E-13 RR= .4E-13
X   14 ERR=F X= .862734385977792E+00, .505657373377985E+00 R= .4E-13 RR= .4E-13
X   15 ERR=F X= .842217233716287E+00,-.539138322911000E+00 R= .4E-13 RR= .4E-13
X   16 ERR=F X= .820401443525514E+00, .571787960227612E+00 R= .4E-13 RR= .4E-13
X   17 ERR=F X= .797320653772707E+00,-.603555941953571E+00 R= .4E-13 RR= .4E-13
X   18 ERR=F X= .773010453362737E+00, .634393284163645E+00 R= .4E-13 RR= .4E-13
X   19 ERR=F X= .747508326862597E+00,-.664252437911282E+00 R= .4E-13 RR= .4E-13
X   20 ERR=F X= .720853596702919E+00, .693087362545636E+00 R= .4E-13 RR= .4E-13
X   21 ERR=F X= .693087362545636E+00,-.720853596702919E+00 R= .4E-13 RR= .4E-13
X   22 ERR=F X= .664252437911282E+00, .747508326862597E+00 R= .4E-13 RR= .4E-13
X   23 ERR=F X= .634393284163645E+00,-.773010453362737E+00 R= .4E-13 RR= .4E-13
X   24 ERR=F X= .603555941953571E+00, .797320653772707E+00 R= .4E-13 RR= .4E-13
X   25 ERR=F X= .571787960227612E+00,-.820401443525514E+00 R= .4E-13 RR= .4E-13
X   26 ERR=F X= .539138322911000E+00, .842217233716287E+00 R= .4E-13 RR= .4E-13
X   27 ERR=F X= .505657373377985E+00,-.862734385977792E+00 R= .4E-13 RR= .4E-13
X   28 ERR=F X= .471396736825998E+00, .881921264348355E+00 R= .4E-13 RR= .4E-13
X   29 ERR=F X= .436409240673342E+00,-.899748284052222E+00 R= .4E-13 RR= .4E-13
X   30 ERR=F X= .400748833103141E+00, .916187957117136E+00 R= .4E-13 RR= .4E-13
X   31 ERR=F X= .364470499879150E+00,-.931214934758804E+00 R= .4E-13 RR= .4E-13
X   32 ERR=F X= .327630179561694E+00, .944806046466878E+00 R= .4E-13 RR= .4E-13
X   33 ERR=F X= .290284677254462E+00,-.956940335732209E+00 R= .4E-13 RR= .4E-13
X   34 ERR=F X= .252491577015158E+00, .967599092360260E+00 R= .4E-13 RR= .4E-13
X   35 ERR=F X= .214309153065051E+00,-.976765881320872E+00 R= .4E-13 RR= .4E-13
X   36 ERR=F X= .175796279934355E+00, .984426568089892E+00 R= .4E-13 RR= .4E-13
X   37 ERR=F X= .137012341681968E+00,-.990569340443577E+00 R= .3E-13 RR= .3E-13
X   38 ERR=F X= .980171403295606E-01, .995184726672197E+00 R= .4E-13 RR= .4E-13
X   39 ERR=F X= .588708036511890E-01,-.998265610184716E+00 R= .4E-13 RR= .4E-13
X   40 ERR=F X= .196336924606283E-01, .999807240482065E+00 R= .4E-13 RR= .4E-13
X   41 ERR=F X=-.196336924606283E-01,-.999807240482065E+00 R= .4E-13 RR= .4E-13
X   42 ERR=F X=-.588708036511890E-01, .998265610184716E+00 R= .4E-13 RR= .4E-13
X   43 ERR=F X=-.980171403295606E-01,-.995184726672197E+00 R= .4E-13 RR= .4E-13
X   44 ERR=F X=-.137012341681968E+00, .990569340443577E+00 R= .3E-13 RR= .3E-13
X   45 ERR=F X=-.175796279934355E+00,-.984426568089892E+00 R= .4E-13 RR= .4E-13
X   46 ERR=F X=-.214309153065051E+00, .976765881320872E+00 R= .4E-13 RR= .4E-13
X   47 ERR=F X=-.252491577015158E+00,-.967599092360260E+00 R= .4E-13 RR= .4E-13
X   48 ERR=F X=-.290284677254462E+00, .956940335732209E+00 R= .4E-13 RR= .4E-13
X   49 ERR=F X=-.327630179561693E+00,-.944806046466878E+00 R= .4E-13 RR= .4E-13
X   50 ERR=F X=-.364470499879150E+00, .931214934758804E+00 R= .4E-13 RR= .4E-13
X   51 ERR=F X=-.400748833103141E+00,-.916187957117136E+00 R= .4E-13 RR= .4E-13
X   52 ERR=F X=-.436409240673342E+00, .899748284052222E+00 R= .4E-13 RR= .4E-13
X   53 ERR=F X=-.471396736825998E+00,-.881921264348355E+00 R= .4E-13 RR= .4E-13
X   54 ERR=F X=-.505657373377985E+00, .862734385977792E+00 R= .4E-13 RR= .4E-13
X   55 ERR=F X=-.539138322911000E+00,-.842217233716287E+00 R= .4E-13 RR= .4E-13
X   56 ERR=F X=-.571787960227612E+00, .820401443525514E+00 R= .4E-13 RR= .4E-13
X   57 ERR=F X=-.603555941953571E+00,-.797320653772707E+00 R= .4E-13 RR= .4E-13
X   58 ERR=F X=-.634393284163645E+00, .773010453362737E+00 R= .4E-13 RR= .4E-13
X   59 ERR=F X=-.664252437911282E+00,-.747508326862597E+00 R= .4E-13 RR= .4E-13
X   60 ERR=F X=-.693087362545636E+00, .720853596702919E+00 R= .4E-13 RR= .4E-13
X   61 ERR=F X=-.720853596702919E+00,-.693087362545636E+00 R= .4E-13 RR= .4E-13
X   62 ERR=F X=-.747508326862597E+00, .664252437911282E+00 R= .4E-13 RR= .4E-13
X   63 ERR=F X=-.773010453362737E+00,-.634393284163645E+00 R= .4E-13 RR= .4E-13
X   64 ERR=F X=-.797320653772707E+00, .603555941953571E+00 R= .4E-13 RR= .4E-13
X   65 ERR=F X=-.820401443525514E+00,-.571787960227612E+00 R= .4E-13 RR= .4E-13
X   66 ERR=F X=-.842217233716287E+00, .539138322911000E+00 R= .4E-13 RR= .4E-13
X   67 ERR=F X=-.862734385977792E+00,-.505657373377985E+00 R= .4E-13 RR= .4E-13
X   68 ERR=F X=-.881921264348355E+00, .471396736825998E+00 R= .4E-13 RR= .4E-13
X   69 ERR=F X=-.899748284052222E+00,-.436409240673342E+00 R= .4E-13 RR= .4E-13
X   70 ERR=F X=-.916187957117136E+00, .400748833103141E+00 R= .4E-13 RR= .4E-13
X   71 ERR=F X=-.931214934758804E+00,-.364470499879150E+00 R= .4E-13 RR= .4E-13
X   72 ERR=F X=-.944806046466878E+00, .327630179561693E+00 R= .4E-13 RR= .4E-13
X   73 ERR=F X=-.956940335732209E+00,-.290284677254462E+00 R= .4E-13 RR= .4E-13
X   74 ERR=F X=-.967599092360260E+00, .252491577015158E+00 R= .4E-13 RR= .4E-13
X   75 ERR=F X=-.976765881320872E+00,-.214309153065051E+00 R= .4E-13 RR= .4E-13
X   76 ERR=F X=-.984426568089892E+00, .175796279934355E+00 R= .4E-13 RR= .4E-13
X   77 ERR=F X=-.990569340443577E+00,-.137012341681968E+00 R= .3E-13 RR= .3E-13
X   78 ERR=F X=-.995184726672197E+00, .980171403295606E-01 R= .4E-13 RR= .4E-13
X   79 ERR=F X=-.998265610184716E+00,-.588708036511890E-01 R= .4E-13 RR= .4E-13
X   80 ERR=F X=-.999807240482065E+00, .196336924606283E-01 R= .4E-13 RR= .4E-13
X  ITERATIONS = 4
END_OF_FILE
if test 6337 -ne `wc -c <'vii-80.res'`; then
    echo shar: \"'vii-80.res'\" unpacked with wrong size!
fi
# end of 'vii-80.res'
fi
echo shar: End of shell archive.
exit 0