1 F77

	AID F77 FUNCTIONS	Will give information about available
				FUNCTIONS
 
	AID F77 SUBROUTINES	Will give information about available
				SUBROUTINES
 
	AID F77 FILEIO		Will give information about FILE IO



2 FUNCTIONS
 
	Further information is available for the following functions
 
	 
	SQRT	LOG	LOG10	EXP	SIN	COS	TAN	ASIN	
	ACOS	ATAN	ATAN2	SINH	COSH	TANH	ABS	INT	
	NINT	REAL	IFIX	FLOAT	DFLOAT	CMPLX	AIMAG	CONJ	
	DPROD	MAX	MIN	DIM	MOD	SIGN	LEN	INDEX	
	ICHAR	IAND	IOR	IEOR	NOT	ISHFT	Characterrelation	
  
	typ	AID F77 FUNCTIONS xxxx	for more information on any function
 
	typ	AID F77 FUNCTLIST for an expanded list of functions
 
3 SQRT

 The SQRT function returns the square root of its argument.  The 
 result of CSQRT or CDSQRT is the principal value with the real 
 part greater than or equal to zero.  When the real part is zero, 
 the result is the principal value with the imaginary part greater 
 than or equal to zero.

 FORMAT:        Length = SQRT(a)

 EXAMPLE:       SQRT(-4.0) = i2         SQRT(0.25) = 0.5

 RESTRICTIONS:   Negative arguments must be COMPLEX,  while 
                 positive arguments can be REAL or COMPLEX, 
                 i.e., the argument of SQRT, DSQRT, or QSQRT 
                 must be greater than or equal to zero.INTEGER 
                 arguments are not allowed.

3 LOG

 The LOG function returns the natural logarithm (base e) of 
 its argument.

 FORMAT:        Answer = LOG(a)

 EXAMPLE:       LOG(1.00) = 0.0         LOG(1.0) = 2.718        

 RESTRICTIONS:   The argument of ALOG and DLOG must be greater 
                 than zero.  The argument of CLOG or CDLOG 
                 must not be (0.,0.).  INTEGER arguments are 
                 not allowed.

3 LOG10

 The LOG10 function returns the common logarithm (base 10) 
 of its argument.

 FORMAT:        Answer = LOG10(a)

 EXAMPLE:       LOG10(1.OO) = 0.0       LOG10(100) = 2.OO

 RESTRICTIONS:  The argument of ALOG10, DLOG10, QLOG10, must be 
                greater than zero.  COMPLEX  or INTEGER arguments 
                are not allowed.

3 EXP

 The EXP function returns the exponential of its argument.

 FORMAT:        Proportion = EXP(a)

 EXAMPLE:       EXP(0.O) = 1.O          EXP(1.00) =  2.718

 RESTRICTIONS:  Argument must be REAL or COMPLEX.

3 SIN

 The SIN function returns the trigonometric sine of its argument, 
 where the argument is expressed in radians.  The argument is 
 treated modulo 2*pi.

 FORMAT:        Heigth = SIN(a)

 EXAMPLE:       SIN(3.14159) = 0.0      SIN(0.77) = 0.696

 RESTRICTIONS:  The argument of SIN must be in radians.
                INTEGER arguments are not allowed.

3 COS

 The COS function returns the trigonometric cosine of its argument, 
 where the argument is expressed in radians.  The argument is 
 treated  modulo 2*pi.

 FORMAT:        Projection = COS(a)

 EXAMPLE:       COS(-3.14159) = -1.0            COS(4.77) = 0.0576

 RESTRICTIONS:  The argument of COS must be in radians.
                INTEGER arguments are not allowed.

3 TAN

 The TAN function returns the trigonometric tangent of its argument, 
 where the argument is expressed in radians.  The argument is treated 
 modulo 2*pi.

 FORMAT:        Ratio = TAN(a)

 EXAMPLE:       TAN(-3.14159) = 0.0             TAN(4.77) = -17.3

 RESTRICTIONS:  The argument of TAN must be in radians.
                INTEGER arguments are not allowed.

3 ASIN

 The ASIN function returns (in radians) the arcsine of its argument. 
 The range of the result is:  -90 .LE. result .LE. 90     (result is
 expressed in radians).

 FORMAT:        ANGLE = ASIN(a)

 EXAMPLE:       ASIN(1.0) = 1.57        ASIN(0.00) = 0.0

 RESTRICTIONS:  The absolute value of the argument of ACOS must be 
                less than or equal to 1.  INTEGER or COMPLEX 
                arguments are not allowed.

3 ACOS

 The ACOS function returns (in radians) the arccosine of its argument. 
 The range of the result is:   0 .LE. result .LE. 180  (expressed in 
 radians).

 FORMAT:        ANGLE = ACOS(a)

 EXAMPLE:       ACOS(1.0) = 0.0         ACOS(0.00) = 1.57

 RESTRICTIONS:  The absolute value of the argument of ACOS must be 
                less than or equal to 1.  INTEGER or COMPLEX
                arguments are not allowed.

3 ATAN

 The ATAN function returns (in radians) the arctangent of its argument.
 The range of the result is:    -90 < result < 90   (expressed in
 radians ).

 FORMAT:        Angle3 = ATAN(a)

 EXAMPLE:       ATAN(1.00) = 0.785      ATAN(0.00) = 0.0

 RESTRICTIONS:  INTEGER or COMPLEX values are not allowed.

3 ATAN2

 The ATAN2 function returns (in radians) the arctangent of the ratio 
 of its arguments.  If the value of the first argument is positive, 
 the result is positive.  When the value of the first argument is 
 zero the result is zero if the second argument is positive and pi 
 if the second argument is negative.  If the value of the first 
 argument is negative the result is negative.  If the value of the 
 second argument is zero, the absolute value of the result is pi/2.  
 Both arguments must not have the value zero.  The range of the 
 result for ATAN2 is:        -180 .LT. result .LE. 180  (answer is
 expressed in radians).

 FORMAT:        Angle3 = ATAN2(a,b)

 EXAMPLE:       ATAN2(4.,4.) = 0.785    ATAN2(0.0,-2.0) = 3.1
                ATAN2(-1.,0.) = -1.57   ATAN2(4.,-4.) = 0.785

 RESTRICTIONS:  Both arguments must not have the value zero.  INTEGER 
                or COMPLEX values are not allowed.


3 SINH

 The SINH function returns the hyperbolic sine of its argument.  

 FORMAT:        Solution = SINH(a)

 EXAMPLE:       SINH(1.00) = 1.18

 RESTRICTIONS:  INTEGER or COMPLEX arguments are not allowed.

3 COSH

 The COSH function returns the hyperbolic cosine of its argument.

 FORMAT:        Solution = COSH(a)

 EXAMPLE:       COSH(1.000) = 1.54      

 RESTRICTIONS:  INTEGER or COMPLEX values are not allowed.

3 TANH

 The TANH function returns the hyperbolic tangent of its argument.

 FORMAT:        Solution = TANH(a)

 EXAMPLE:       TANH(1.0) = 0.8

 RESTRICTIONS:  INTEGER or COMPLEX values are not allowed.

3 ABS

 The ABS function returns the absolute value of its argument.  (The 
 absolute value of a complex number (a,b) is the real value:
 (a**2  + b**2)**0.5      .) 

 FORMAT:        Amount = ABS(a)

 EXAMPLE:       ABS(-5.) = 5.           ABS(5.) = 5.
                ABS(0.) = 0.            ABS(3.,4.) = 5.

3 INT

 The INT, AINT functions truncate the fractional part of their 
 argument toward zero.  The functions returns INTEGER*4 values 
 if the /I4 command qualifier is in effect, INTEGER*2  values 
 if the /NOI4 qualifier is in effect. 
 
 FORMAT:        Iapprox = INT(a)

 EXAMPLE:       INT(5.634) = 5          INT(-2.99) = -2

3 NINT

 The NINT, ANINT functions return the value that is the
 nearest integer to the argument, rounding up if the fractional part
 of the argument is .5 or greater, and down otherwise.  This can be
 expressed as:  [a + .5*sign(a)]  , where "a" denotes the argument.
 The functions return INTEGER*4 values if the /I4 command qualifier 
 is in effect, INTEGER*2 values if the /NOI4 qualifier is in effect.

 FORMAT:        Iapprox = NINT(a)

 EXAMPLE:       NINT(-5.5) = -6         NINT(.4999) = 0

 RESTRICTIONS:  COMPLEX values are not allowed.

3 REAL

 The REAL function converts its argument into a REAL*4.  The function 
 provides the same effect as the implied conversion in assignment 
 statements.  The function returns a REAL*4 argument without conver-
 sion.

 FORMAT:        Xreal = REAL(a)

 EXAMPLE:       (for K=2, L=3)
                I = J*(K/L) = 0  while  J*(REAL(K)/L) = 1.
                REAL(K)/L = 0.6666      

 NOTE:          Care should be employed in using the REAL function;
                it entails conceptual subtleties.  REAL conversions are
                used primarily in subroutine calls and in forcing 
                computation in floating point.

3 IFIX

 The IFIX function takes a REAL*4 and converts it to an INTEGER.  This 
 function provides the same effect as the implied conversion in 
 assignment statements.  The function returns INTEGER*4 values if the 
 /I4 command qualifier is in effect, INTEGER*2 values if the /NOI4 
 qualifier is in effect.

 FORMAT:        Iapprox = IFIX(a)

 EXAMPLE:       IFIX(40.000) = 40

 RESTRICTIONS:  Argument must be REAL*4.

3 FLOAT

 The FLOAT function takes an INTEGER and converts it to a REAL*4.  
 This function provides the same effect as the implied conversion 
 in assignment statements.

 FORMAT:        Xreal = FLOAT(a)

 EXAMPLE:       FLOAT(4) = 4.0

 RESTRICTIONS:  Arguments must be of type INTEGER.

3 DFLOAT

 The DFLOAT function takes an INTEGER and converts it to a REAL*8.
 This function provides the same effect as the implied conversion in
 assignment statements.

 FORMAT:        Xreal = FLOAT(a)

 EXAMPLE:       FLOAT(4) = 4.0

 RESTRICTIONS:  Arguments must be of type INTEGER.

3 CMPLX

 The CMPLX function returns its argument of any type as a COMPLEX*8.
 When the function has only one argument, this argument is converted 
 the real part of a complex value, and zero is assigned to the 
 imaginary part; when there are two arguments (not complex), a complex
 value is produced by conversion of the first argument into the real 
 part of the value, the second argument into the imaginary part.

 FORMAT:        Xcompl = CMPLX(a)

 EXAMPLE:       CMPLX(4) = (4.,0.)        CMPLX(4,2) = 4 + i2

3 AIMAG

 The AIMAG function returns the imaginary part of its complex argument,

 as a REAL*4.  (DIMAG returns the argument as a REAL*8.)

 FORMAT:        Xreal = AIMAG(a)        (where "a" is a complex number)

 EXAMPLE:       AIMAG(4.,2.) = 2.

 RESTRICTIONS:  Argument must be a COMPLEX*8 or a COMPLEX*16.

3 CONJ

 The CONJ function returns the complex conjugate of its argument.
 (The complex conjugate of a complex number  a+ib  is  a-ib .)

 FORMAT:        Xstar = CONJ(a)         (where "a" is a complex number)

 EXAMPLE:       CONJ(2.0, 4.0) = (2.0, -4.0)

 RESTRICTIONS:  Argument must be a COMPLEX.

3 DPROD

 The DPROD function takes two REAL*4 arguments, and returns their 
 product as a REAL*8.

 FORMAT:        Area= DPROD(a1,a2)

 EXAMPLE:       DPROD(2.,4.) = 8.

 RESTRICTIONS:  Arguments are of type REAL*4.

3 MAX

 The MAX function returns the maximum value from among the argument
 list.

 FORMAT:        Xlarge = MAX(a1,a2,...aN)

 EXAMPLE:       MAX(5.,7.,0.,4.) = 7.

 RESTRICTIONS:  There must be at least two arguments.  COMPLEX 
                arguments are not allowed. 

3 MIN

 The MIN function returns the minimum value from among the argument
 list.

 FORMAT:        Xsmall = MIN(a1,a2,...aN)

 EXAMPLE:       MIN(5.,7.,1.,4.) = 1.

 RESTRICTIONS:  There must be at least two arguments.  COMPLEX 
                arguments are not allowed. 

3 DIM

 The DIM function returns the first of two arguments minus the 
 minimum of the two arguments, i.e., the function returns  
 a1-(min(a1,a2)) , where a1 and a2 denote the respective 1st and 
 2nd arguments.

 FORMAT:        Xdiff = DIM(a1,a2)

 EXAMPLE:       DIM(5.,2.) = 3.         DIM(2.,5.) = 0.

 RESTRICTIONS:  COMPLEX arguments are not allowed.

3 MOD

 The MOD function returns the remainder when the first argument is 
 divided by the second i.e., the function returns  a1-a2*[a1/a2] 
 where a1 and a2 denote the respective 1st and 2nd arguments.

 FORMAT:        Xwhole = MOD(a1,a2)

 EXAMPLE:       MOD(8,3) = 2            MOD(8.,4.) = 0.

 RESTRICTIONS:  COMPLEX arguments are not allowed.

3 SIGN

 The SIGN function transfers the sign of the second argument to the 
 absolute value of the first argument.

 FORMAT:        Xtrans = SIGN(a1, a2)

 EXAMPLE:       SIGN(5,-2)=-5      SIGN(-5,-2)=-5       SIGN(-5,2) = 5

 RESTRICTIONS:  COMPLEX arguments are not allowed.

3 LEN
 The LEN function returns the length of the argument, a character 
 expression.  The function will return INTEGER*4 values if the /I4 
 command qualifier is in effect, INTEGER*2 values if the /NOI4 
 qualifier is in effect.  The value returned indicates how many bytes
 there are in the function.

 FORMAT:        Xlen = LEN(c)
                        (where "c" is a character expression.)

 EXAMPLE:       LEN(NAMES(2,3)(1:7)) = 7

 RESTRICTIONS:  Argument must be of type CHARACTER.

3 INDEX

 The INDEX function searches for a substring (first argument) 
 in a specified character string (second argument), and, if it 
 finds the substring, returns the substring's starting 
 position.  If the second argument occurs more than once in 
 the first argument, the starting position of the first 
 (leftmost) occurence is returned.  If the second argument 
 does not occur in the first argument, the value zero is 
 returned.  The function returns INTEGER*4 values if the /I4 
 command qualifier is in effect, INTEGER*2 values if the /NOI4 
 qualifier is in effect.

 FORMAT:        Xorder = INDEX(c1, c2)
                        (where c1 is a character expression 
                         specifying the string to be  searched 
                         for the substring specified by c2, and
                         c2 is a character expression specifying
                         the substring for which the starting 
                         location is to be determined)
                
 RESTRICTIONS:  Arguments must be of type CHARACTER.

3 ICHAR

 The ICHAR function converts a character expression to its equivalent 
 ASCII code and returns the ASCII  value.  If the character to be
 converted is longer than one byte, only the value of the first byte
 is returned; the remainder is ignored.  
        
 FORMAT:        ICHAR(c)
                        (where "c" is the character to be converted to
                         an ASCII code)

 RESTRICTIONS:  Argument must be of type CHARACTER.

3 IAND
 
 The IAND function (bitwise AND) performs a logical AND on 
 corresponding bits, i.e., corresponding bits of answer will
 be TRUE if and only if corresponding bits of both arguments
 are TRUE.
                                                    76|543|210 (bit #)
 FORMAT:        FORM = IAND(x,y)                    __|___|___
                                                      |   |  
 EXAMPLE:       IAND('134'O , '021'O) = '020'O      01|011|100 ('134'O)
                                                    00|010|001 ('021'O)
                  (Only bit 4 is set                __|___|___
                   to 1 in both arguments;          00|010|000 ('020'O)
                   therefore the result                  
                   will contain a single
                   "1", as bit #4.
                   In base 10, 92 and 17
                   have resulted in 16.  )

 RESTRICTIONS:  Arguments must be of type INTEGER*2 or INTEGER*4,
                containing up to 16 or 32 bits.  However, to
                facilitate display, the example shows only the first 
                eight bits of each integer.

3 IOR
 
 The IOR function (bitwise OR) performs a logical OR on corresponding
 bits, i.e., corresponding bits will be TRUE if either, or both 
 corresponding bits of both arguments are TRUE.

 FORMAT:        FORM = IOR(x,y)                     76|543|210 (bit #)
                                                    __|___|___
 EXAMPLE:       IOR('134'O,'021'O) = '135'O         01|011|100 ('134'O)
                                                    00|010|001 ('021'O)
                (Bits 1,5,7, of the                 __|___|___
                 result remain 0.In                 01|011|101 ('135'O)
                 base 10, 92 and 17
                 have resulted in 93.)

 RESTRICTIONS:  Arguments must be of type INTEGER*2 or INTEGER*4, 
                containing up to 16 or 32 bits.  However, to facilitate 
                display, the example shows only the first eight bits of
                each integer.

3 IEOR
 
 The IEOR function (bitwise exclusive OR) performs a logical exclusive
 OR on corresponding bits, i.e., corresponding bits will be TRUE if 
 either, but not both, corresponding bits of both arguments are TRUE.

                                                    76|543|210 (bit #)
 FORMAT:        FORM = IEOR(x,y)                    __|___|___
                                                      |   |  
 EXAMPLE:       IEOR('134'O , '021'O) = '115'O      01|011|100 ('134'O)
                                                    00|010|001 ('021'O)
                (Note the fourth bit of             __|___|___
                 result is 0.  In base 10,          01|001|101 ('115'O)
                 92 and 17 have resulted
                 in 77.)

 RESTRICTIONS:  Arguments must be of type INTEGER*2 or INTEGER*4, con-
                taining up to 16 or 32 bits.  However, to facilitate
                display, the example shows only the first eight bits 
                of each integer.

3 NOT
 
 The NOT function (bitwise complement) complements each bit of its 
 argument.  It will therefore return a negative result from a 
 positive argument.

 FORMAT:        FORM = NOT(x)

 EXAMPLE:       NOT('000167'O)='37777777610'O
                (In base 10, 119 has been changed to -120.)

                NOT('112345'O)='37777665432'O
                (In base 10, -38117 has been changed to 38118.)

                NOT('0'O) = '37777777777'O
                (In base 10, 0 has been changed to -1.)

 RESTRICTIONS:  Arguments must be of type INTEGER.

3 ISHFT
 
 The ISHFT function (bitwise shift) logically shifts its first 
 argument left an amount denoted by the second argument.

                                                   76|543|210 (bit #)
 FORMAT:        FORM = ISHFT(x,y)                  __|___|___
                                                     |   |  
 EXAMPLE:       ISHFT('334'O,-2) = '067'O          11|011|100 ('334'O)
                                                   __|___|___
                (Bit #5 becomes bit #7,            00|110|111 ('067'O)
                 bit #4 becomes bit #6,
                 and so on.  The first two bits become zero, while the 
                 last two are "pushed off".  In base 10, 92 has been 
                 changed to 55.)

 RESTRICTIONS:  Arguments must be of type INTEGER*2 or INTEGER*4,
                containing up to 16 or 32 bits.  However, to facilitate
                display, the example shows only the first eight bits of
                each integer.

3 Characterrelationals

ASCII collating sequence.  The four lexical comparison functions 
provided are:

        * LLT, where LLT(x,y) is equivalent to (x .LT. y)
        * LLE, where LLE(x,y) is equivalent to (x .LE. y)
        * LGT, where LGT(x,y) is equivalent to (x .GT. y)
        * LGE, where LGE(x,y) is equivalent to (x .GE. y)

 FORMAT:        func(c,c)
                        (where "func" is one of the symbolic names:
                         LLT, LLE, LGT, or LGE; and "c" is a 
                         character expression)

 EXAMPLE:       CHARACTER*10 CH2
                IF (LGT(CH2,'SMITH')) STOP

2 FUNCTLIST


        SQRT    Returns the square root of its argument.

        LOG     Returns the natural logarithm (base e) of its argument.

        LOG10   Returns the common logarithm (base 10) of its argument.

        SIN     Returns the trigonometric sine of its argument, where
                argument is expressed in radians.

        COS     Returns the trigonometric cosine of its argument where
                argument is expressed in radians.

        TAN     Returns the trigonometric tangent of its argument where
                argument is expressed in radians.

        ASIN    Returns (in radians) the arcsine of its argument.

        ACOS    Returns (in radians) the arccosine of its argument.
        
        ATAN    Returns (in radians) the arctangent of its argument.

        SINH    Returns the hyperbolic sine of its argument.

        COSH    Returns the hyperbolic cosine of its argument.

        TANH    Returns the hyperbolic tangent of its argument.

        ABS     Returns the absolute value of its argument.

        INT     Returns the largest integer (truncating to zero).

        NINT    Returns the nearest integer.

        REAL    Converts argument into REAL*4.

        DBLE    Converts argument into REAL*8.

        IFIX    Converts REAL*4 argument into INTEGER.

        FLOAT   Converts INTEGER argument into REAL*4.

        DFLOAT  Converts INTEGER argument into REAL*8.

        CMPLX   Converts argument(s) into COMPLEX*8.

        AIMAG   Returns real part of COMPLEX argument as a REAL*8.

        CONJ    Returns complex conjugate of COMPLEX argument.

        DPROD   Returns REAL*8 product of REAL*4 arguments.

        MAX     Returns the maximum value from among the argument 
                list.

        MIN     Returns the minimum value among the argument list.

        DIM     Returns the first argument minus the minimum of the
                two arguments.

        MOD     Returns the remainder when the first argument is
                divided by the second.

        SIGN    Returns the absolute value of the first argument,
                giving it the sign of the second.

        IAND    Bitwise AND.  Performs a logical AND on corresponding 
                bits.

        IOR     Bitwise OR.  Performs an inclusive OR on corresponding
                bits.

        IEOR    Bitwise exclusive OR.  Performs an exclusive OR on
                corresponding bits.

        NOT     Bitwise Complement.  Complements each bit.

        ISHFT   Bitwise shift.  Logically shifts first argument by 
                an amount denoted by the second argument.


        LEN     Returns length of the character expression.

        INDEX   Returns the position of the second argument substring
                in the first argument substring.

        ICHAR   Returns the ASCII value of the argument.

2 SUBROUTINES

  The PDP-11 FORTRAN system provides subroutines you call in the 
  same manner as user-written subroutines.
 

 
	Further information is available for the following subroutines
 
	 
	DATE	IDATE	ERRSNS	EXIT	SECNDS	TIME	RAN	
  
	typ	AID F77 SUBROUTINES xxx	for more information on any subroutine
	typ	AID F77 SUBLIST for an expanded list of subroutines

3 DATE

  The DATE subroutine obtains the current date as set within 
  the system. The call to DATE has the form:

        CALL DATE(buf)
                (Where "buf" is a 9-byte variable, array 
                 element, or character substring.)

  The date is returned as a 9-byte ASCII character string of 
  the form:

        dd-mm-yy
                (Where "dd" is the 2-digit date, "mmm" is the 
                 3-letter month specification, and "yy" is the 
                 last two digits of the year.)

3 IDATE

  The IDATE subroutine returns three integer values representing the
  current month, day, and year.  The call to IDATE has the form:

        CALL IDATE(i,j,k)
                (If the current date were October 9, 1985, the values
                 of the integer variables upon return would be:
                        i = 10
                        j =  9
                        k = 85  .)

3 ERRSNS

  The ERRSNS subroutine returns information about the most recent
  error that has occured during program execution.  The call to 
  ERRSNS has the form:

        CALL ERRSNS(fnum, rmssts, rmsstv, iunit, condval)

  where:        "fnum" is an integer variable or array element 
                into which is stored the most recent FORTRAN 
                run-time error number.  (See VAX-11 FORTRAN 
                USER'S GUIDE for listing of error numbers).  A
                zero is returned if no error has occurred
                since the start of the execution.
                
                "rmssts" is an integer variable or array element
                into which is stored the RMS completion status
                code (STS), if the last error was an RMS I/O
                error.  

                "rmsstv" is an integer variable or array element
                into which is stored the RMS status value (STV)
                if the last error was an RMS I/O error.  This
		status value provides additional status
		information.

                "iunit" is an integer variable or array element
		into which is stored the logical unit number,
		if the last error was an I/O error.

                "condval" is an integer variable or array element
		into which is stored the actual VAX-11 condition
		value.

  Any of the arguments may be null.  If the arguments are of
  INTEGER*2 type, only the low-order 16 bits of information are 
  returned.  The saved error information is set to zero after 
  each call to ERRSNS.

3 EXIT

  The EXIT subroutine caused program termination, closes all files,
  and returns control to the operating system.  A call to EXIT has
  the form:

        CALL EXIT(exit-status)
                (Where "(exit-status") is an optional integer
		 argument which may be used to specify the image
		 exit-status value.)

3 SECNDS

  The SECNDS function subprogram returns the system time in seconds
  as a single-precision, floating-point value less the value of its
  single-precision floating-point argument.  The call to SECNDS has
  the form:

        y = SECNDS(x)
                (Where "y" is set equal to the time in seconds
		 since midnight, minus the user-supplied value 
		 of x.)

  The SECNDS function can be used to perform elapsed-time
  computations.  For example:

        C     START OF TIMED SEQUENCE
              T1 = SECONDS(0.0)

        C     CODE TO BE TIMED

              DELTA = SECNDS(T1) 

                (Where DELTA will give the elapsed time.)

  The value of SECNDS is accurate to 0.01 second, which is the
  resolution of the system clock.

 			  NOTES

                1.  The time is computed from midnight.  SECNDS
  also produces correct results for time intervals that span 
  midnight.
                2.  The 24 bits of precision provides accuracy 
  to the resolution of the system clock for about one day.
  However, loss of significance can occur if computations of
  very small elapsed times are attempted late in the day.
  More precise timing information can be obtained using
  Run-Time Library procedures:

        LIB$INIT_TIMER
        LIB$SHOW_TIMER
        LIB$STAT_TIMER

3 TIME

  The TIME subroutine returns the current system time as an
  ASCII string.  A 24-hour clock is used.  The call to TIME
  has the form:

        CALL TIME(buf)
                (Where "buf" is an 8-byte variable, array,
		 array element, or character substring.)

  The TIME call returns the time as an 8-byte ASCII character
  string of the form:

        hh:mm:ss
                (Where "hh" is the 2-digit hour indication,
		 "mm" is the 2-digit minute indication, "ss"
		 is the 2-digit second indication.  For
		 example:

                        10:29:59  )

3 RAN

  The RAN function is a general random number generator of the
  multiplicative congruential type.  The result is a 
  floating-point number that is uniformly distributed in the 
  range between 0.0 inclusive and 1.0 exclusive. The call to
  RAN has the form:

        y = RAN(i)
                (Where "y" is set equal to the value associated,
		 by the function, with the argument "i".  The
		 argument must be an INTEGER*4 variable of 
		 INTEGER*4 array element.)

  The argument should initially be set to a large, odd integer
  value. The RAN function stores a value in the argument that it
  later uses to calculate the next random number.

  There are no restrictions on the seed, although it should be
  initialized with different values on separate runs in order to
  obtain different random numbers;  the seed is updated
  automatically.  RAN uses the following algorithm to update the
  seed passed as the parameter:

        SEED = 69069 * SEED + 1 (MOD 2**32)     .

  The value of SEED is a 32-bit number whose high-order 24 bits
  are converted to floating point and returned as the result.

        A       Transfers character or Hollerith values.

        BN      Specifies that embedded and trailing blanks in a
		numeric input field are to be ignored.

        BZ      Specifies that embedded and trailing blanks in a
		numeric input field are to be treated as zeros.

        D       Transfers real values (D exponent field indicator).

        E       Transfers real values (E exponent field indicator).

        F       Transfers real values.

        G       Transfers real values:  on input, acts like F code;
		on output, acts lke E code or F code, depending on
		the magnitude of the value.

        H       Transfers data between the H field descriptor and
		an external record.

        I       Transfers decimal integer values.

        L       Transfers logical data:  on input, transfers
		characters; on output, transfers T or F.

        O       Transfers octal values.

        Q       Obtains the number of characters remaining to be 
		transferred in an input record.

        S       Reinvokes optional plus characters in numeric
		output fields:  counters the action of SP and SS.

        SP      Writes plus characters that would otherwise be
		optional into numeric output fields.

        SS      Suppresses optional plus characters in numeric
		output fields.

        T       Specifies positional tabulation.

        TL      Specifies relative tabulation (left).

        TR      Specifies relative tabulation (right).

        X       Specifies that n characters are to be skipped.

        Z       Transfers hexadecimal values.

        $       Suppresses carriage return during interactive
		I/O.

        :       Terminates format control if the I/O list is
		exhausted.

        '+'     Carriage control character.  Overprinting.

        ' '     Carriage control character.  Single spacing.

        '0'     Carriage control character.  Double spacing.

        '1'     Carriage control character.  Paging.

        ASCIINUL
                Carriage control character.  Overprinting
		with no advance.

3 A

  The A field descriptor transfers character or Hollerith values.
  It has the form:

                A[w]

  The corresponding I/O list elements can be of any data type.
  If it is of character data type, character data is transmitted.
  If it is of any other data type, Hollerith data is transmitted.

  The value of "w" must be less than or equal to 32767.

  The maximum number of characters that can be stored depends on
  the size of the I/O list element.

  If "w" is omitted in an A field descriptor, a default value is
  supplied.  If the I/O list element is of character data type,
  the default value is the length of the I/O list element.  If
  the I/O list element is of numeric data type,  the default
  value is the maximum number of characters that can be stored
  in a variable of that data type.

3 BN

  The BN descriptor causes the processor to ignore all the
  embedded and trailing blanks it encounters within a numeric
  input field.  It has the form:

                BN

  The effect is that of actually removing the blanks and
  right-justifying the remainder of the field.  A field of all
  blanks is treated as zero.  The BN descriptor affects only
  I, O, Z, F, E, D, and G editing, and then only upon the
  execution of an input statement.

3 BZ

  The BZ descriptor causes the processor to treat all the
  embedded and trailing blanks it encounters within a numeric
  input field as zeros.  It has the form:

                BZ

  The BZ descriptor affects only I, O, Z, F, E, D, and G
  editing; and then only upon the execution of an input
  statement.

3 CARRIAGECONTROL

  The first character of every record transferred to a
  printer is not printed.  Instead, it is interpreted as
  a carriage control character (except when overridden
  by the OPEN statement keyword CARRIAGECONTROL = 'LIST'
  or 'NONE').  The I/O system recognizes certain
  characters, listed below, as carriage control
  characters.  

  '+'   Overprinting:  starts output at the beginning of
	the current line and returns to the left margin
	after printing.

  ' '   (blank space)  Single spacing:  starts output at
	the beginning of the next line.

  '0'   Double spacing:  skips a line before starting
	output.

  '1'   Paging:  starts output at the top of a new page.

  '$'   Prompting:  starts output at the beginning of
	the next line, and suppresses carriage return at
	the end of the line.

  ASCII NUL
        Overprinting with no advance:  starts output at
	the beginning of the current line and does not
	return to the left margin after printing.

3 :

  The colon character (:) in a format specification 
  terminates format control if no more items are in 
  the I/O list.  The : descriptor  has no effect if
  I/O list items remain.  For example:

               PRINT 1,3
               PRINT 2,4
        1      FORMAT (' I=',I2,' J=',I2)
        2      FORMAT (' K=',I2,:,' L=',I2)

  These statements print the following two lines (the
  two carats designate blank spacing):

            v
        I= 3 J=
        K= 4
          ^ 

3 D

  The D field descriptor transfers real values in 
  exponential form.  It has the form:

                Dw.d

  The corresponding I/O list element must be of real
  data type, or it must be either the real or the
  imaginary part of a complex type.  In an input
  statement, the D field descriptor transfers "w" 
  characters from the external field and assigns
  them as a real value to the corresponding I/O list
  element.  The F and E field descriptors interpret
  and assign data in exactly the same way.

  In an output statement, the D field descriptor has
  the same effect as the E field descriptor, except 
  that the D exponent field indicator is used in 
  place of the E indicator.

  The default values depend on the data type of the I/O 
  list element.  For REAL, and COMPLEX*8 list elements,
  the respective default values for "w", "d", and "e"
  are 15, 7, and 2.  For REAL*8, and COMPLEX*16 list
  elements, they are 25, 16, and 2.  For REAL*16 list
  elements, they are 42, 33, and 3.

3 $

  The dollar sign character ($) in a format specification 
  modifies the carriage control specified by the first
  character of the rocord, for files with the FORTRAM
  carriage control attribute.  In an output statement,
  if the first character of the record is a space, the
  $ descriptor suppresses the carriage return.  This
  means that for terminal I/O a typed response will
  follow the output on the same line.  If the first
  character of the record is a plus sign (+), the $
  descriptor causes the output to begin at the end of
  the previous line and leaves the print position at the
  end of the line.  In an input statement, the $
  descriptor is ignored.

  See VAX-11 FORTRAN Reference Guide for example.

3 E

  The E field descriptor transfers real values in exponential form.
  It has the form:

                Ew.d[Ee]

  The corresponding I/O list element must be of real data type, or
  it must be either the real or the imaginary part of a complex
  data type. In an input statement, the E field descriptor
  transfers "w" characters from the external field and assigns
  them as a real value to the corresponding I/O list element.  The
  F field descriptor interprets and assigns data in exactly the
  same way.

  For REAL, and COMPLEX*8 list elements, the respective default
  values for "w", "d", and "e" are 15, 7, and 2.  For REAL*8, and
  COMPLEX*16 list elements, they are 25, 16, and 2.  For REAL*16
  list elements, they are 42, 33, and 3.

3 F

  The F field descriptor transfers real values.  It has the form:

        Fw.d

  The corresponding I/O list element must be of real data type, or
  it must be either the real or the imaginary part of a complex
  data type.

  In an input statement, the F field descritpor transfers "w" 
  characters from the external field and assigns them, as a real 
  value, to the corresponding I/O list element.  If the first 
  nonblank character of the external field is a minus sign,  the
  field is treated as a negative value.  If the first nonblank
  character is a plus sign, or if no sign appears in the field, 
  the field is treated as a positive value.  An all-blank field
  is treated as a value of zero.

  If the field contains neither a decimal point nor an exponent,
  it is treated as a real number of "w" digits, in which the 
  rightmost "d" digits are to the right of the decimal point, 
  with leading zeros assumed if necessary.  If the field
  contains an explicit decimal point, the location of that
  decimal point overrides the location specified by the field
  descriptor.  If the field contains an exponent, that exponent
  is used to extablish the magnitude of the value before it is
  assigned to the list element.

  For REAL, and COMPLEX*8 list elements, the respective default values 
  for "w", "d", and "e" are 15, 7, and 2.  For REAL*8, and COMPLEX*16 
  list elements, the values are 25, 16, and 2.  For REAL*16 list
  elements, they are 42, 33, and 3.

3 G

  The G field descriptor transfers real values in a form that, in 
  effect, combines the F and E field descriptors.  It has the form:

                Gw.d[Ee]

  The corresponding I/O list element must be of real data type, or
  it must be either the real or the imaginary part of a complex
  data type.  In an input statement, the G field descriptor 
  transfers "w" characters from the external field and assigns
  them as a real value to the corresponding I/O list element.  The
  F, D, and E field descriptors interpret and assign data in
  exactly the same way.

  For REAL, and COMPLEX*8 list elements, the respective default
  values for "w", "d", and "e" are 15, 7, and 2.  For REAL*8, and
  COMPLEX*16 list elements, the values are 25, 16, and 2.  For
  REAL*16 list elements, they are 42, 33, and 3.

  See VAX-11 FORTRAN Reference Guide for additional specifications.

3 H

  The H field descriptor transfers data between the external record
  and the H field descriptor itself.  It has the form of a Hollerith
  constant:

        nHc1,c2,c3,...cN
                (Where "n" is the number of characters to be
 		 transferred, and "c" is an ASCII character.)

  In an input statement, the H field descriptor transfers n
  characters from the external field to the field descriptor.  The
  first character appears immediately after the letter H.  Any 
  character in the field descriptor before input are replaced by
  the input characters.

  In an output statement, the H field descriptor transfers n characters
  following the letter H from the field descriptor to the external
  field.

3 I

  The I field descriptor transfers decimal integer values.  It has the
form:

                Iw.[.m]

  The corresponding I/O list element must be of either integer or
  logical data type.

  In an input statement, the I field descriptor transfers "w"
  characters from the external field and assigns them to the 
  corresponding I/O list element as an integer value.  The 
  external data must have the form of an integer constant; 
  it cannot contain a decimal point or exponent field.

  If the value of the external field exceeds the range of the 
  corresponding list element, an error occurs.  If the first 
  nonblank character of the external field is a minus sign, the 
  field is treated as a negative value.  If the first nonblank-
  character is a plus sign, or if no sign appears in the field,
  the field is treated as a positive value.  An all-blank field
  is treated as a value of zero.

  
  See VAX-11 FORTRAN Reference Guide for transfer specifications 
  and examples.

  The default value of "w" is 7 for BYTE, INTEGER*2, and LOGICAL*2 
  list elements, and 12 for INTEGER*4 and LOGICAL*4 list elements.

3 L

  The L field descriptor transfers logical data.  It has the form:

        Lw

  The corresponding I/O list element must be of either integer or 
  logical data type.

  In a input statement, the L field descriptor transfers "w" characters
  from the external field.  If the first nonblank characters of the
  field are T, t, .T, or .t, the value .TRUE. is assigned to the 
  corresponding I/O list element; if the first nonblank characters are
  F, f, .F or .f, the value .FALSE. is assigned.  An all-blank field is
  assigned the value .FALSE..  Any other value in the external field
  produces an error.  Note that the logical constants .TRUE. and
  .FALSE. are acceptable input forms.

  The default value of "w" for LOGICAL list elements is 2.

  See VAX-11 FORTRAN Reference Guide for transfer specifications
  and examples.

3 O

  The O field descriptor transfers octal (base 8) values, and can 
  be used with any data type.  It has the form:

        Ow[.m]

  The default value of "w" is 7 for BYTE, INTEGER*2, and LOGICAL*2
  list elements; 12 for INTEGER*4, LOGICAL*4, and REAL*4 list
  elements; 23 for REAL*8 list elements; and 44 for REAL*16 list
  elements.

  See VAX-11 FORTRAN Reference Guide for transfer specifications and
  examples.

3 Q

  The Q edit descriptor obtains the number of characters in the input
  record remaining to be transferred during a READ operation.  It has
  the form:

        Q

  The corresponding I/O list element must be of integer or logical 
  data type.

  For example:

              READ (4,1000) XRAY, KK, NCHRS, (ICHR(I), I=1, NCHRS)
        1000  FORMAT (E15.7,I4,Q,80A1)

  These input statements read two fields into the variables XRAY 
  and KK.  The number of characters remaining in the record is 
  stored in NCHRS, and exactly that many characters are read into 
  the array ICHR.  By placing the Q descriptor first in the format
  specification, you can determine the actual length of the input
  record. 

  In an output statement, the Q edit descriptor has no effect except
  that the corresponding I/O list element is skipped.

3 S

  The S edit descriptor reinvokes optional plus characters (+) in 
  numeric output fields.  It has the form:

        S

  The S descriptor counters the action of either the SP or SS
  descriptor by restoring to the processor the discretion of
  producing plus characters on an optional basis.

  The S descriptor affects only I, F, E, D, and G editing, and
  then only upon execution of an output statement.

3 SP

  An SP descriptor causes the processor to produce a plus character
  (+) in any position where this character would otherwise be
  optional.  It has the form:

        SP

  
  The SP  descriptor affects only I, F, E, D, and G editing, and then
  only upon execution of an output statement.

3 SS

  The SS descriptor causes the processor to suppress a leading plus
  character (+) from any position where this character would normally
  be produced as an optional charactrer;  it has the opposite effect 
  of the SP field descriptor.  The SS descriptor has the form:

        SS
  
  The  descriptor affects only I, F, E, D, and G editing, and then only
  upon execution of an output statement.

3 P

  The scale factor lets you alter, during input or output, the location
  of the decimal point in real values and in the two parts of complex 
  values.

  The scale factor has the form:

        nP
                (Where n is a signed or unsigned integer constant in
		 the range -127 through 127.  It specifies the
		 number of positions, to the left or right, that the
		 decimal point is to move.)

  A scale factor can appear anywhere in a format specification, but
  must precede the first field descriptor that is to be associated
  with it.  For example:

        nPFw.d          nPEw.d          nPDw.d          nPGw.d

  On input, the scale factor in any of the above field descriptors 
  multiplies the data by 10**-n and assigns it to the corresponding
  I/O element.  For example, a 2P scale factor multiplies an input
  value by .01, moving the decimal point two places to the left.  A
  -2P scale factor multiplies an input value by 100, moving the
  decimal point two places to the right.  However, if the external
  field contains an explicit exponent, the scale factor has no
  effect.

  If a second scale factor appears in the FORMAT statement, it takes
  control from the first scale factor.

  See VAX-11 FORTRAN Reference Guide for complete specifications and
  examples.

3 SEPARATORS

  Field descriptors in a format specification are generally separated
  by commas.  You can also use the slash (/) record terminator to 
  separate field descriptors.  A slash terminates input or output of
  the current record and initiates a new record.  For example:

               WRITE (6,40) K,L,M
        40     FORMAT (3I6,6)
               WRITE (6,50) N,O,P
        50     FORMAT (I6,2F8.4)

  Multiple slashes can be used to bypass input records or to output
  blank records.  If n consecutive slashes appear between two field
  descriptors, (n-1) records are skipped on input, or (n-1) blank re-
  cords are output.  The first slash terminates the current record;
  the second slash terminates the first skipped or blank record, and
  so on.  However, n slashes at the beginning or end of a format 
  specification result in n skipped or blank records.  This is 
  because the opening and closing parentheses of the format
  specification are themselves a record and terminator, respectively.
  For example:

        WRITE (6,99)
  99    FORMAT ('1',t51,'HEADING LINE'//T51,/SUBHEADING LINE'//)

  The above statements procude the following output:

                                                  HEADING LINE
                                        (blank line)
                                                  SUBHEADING LINE
                                        (blank line)
                                        (blank line)
                (With the "H" of "HEADING" at Column 50 at top of
		 page.)

  When the field desctiptor is numeric, padding the input field may be 
  avoided by using a comma to terminate the field.  The comma overrides
  the field descriptor's field width specification.

  The physical end of the record also serves as a field terminator, and
  the "d" part of a "w.d" specification is not affected by an external
  field separator.  

  Commas may be used to terminate only fields less tha w characters
  long. If a comma follows a field of w or more characters, the comma
  is considered part of the next field.

  Two successive commas, or a comma after a field of exactly w
  characters, constitutes a null (zero-length) field.  Depending on the
  field descriptor specified, the resulting value assigned is 0., 0.0,
  0.D0, 0.Q0, or .FALSE..

  Commas may not be used to terminate a field that is controlled by an
  A, H, or character constant field descriptor.  However, if the 
  record reaches its physical end before w characters are read, short
  field termination occurs and the characters that were input are
  assigned successfully.  Trailing spaces are appended to fill the
  corresponding I/O element or the field descriptor.

  
  

3 T

  The T edit descriptor is a positional tabulation specifier.  It has
  the form:

        Tn

  The term n indicates the character position of the external record. 
  The value of n must be greater than or equal to one.

  In an input statement, the T field descriptor positions the external
  record to its nth character position.  For example, a READ  statement
  inputs a record containing:

        ABC   XYZ
                (With three blank spaces in between.)

  This record is under the control of the FORMAT statement:

        10     FORMAT (T7,A3,T1,A3)

  On execution, the READ statement would input the characters XYZ
  first, then the characters ABC.

  In an output statement, the T field descriptor specifies that
  subsequent data transfer is to begin at the nth character position
  of the external record.  The first position of a record to be
  printed is usually reserved for a carriage control character which
  is not printed.  For example:

               PRINT 25
        25     FORMAT (T51,'COLUMN 2',T21,'COLUMN 1')

  These statements would print the following line:

                    COLUMN 1                      COLUMN 2

                (With the "C" of "COLUMN 1" at Position 20, and the
		 "C" of "COLUMN 2" at Position 50.)

3 TL

  The TL edit descriptor is a relative tabulation specifier.  It has
  the form:

        TLn

  The term n indicates that the next character to be transferred from
  or to a record is the nth character to the left of the current 
  character. The value of n must be greater that or equal to one.  If
  the value of n is  greater than or equal to the current character
  position, the first character in the record is specified.

3 TR

  The TR edit descriptor is a relative tabulation specifier.  It has
  the form:

        TRn

  The term n indicates that the next character to be transferred from
  or to a record is the nth character to the right of the current 
  character. The  value of n must be greater than or equal to one.

3 X

  The X edit descriptor is a positional specifier.  It has the form:

        nX

  The term n specifies how many character positions are to be passed
  over.  The value of n must be greater than or equal to one.

  In an input statement, the X field descriptor specifies that the next
  n characters in the input record are to be skipped.

  In an output statement, the X field descriptor tabs right n spaces;
  it does not write over anything already written.  For example:



           WRITE (6, 90) NPAGE
    90     FORMAT ('1PAGE NUMBER ',12,16X,'GRAPHIC ANALYSIS, CONT.')
                         ^      ^                 ^         ^

  (Note the blank spacing.)  The WRITE statement prints a record
   similar to:

        PAGE NUMBER  nn                         GRAPHIC ANALYSIS, CONT.

  The term nn is the current value of the variable NPAGE.  The numeral
  1 in the first H field descriptor is not printed, but is used to ad-
  vance the printer paper to the top of a new page.

3 Z

  The Z field descriptor transfers hexadecimal (base 16) values, and
  can be used with any data type.  It has the form:

        Zw[.m]

  In an input statement, the Z field descriptor transfers "w" char-
  acters characters from the external field and assigns them as a 
  hexadecimal value to the corresponding I/O list element.  The
  external field can contain only the numerals 0 through 9 and the
  letters A (a) through F (f); it cannot contain a sign, a decimal
  point, or an exponent field.  An all-blank field is treated as a
  value of zero.  If the value of the external field exceeds the
  range of the corresponding list element, an error occurs.

  In an output statement, the Z field descriptor transfers the hexade-
  cimal value of the corresponding I/O list element, right-justified,
  to an external field "w" characters long.  No signs are output; a
  negative value is transmitted in internal form.  If the value does
  not fill the field, leading spaces are inserted; if the value
  exceeds the field width, the entire field is filled with asterisks.
  If "m" is present, the external field consists of at leas m digits,
  and is zero- filled on the left if necessary.

  If "m" is zero, and the internal representation is zero, the external
  field is blank-filled.

  The default value of "w" is 7 for BYTE, INTEGER*2, and LOGICAL*2 list
  elements; 12 for INTEGER*4, LOGICAL*4, and REAL*4 list elements; 23
  for REAL*8 list elements; and 44 for REAL*16 list  elements.

  See VAX-11 FORTRAN Reference Guide for examples.

2 SUBLIST
  The subroutines supplied are:

        DATE    Returns a 9-byte string containing the ASCII 
                representation of the current date.
        IDATE   Returns three integer values representing the 
                current month, day, and year.
        ERRSNS  Returns information about the most recently 
                detected error condition.
        EXIT    Terminates the execution of a program and 
                returns control to the operation system.
        SECNDS  Provides the system time of day, or elapsed 
                time, as a floating-point value in seconds.
        TIME    Returns an 8-byte string containing the ASCII 
                representation of the current time in hours, 
                minutes, and seconds.
        RAN     Returns the next number from a sequence of 
                pseudo random numbers of uniform distribution 
                over the range from 0 to 1.
2 FILEIO
	Further information is available for the following keywords
 
	ACCESS	ASSOCIATEVARIABLE	BLANK	BLOCKSIZE	BUFFERCOUNT
	CARRIAGE CONTROL	DEFAULTFILE	DISPOSE	ERR	EXTENDSIZE
	FILE	FORM	INITIALSIZE	IOSTAT	KEY	MAXREC	NAME
	NOSPANBLOCK	S	ORGANIZATION	READONLY	RECL	
	RECORDSIZE	RECORDTYPE	SHARED	STATUS	TYPE	UNIT
	USEROPEN	FILE	DEFAULTFILE	ACCESS	BLANK	CARRIAGECONTROL
	DIRECT	ERR	EXIST	FORM	FORMATTED	IOSTAT	KEYED	
	NAME	NAMED	NEXTREC	NUMBER	OPEND	ORGANIZATION
 
	typ	AID F77  FILEIO xxxxxx	for more information

3 OPEN

  FORMAT:       OPEN(par[,par]...)

  Where "par" is a keyword specification in one of the following 
  forms:

        key

        key = value

  Where "key" is a keyword as described below, and "value" depends 
  on the keyword.  See individual listings.

  Keywords are divided into several categories based on function:

        * Keywords that identify the unit and file:

                UNIT            --logical unit number to be used.
                FILE or NAME    --file-name specification for the 
                                  file.
                DEFAULTFILE     --default file-name specification 
                                  for the file.
                STATUS or TYPE  --file existence status at OPEN.
                DISPOSE         --file existence status after CLOSE.

        * Keywords that describe the records in the file:

                BLOCKSIZE       --physical block size.
                CARRIAGECONTROL --printer control type.
                FORM            --type of FORTRAN record formatting.
                RECL or         --logical record length.
                RECORDSIZE
                RECORDTYPE      --logical record format.
                BLANK           --blank interpretation for numeric
                                  output.
                KEY             --keys for keyed access.

        * Keywords that describe file storage allocation when a file 
          is created:

                INITIALSIZE     --initial file allocation.
                EXTENDSIZE      --file allocation increment size.

        * Keywords that provide additional capability for direct
          access I/O:

                ASSOCIATEVARIABLE
                                --the next record number value.
                MAXREC          --maximum direct access record 
                                  number.

        * Optional keywords that provide improved performance or
          special capabilities.  These options are generally 
          transparent to I/O processing:

                BUFFERCOUNT     --number of I/O buffers to be used.
                NOSPANBLOCKS    --records are not to be split 
                                  across physical blocks.
                SHARED          --other programs can simultaneously
                                  access the file.
                USEROPEN        --user program option to provide
                                  additional OPEN capability.
                ERR             --statement to which control is 
                                  transferred if an error occurs 
                                  during execution of the OPEN 
                                  statement.
                IOSTAT          --status value that indicates 
                                  whether an error condition 
                                  exists.

4 ACCESS

  FORMAT:       ACCESS = acc

  (Where "acc" may take on the following values:

                'DIRECT'        --file is accessed by record 
                                  number.
  (default) >>> 'SEQUENTIAL'    --file is accessed sequentially. 
                'KEYED'         --file is accessed by a specified 
                                  key.
                'APPEND'        --implies sequential access and 
                                  positioning after the last record 
                                  of the file.    )

4 ASSOCIATEVARIABLE

  FORMAT:       ASSOCIATEVARIABLE = asv

  (Where  "asv" is an integer variable which is not a dummy argument 
   to the routine in which the OPEN statement occurs.)

  ASSOCIATEVARIABLE specifies the integer variable (asv) that, after 
  each direct access I/O operation, contains the record number of 
  the next sequential record in the file.  This specifier is valid 
  only for direct access mode; it is ignored for other access modes.

4 BLANK

  FORMAT:       BLANK = blnk

  (Where "blnk" is a character expression having a value equal to:

                        'NULL'  --whereupon all blanks in a numeric 
                                  input field are ignored (except if 
                                  the field is comprised of all 
                                  blanks, in which case it is treated 
                                  as zero).  
        (default) >>>   'ZERO'  --whereupon all blanks other than 
                                  leading blanks are to be treated as 
                                  zeros.  )

4 BLOCKSIZE

  FORMAT:       BLOCKSIZE = bks

  (Where "bks" is a numeric expression.  )

  BLOCKSIZE specifies the physical I/O transfer size (in bytes) 
  for the file. The default is the system dafault for the device.  
  See VAX-11 FORTRAN User's Guide for more information.

4 BUFFERCOUNT

  FORMAT:       BUFFERCOUNT  = bc

  (Where "bc" is a numeric expression.  )

  BUFFERCOUNT specifies the number of buffers to be associated 
  with the logical unit for multibuffered I/O.  The BLOCKSIZE 
  keyword determines the size of each buffer.  If you do not 
  specify BUFFERCOUNT, or if you specify zero, the system 
  default is assumed.

4 CARRIAGECONTROL

  CARRIAGECONTROL determines the kind of carriage control processing
  to be used when printing a file.

  FORMAT:       CARRIAGECONTROL = cc

  (Where "cc" is a character expression having a value equal to:

                'FORTRAN'       --specifies normal FORTRAN 
                                  interpretation of the first 
                                  character.
                'LIST'          --specifies single spacing 
                                  between records.
                'NONE'          --specifies no implied carriage 
                                  control.  
                                                                

  The default for formatted files is 'FORTRAN'; for unformatted 
  files, the default is 'NONE'.  )

4 DEFAULTFILE

  FORMAT:       DEFAULTFILE = ce

  (Where "ce" is a character expression which contains a default 
   file name specification string.)

  DEFAULTFILE specifies a string that is used in conjunction with 
  the file name specified by the FILE or NAME keyword to produce a 
  fully specified file name.  See VAX-11 FORTRAN User's Guide for 
  more information on DEFAULTFILE.

4 DISPOSE

  FORMAT:       DISPOSE = dis           DISP = dis

  (Where "dis" may take on the following values:

                'KEEP' or 'SAVE'--whereupon file is retained after the
                                  unit is closed. (This is the default
                                  value.)
                'DELETE'        --whereupon the file is deleted.
                'PRINT'         --whereupon the file is submitted to
				  the system line printer spooler and
				  is not deleted.
                'PRINT/DELETE'  --whereupon the file is submitted to
				  the system line printer spooler and
				  IS deleted.
                'SUBMIT'        --whereupon the file is submitted to
				  the batch job queue and is not 
				  deleted.
                'SUBMIT/DELETE' --whereupon the file is submitted to
				  the batch job queue and IS deleted.)

  A scratch file cannot be saved, printed, or submitted.

4 ERR

  FORMAT:       ERR = s

  (Where "s" is the label of an executable statement.)

  ERR transfers control to the executable statement specified by "s"
  when an error occurs.  ERR applies only to the OPEN statement in
  which it is specified, and not to subsequent I/O operations on the
  unit. If an error occurs, no file is opened or created.
                                                                

4 EXTENDSIZE

  FORMAT:       EXTENDSIZE = es

  (Where "es" is a numeric expression.  )

  EXTENDSIZE specifies the number of blocks by which to extend a disk 
  file when additional file storage is allocated.  If you do not 
  specify EXTENDSIZE, or if you specify zero, the system default for 
  the device is used.

4 FILE

  FORMAT:       FILE = fln

  (Where "fln" is a character expression, numeric array name, 
   numeric variable name, or numeric array element name.)

  FILE specifies the name of the file to be connected to the unit.  
  The name can be any file specification accepted by the operating 
  system.

  The VAX-11 FORTRAN User's Guide describes default file name 
  conventions.

  If the file name is stored in a numeric variable, numeric array, 
  or numeric array element, the name must consist of ASCII characters 
  terminated by am ASCII null character (zero byte).  However, if it 
  is stored in a character variable, array, or array element, it must 
  not contain a zero byte.

4 FORM

  FORM specifies whether the file being opened is to be read or 
  written using formatted or unformatted READ or WRITE statements.

  FORMAT:       FORM = ft

  (Where "ft" is a character expression having a value equal to
   'FORMATTED' (default value for sequential files) or 'UNFORMATTED'
   (default value for direct access and keyed access files).)

4 INITIALSIZE

  FORMAT:       INITIALSIZE = insz

  (Where "insz" is a numeric expression.  )

  INITIALSIZE specifies the number of blocks in the initial allocation
  of space for a new file on a disk.  If you do not specify INITIAL-
  SIZE, or if you specify zero, no initial allocation is made.

4 IOSTAT

  FORMAT:       IOSTAT = ios

  (Where "ios" is an integer variable or integer array element.  )

  IOSTAT is an I/O status specifier.  It causes "ios" to be defined 
  as zero if no error condition exists, or as a positive integer if 
  an error condition exists.  VAX-11 FORTRAN I/O status values are 
  described in the VAX-11 FORTRAN  User's Guide.  IOSTAT applies only 
  to the OPEN statement in which it appears and not to subsequent I/O 
  operations on the logical unit that is opened; however, IOSTAT can 
  be used in subsequent I/O statements to perform a similar function.

4 KEY

  FORMAT:       KEY = (kspec[,kspec]...)

  (Where "kspec" has the form:  e1:e2[:dt] , and "e1" signifies the 
   first byte position of the key, "e2" signifies the last byte 
   position of the key, and "dt" is the data type of the key:  
   either INTEGER or CHARACTER.  )

  KEY defines the access keys for records in an indexed file.  The 
  key starts at position e1 in the record and has a length of 
  e2-e1+1.  The values of e1 and e2 must be such that:

        1 .LE. (e1) .LE. (e2) .LE. record length
        1 .LE. (e2-e1+1) .LE. 255

  If the key type is INTEGER, the key length must be either 2 or 4.  
  There may be up to 255 key specifications in a list, but there 
  must be at least one.  The first key specification defines the 
  primary key, the second defines the first alternate key, and so 
  forth.  The default data type is CHARACTER.  The position of a 
  key specification in the list determines a key's key-of reference 
  number.  This number is used in any subsequent  I/O statement to 
  specify the same key.  The primary key is key-of-reference number 
  0, the first alternate key is key-of-reference number 1, and so 
  forth.

  The key fields and key-of-reference numbers are permanent 
  attributes of an indexed file and are established when the file 
  is created.  The KEY parameter must be specified when a file is 
  created, but need not be specified when an existing file is 
  opened.  When an existing file is opened, key definitions and 
  key-of-reference numbers are obtained from the file itself.  If 
  the KEY parameter is specified for an existing file, it must 
  agree with the established attributes of the file.

4 MAXREC

  FORMAT:       MAXREC = mr

  (Where "mr" is a numeric expression.  )

  MAXREC specifies the maximum number of records permitted in 
  a direct access file.  The default is an unlimited number 
  of records.  This specifier applies only to direct access 
  files.

4 NAME

  NAME is a nonstandard synonym for FILE.  See FILE listing 
  for details.

4 NOSPANBLOCKS

  FORMAT:       NOSPANBLOCKS

  NOSPANBLOCKS specifies that records are not to cross disk block
  boundaries.  If any record exceeds the size of a physical block, 
  an error occurs.

4 ORGANIZATION

  FORMAT:       ORGANIZATION = org

  (Where "org" a character expression whose value is equal to
  'SEQUENTIAL', 'RELATIVE', or 'INDEXED'.)

  ORGANIZATION specifies the internal organization of the file.  When
  you create a file, the default is 'SEQUENTIAL'.  When you access an
  existing file, the default is the organization of that file.  If you
  specify ORGANIZATION for an existing file, "org" must have the same
  value as that of the existing file.

  See the VAX-11 FORTRAN User's Guide for more information on the
  internal organization of files.

4 READONLY

  FORMAT:       READONLY

  READONLY specifies that an existing file can be read, but prohibits
  writing to that file.  

4 RECL

  FORMAT:       RECL = rl

  (Where "rl" is a numeric expression.  )

  RECL specifies the logical record length.  If the file contains
  fixed-length records, RECL specifies the size of each record.  If
  the file contains variable-length records, RECL specifies the
  maximum length for any record.  If the records are formatted, the
  length is the number of longwords.  If the file exists and "rl" does
  not agree with the actual length of the record, an error occurs.  If
  you omit this specifier for old files, the actual record length
  specified when the file was created is assumed.  You must specify
  RECL when you create files with fixed-length records or with
  relative or indexed organization.

4 RECORDSIZE

  RECORDSIZE is a nonstandard synonym for RECL;  see RECL subheading
  for more information.

4 RECORDTYPE

  FORMAT:       RECORDTYPE = typ

  (Where "typ" is a character expression whose value is equal to
   'FIXED', 'VARIABLE', or 'SEGMENTED'.  )

  RECORDTYPE specifies whether the file has fixed-length records,
  variable-length records, or segmented records.  When you create a
  file, the default record types are 'FIXED' for relative or indexed,
  and direct access sequential files; 'VARIABLE' for formatted
  sequential access files; and 'SEQUENTIAL' for unformatted
  sequential files.  

  A segmented record consists of one or more variable-length records.
  Use of segmented records allows a FORTRAN logical record to span
  several physical records.  Only sequential access, unformatted files
  with sequential organization can use segmented records.  You cannot
  specify 'SEGMENTED' for any other type.

  If RECORDTYPE is not specified when accessing an existing file, the
  record type of the file is used.  An exception to this is
  unformatted sequential access, sequential organization files with 
  variable-length records; these files have a default of 'SEGMENTED'.

  If RECORDTYPE is specified, "typ" must match the record type of the
  existing file.

  In fixed-length record files, if an output statement does not
  specify a full record, the record is filled with spaces (for a
  formatted file) or zeros (for an unformatted file).

4 SHARED

  FORMAT:       SHARED

  SHARED specifies that the file can be opened for shared access by
  more than one program executing simultaneously.

  See the VAX-11 FORTRAN User's Guide for additional information.

4 STATUS

  FORMAT:       STATUS = sta

  (Where "sta" is a character expression whose value is equal to:

                'OLD'   --for which the file must already exist.
                'NEW'   --for which a new file is created.
                'SCRATCH'-for which a new file is created and then
                          deleted when the file is closed.
  (default) >>  'UNKNOWN'-for which the processor will first try 
                          'OLD'; if the file is not found, the
                          processor will use 'NEW'.  )

4 TYPE
 
  TYPE is a nonstandard synonym for STATUS.  See STATUS subheading
  for more information.

4 UNIT

  FORMAT:       [UNIT=]u

  (Where "u" is a numeric expression.  )

  UNIT specifies the logical unit to which a file is to be connected.
  The unit specification must appear in the list.  The optional 
  character string "UNIT = " may be omitted only when the UNIT
  parameter occupies the first position in the list.

  The logical unit may already be connected to a file when an OPEN
  statement is executed.  If this file is not the same as the one
  to be opened, the OPEN statement executes as if a CLOSE  statement 
  had executed just before it.  If the file to be opened is already
  connected to the unit, or if the "FILE =" specifier is not 
  included in the OPEN  statement, only the "BLANK =" specifier may
  have a value different from the one currently in effect.  The 
  position of the file is unaffected.

4 USEROPEN

  FORMAT:       USEROPEN = p

  (Where "p" is an external function name.  )

  The USEROPEN keyword specifies a user-written external function, for
  knowledgable users only.  

3 CLOSE

  FORMAT:

        CLOSE( [UNIT = ]u [,st=p][,ERR=s][,IOSTAT=ios] )

  Where:

        "u" is a logical unit number.
        "st" is one of the keywords STATUS, DISPOSE, or DISP.
        "p" is a character expression that determines the dispostion of
                the file.  Its values are:
                        'KEEP' or 'SAVE',-for which the file is 
					  retained after the unit is
					  closed; 
                        'DELETE'        --for which the file is
					  deleted; 
                        'PRINT'         --for which the file is
                                          submitted to the line printer
                                          spooler; 
                        'PRINT/DELETE'  --for which the file is deleted
                                          after being submitted to the 
                                          line printer spooler; 
                        'SUBMIT'        --for which the file is 
					  submitted to the batch job
					  queue; 
                        'SUBMIT/DELETE' --for which the file is deleted
                                          after being submitted to the 
                                          batch job queue.
                For scratch files, the default is 'DELETE'; for all
		other files, the default is 'KEEP'.
        "s" is the labes of an executable statement.
        "ios" is an integer variable or integer array element.

  The CLOSE statement parameters can occur in any order.  The keyword
  UNIT= is optional only if the unit specifier is the first parameter
  on the list.

  The disposition specified in a CLOSE  statement supersedes the
  disposition specified in an OPEN statement, except that a file
  opened as a scratch file cannot be saved, printed, or submitted,
  nor can a file opened for read-only access be deleted.

  For example:

        CLOSE (UNIT=1, STATUS='PRINT')

  This statement closes the file on unit 1 and submits the file for
  printing.

        CLOSE (UNIT=J, STATUS='DELETE', ERR=990)

  This statement closes the file on unit J and deletes it.

3 INQUIRE

  The INQUIRE statement inquires about specified properties of a file
  or of a logical unit on which a file might be opened.  The INQUIRE
  statement has two forms, one for inquiring by file and the other
  for inquiring by unit:

  FORMAT:      INQUIRE (FILE=fi[,DEFAULTFILE=dfi...],flist)
    or
  FORMAT:      INQUIRE([UNIT=]u,ulist)

  "FILE=fi" and "UNIT=u" can appear anyplace in the property-specifier 
  list; however, if "UNIT=" is omitted, "u" must be the first property
  in the list.

  DEFAULTFILE=dfi can be used in addition to or in place of FILE=fi
  when used in connection with an inquiry about a file.  If a file is
  opened with both FILE and DEFAULTFILE keywords specified in the OPEN
  statement, then this file may be inquired about by specifying both
  the FILE and DEFAULTFILE keywords in the INQUIRE statement.

  An INQUIRE statement may be executed before, during, or after the 
  connection of a file to a unit; the values assigned by the statement
  are those that are current at the time of execution of the INQUIRE
  statement.

4 list

  NOTE:		"assigned" refers to the entity associated with
		the particular keyword

  fi		a character expression, numeric array name, numeric
		variable name, or numeric array element name

  dfi		a character expression

  flist 	property-specifier list

  u		logical unit number

  ulist		property-specifier list


  ACCESS	determines access mode

  BLANK		determines interpretation of blanks

  CARRIAGECONTROL
		determines print control

  DIRECT	assigned YES if DIRECT is an allowed access mode

  ERR		determines where control is transferred, should
		an error occur during execution of the INQUIRE
		statement

  EXIST		assigned the value true if the specified file or 
		unit exists

  FORM		determines format type

  FORMATTED	assigned the value YES if formatted is an allowed
		form for the file

  IOSTAT	determines I/O status

  KEYED		assigned the value YES if KEYED is an allowed
		access method for the file

  NAME		assigned the name of the file being inquired
		about

  NAMED		assigned TRUE if specified file has a name

  NEXTREC	assigned an integer value which is one more
		than the number of the last record read or
		written on the specified direct access file

  NUMBER	assigned the number of the logical unit 
		currently connected to the specified file

  OPENED	assigned the value the value TRUE if
		specified file is opened on a unit or if
		the specified unit is opened

  ORGANIZATION	determines file structure

  RECL		determines record length

  RECORDTYPE	determines record structure

  SEQUENTIAL	assigned the value YES if SEQUENTIAL is an
		allowed access method

  UNFORMATTED	assigned the value YES if unformatted is
		an allowed form for the file

4 FILE

  FORMAT:	FILE = fi

		(Where "fi" is a character expression, numeric 
		 array name, numeric variable name, or numeric
		 array element name whose value specifies the
		 name of the file to be inquired about.)

4 DEFAULTFILE

  FORMAT:	DEFAULTFILE = dfi

		(Where "dfi" is a character expression
		 specifying a default file name
		 specification.)

4 flist

	"flist" 	--is a property-specifier list
		 	  in which any one specifier appears
			  only once.  

4 u

        "u"     --is the number of the logical unit to be inquired
		  about.  The unit need not exist, nor need it be
		  connected to a file.  If the unit is connected to
		  a file, the inquiry encompasses both the 
		  connection and file.

4 ulist

        "ulist" --is a property-specifier list in which any one
		  specifier appears only once.

4 ACCESS

  FORMAT:	ACCESS = acc

		(Where acc is acharacter variable, array element,
		 or substring reference.  )

  Acc is assigned the value SEQUENTIAL if the file is connected for
  sequential access, DIRECT if the file is connected for direct 
  access, and KEYED if the file is connected for keyed access.  If
  there is no connection, add is UNKNOWN.

4 BLANK

  FORMAT:	BLANK = blk

		(Where blk is a character variable array element,
		 or substring reference.  )

  Blk is assigned the value NULL if null blank control is in effect
  for a file connected for formatted I/O, and the value ZERO if
  zero blank control is in effect.  If there is no connection, or
  if the connection is not for formatted I/O, blk is UNKNOWN.

4 CARRIAGECONTROL

  FORMAT:	CARRIAGECONTROL = cc

		(Where cc as a character variable, array element,
		 or substring reference.  )

  Cc is assigned the value FORTRAN if the file has the FORTRAN carriage
  control attribute, LIST if the file has the implied carriage control
  attribute, NONE if the file has no carriage control attribute, and
  UNKNOWN if no other value applies.

4 DIRECT

  FORMAT:	DIRECT = dir

		(Where dir is character variable, array element, or
		 substring reference.  )

  Dir is assigned the value YES if DIRECT is an allowed access method
  for the file, NO if DIRECT is not an allowed access method, and
  UNKNOWN if the processor is unable to determine whether DIRECT is
  an allowed access method.

4 ERR

  FORMAT:		ERR = s

		(Where s is the label of an executable statement.  )

  ERR is a control specifier rather than a property specifier.  If
  an error occurs during execution of the INQUIRE statement, control
  is transferred to the statement whose label is s.

4 EXIST

  FORMAT:	EXIST = ex

		(Where ex is a logical variable or logical array
		 element.  )

  Ex is assigned the value true if the specified file or unit exists,
  and the value false if the specified file or unit does not exist.

4 FORM

  FORMAT:	FORM = fm

		(Where fm is a character variable, array element,
		 or substring reference.  )

  Fm is assigned the value FORMATTED if the file is connected for
  formatted I/O, and UNFORMATTED if the file is connected for 
  unformatted I/O.  If there is no connection, fm is UNKNOWN.

4 FORMATTED

  FORMAT:	FORMATTED = fmd

		(Where fmd is a character variable, array element,
		 or substring reference.  )

  Fmd is assigned the value YES if formatted is an allowed form for
  the file, NO if formatted is not an allowed form, and UNKNOWN if
  the processor is unable to determine whether formatted is an
  allowed form.

4 IOSTAT

  FORMAT:	IOSTAT = ios

		(Where ios is an integer variable or integer array
		 element.  )

  IOSTAT is a control specifier rather than a property specifier.
  Ios is assigned a processor-dependent positive integer value if
  an error occurs during execution of the INQUIRE statement, and
  the value zero if there is no error condition.

4 KEYED

  FORMAT:	KEYED = kyd

		(Where kyd is a character variable, array element,
		 or substring reference.  )

  Kyd is assigned the value YES if KEYED is an allowed access method
  for the file (that is, the file is indexed), NO if KEYED is not an
  allowed access method, and UNKNOWN if the processor is unable to
  determine whether KEYED is an allowed access method.

4 NAME

  FORMAT:	NAME = nme

		(Where nme is a character variable, array element,
		 or substring reference.  )

  Nme is assigned the name of the file being inquired about.  If the
  file does not have a name, nme is not defined.

  The value assigned to nme is not necessarily identical to the value
  specified with FILE= .  For example, the value that the processor 
  returns may be qualified by a directory name or version number.
  However, the value that is assigned is always valid for use with
  FILE= in an OPEN statement.

				NOTE
  FILE and NAME are synonyms when used with the OPEN statement, but
  not when used with the INQUIRE  statement.

4 NAMED

  FORMAT:	NAMED = nmd

		(Where nmd is a logical variable or logical array
		 element.  )

  Nmd is assigned the value TRUE if the specified file has a name,
  and the value FALSE if it does not have a name.

4 NEXTREC

  FORMAT:	NEXTREC = nr

		(Where nr is an integer variable or integer array
		 element.  )

  Nr is assigned an integer value which is one more than the number
  of the last record read or written on the specified direct access
  file.  If no records have been read or written, the value of nr
  is one.  If the file is not connected for direct access, or if the
  position is indeterminate because or an error condition, nr is
  zero.

4 NUMBER

  FORMAT:	NUMBER = num

		(Where num is an integer variable or integer array
		 element.  )

  Num is assigned the number of the logical unit currently connected
  to the specified file.  If there is no logical unit connected to
  the file, num is not defined.

4 OPENED

  FORMAT:	OPENED = od

		(Where od is a logical variable or logical array
		 element.  )

  Od is assigned the value TRUE if the specified file is opened on
  a unit or if the specified unit is opened; it is assigned the 
  value FALSE if the file or unit is not open.

4 ORGANIZATION

  FORMAT:	ORGANIZATION = org

		(Where org is a character variable, array element,
		 or substring reference.  )

  Org is assigned the value SEQUENTIAL if the file is a sequential
  file, RELATIVE if the file is a relative file, and INDEXED if 
  the file is an indexed file.  If the processor is unable to
  determine the organization, org is assigned the value UNKNOWN.

4 RECL

  FORMAT:	RECL = rcl

		(Where rcl is an integer variable or integer array
		 element.  )

  If the file (or unit) is opened, rcl is the maximum record length
  allowed; if not opened, rcl is the longest record in the file.
  If a specified file does not exist, rcl is zero.  Rcl is 
  expressed in bytes if the file is opened for formatted I/O, and
  in longwords if the file is unformatted.

4 RECORDTYPE

  FORMAT:	RECORDTYPE = rtype

		(Where rtype is a character variable, array element,
		 or substring reference.  )

  Rtype is assigned the value FIXED if the file has fixed-length
  records, VARIABLE if the file has variable-length record, and
  SEGMENTED if the file is connected for unformatted sequential I/O
  using segmented records.  If the processor cannot determine the
  record type, rtype is assigned the value UNKNOWN.

4 SEQUENTIAL

  FORMAT:	SEQUENTIAL = seq

		(Where seq is a character variable, array element,
		 or substring reference.  )

  Seq is assigned the value YES if SEQUENTIAL is an allowed access
  method for the specified file, NO if SEQUENTIAL is not an allowed
  access method, and UNKNOWN if the processor cannot determine
  whether SEQUENTIAL is an allowed access method.

4 UNFORMATTED

  FORMAT:	UNFORMATTED = unf

		(Where unf is a character variable, array element,
		 or substring reference.  )

  Unf is assigned the value YES if unformatted is an allowed form
  for the file, NO if unformatted is not an allowed form for the
  file, and UNKNOWN if the processor is unable to determine
  whether unformatted is an allowed form for the file.


2 SYNTAX

  ACCEPT format_spec[,list]

  ACCEPT*[,io_list]	{ * denotes list-directed formatting }

  ACCEPT name_list_group-name

  ASSIGN s TO int_var_name	{s=label of a FORMAT statement of an
				 executable statement}

  BACKSPACE([UNIT=]log_unit_spec[,IOSTAT=ios][,ERR=st_label])

  BLOCK DATA [symbolic_name]

  CALL f[([a][,[a]]...)]	{f=subprogram name or entry point}

  CLOSE([UNIT=]log_unit_spec[,p][,IOSTAT=ios][,ERR=st_label
	(see File_handling for specifics)

  COMMON [/[common_block_name]/]nlist[[,]/[c_b_name]/nlist]...

  CONTINUE

  DATA nlist/const_list/[[,]nlist/const_list/]...

  DECODE (int_exp,form_spec,name[,IOSTAT=ios][,ERR=st_label])[io_list]

  DEFINE FILE log_unit_spec(m,n,U,v)[,log_unit_spec(m,n,U,v)]...
	{m=const or variable, n=const or var, U specifies unformatted,
	 v=integer variable name.}

  DELETE ([UNIT=]u[,REC=rec_spec][,IOSTAT=ios][,ERR=st_label])
  DELETE(u'rec_spec[,IOSTAT=ios][,ERR=s])
	{u=logical unit specifier}

  DIMENSION a(d)[,a(d)]...	{  a(d)=array declarator  }

  DO [st_label[,]]var_name=e1,e2[,e3]

  DO [st_label[,]] WHILE (e)

  ELSE

  ELSE IF (e) THEN

  ENCODE (c,f,b[,IOSTAT=ios][,ERR=st_label]) [io_list] 
     {c=int_exp; f=format_spec; b=var_name, array_name, array_elmnt,
      or substring_name}

  END

  END DO

  ENDFILE ([UNIT=]log_unit_spec[,IOSTAT=ios][,ERR=st_label])
  ENDFILE logical_unit_specifier

  END IF

  ENTRY subpro_name[([p[,p]...])]
	{  p=symbolic_name or alternate_return_specifier (*)  }

  EQUIVALENCE (nlist)[,(nlist)]...

  EXTERNAL subpro_name[,subpro_name]...

  FIND([UNIT=]log_unit_spec,REC=rec_spec[,IOSTAT=ios][ERR=s])
  FIND(log_unit_spec'rec_spec[,IOSTAT=ios][,ERR=st_label])

  FORMAT (field specification,...)

  [data_typ_spec]FUNCTIONsymb_name[*n][([symb_name[,symb_name]...])]
	{  *n=data_type_length_spec  }

  GO TO st_label

  GO TO (st_label_list)[,]e

  GO TO int_var_name[[,](st_label_list)]

  IF (e) st_label1, st_label2, st_label3

  IF (e) st_label	{  st_label .NE. DO, END DO, END, block IF,
			 or logicalIF  }


  IF (e1) THEN
	block
  ELSE IF (e2) THEN
	block
  ELSE
	block
  END IF


  IMPLICIT data_type_spec(a[,a]...)[,typ(a[,a]...)]...
  IMPLICIT NONE

  INCLUDE'file_specification[/[NO]LIST]'
  INCLUDE'[file_spec](module_name)[/[NO]LIST]'

  INQUIRE (par[,par]...)
	(see File_handling for specifics)

  INTRINSIC intrins_funct_name[,intrins_funct_name]...

  NAMELIST /symbolic_name/namelist[[,]/symb_name/ namelist]...

  OPEN (par[,par]...)
	(see File_handling for specifics)

  PARAMETER (p=c[,p=c]...)
	{p=symbolic_name, c=constant or compile-time constant
	 expression}

  PAUSE[decimal_digit_string]

  PRINT format_spec[,io_list]

  PRINT *[,io_list]	{ * denotes list-directed formatting.  }

  PRINT  namelist_group-name

  PROGRAM symbolic_name

  READ ([UNIT=]u,[FMT=]f[,IOSTAT=ios][,END=s][,ERR=s]) [io_list]
  READ f[,io_list]
    {  u=log_unit_spec, f=format_spec, s=st_label  }
 
  READ ([UNIT=]u,[FMT=]*[,IOSTAT=ios][,END=s][,ERR=s]) [io_list]
  READ *[,io_list]
    {  * denotes list-directed formatting  }

  READ([UNIT=]u,[NML=]namelist_gr_name[,IOSTAT=ios][,END=s][,ERR=s])
  READ namelist_group-name

  READ ([UNIT=]u[,IOSTAT=ios][,END=s][,ERR=s]) [io_list]
    {  u=log_unit_spec, f=format_spec, s=st_label  }

  READ ([UNIT=]u,[FMT=f,REC=r[,IOSTAT=ios][,ERR=s]) [io_list]] 
  READ (u'r,[FMT=]f[,IOSTAT=ios][,ERR=s]) [io_list]
    {  u=log_unit_spec, f=format_spec, s=st_label  r=rec_spec  }

  READ ([UNIT=]u,REC=r[,IOSTAT=ios][,ERR=s]) [io_list]
  READ (u'r[,IOSTAT=ios][,ERR=s]) [io_list]

  READ ([UNIT=]u,[FMT=]f,key_specifier[,KEYID=key-of-ref_spec]
	[,IOSTAT=ios][,ERR=s]) [io_list]
  READ ([UNIT=]u,key_spec[,KEYID=key-of-ref_spec][,IOSTAT=ios]
	[,ERR=s]) [io_list]

  READ ([UNIT=]c,[FMT=]f[,IOSTAT=ios][,ERR=s][END=s]) [io_list]
  { u=log_unit_spec, f=format_spec, s=st_label c=internal_file_spec }
  
  RETURN[integer_value]

  REWIND([UNIT=]log_unit_spec[,IOSTAT=ios][,ERR=st_label]
  REWIND log_unit_spec

  REWRITE ([UNIT=]u,[FMT=]f,[,IOSTAT=ios][,ERR=s]) [io_list]
  REWRITE ([UNIT=]u[,IOSTAT=ios][,ERR=s]) [io_list]
    {  u=log_unit_spec, f=format_spec, s=st_label  }

  SAVE [a[,a]...]

  Statement Function
  f([symbolic_name[,symbolic_name]...]) = e

  STOP [decimal_digit_string]

  SUBROUTINE symbolic_name[([p[,p]...])]
	{p = symbolic name or an alternate return specifier (*) }

  TYPE format_spec[,io_list]

  TYPE*[,io_list]	{ * denotes list-directed formatting}

  TYPE namelist_groupname

  Type Declaration
  typ v[/clist/][,v[/clist/]...
	{Where:
	 typ is one of the following data type specifiers:
		BYTE		LOGICAL
		INTEGER		LOGICAL*1
		INTEGER*2	LOGICAL*2
		INTEGER*4	LOGICAL*4
		REAL		COMPLEX
		REAL*4		COMPLEX*8
		REAL*8		COMPLEX*16
		REAL*16		DOUBLE PRECISION
		CHARACTER*len	DOUBLE COMPLEX
		CHARACTER*(*)
	 v is a variable name, array name, function or function
		entry name, or an array declarator.  The name
		can optionally be followed by a data type length 
		specifier (*n).  For character entities, the
		length specifier can be *len or *(*).
	 clist is an initial value or values to be assigned to
		to the immediately preceding variable or array
		element.
	 The symbolic names (v) are assigned the specified data
		type.  }

  UNLOCK ([UNIT=]log_unit_specifier[,IOSTAT=ios][,ERR=st_label])
  UNLOCK log_unit_spec

  VIRTUAL a(d)[,a(d)]...

  WRITE ([UNIT=]u,[FMT=]f[IOSTAT=ios][,ERR=s]) [io_list]
    {  u=log_unit_spec, f=format_spec, s=st_label  }

  WRITE ([UNIT=]u,REC=rec_spec,[FMT=]f[,IOSTAT=ios][,ERR=s]) [io_list]
  WRITE (u'rec_spec,f[,ERR=s]) [io_list]

  WRITE ([UNIT=]u,REC=rec_spec[,IOSTAT=ios][,ERR=s]) [io_list]
  WRITE (u'rec_spec[,IOSTAT=spec][,ERR=s]) [io_list]

2 DATA_TYPES

	BYTE

	LOGICAL
		LOGICAL*1

		LOGICAL*2

		LOGICAL*4

	INTEGER
		INTEGER*2

		INTEGER*4

	REAL
		REAL*4

		REAL*8

		DOUBLE PRECISION

		REAL*16

	COMPLEX
		COMPLEX*8

		COMPLEX*16

		DOUBLE COMPLEX

	CHARACTER*len

	CHARACTER*(*)

3 BYTE

  BYTE

  RANGE:	The 1-byte storage area can contain the logical 
		values true or false, a single character, or
		integers in the range -128 to 127.

  LENGTH:	1 byte of storage (8 bits)

  REPRESENTATION:	   45 (decimal)
			'55'O (octal)
			'2D'X (hex)
3 LOGICAL

  LOGICAL

  RANGE:	.TRUE. or .FALSE.

  LENGTH:	Either two or four bytes are allocated depending on
		the setting of the [NO]I4 qualifier.  The default
		allocation is four bytes.

		LOGICAL*1, LOGICAL*2, LOGICAL*4, contain respectively,
		1, 2, or 4, bytes.

3 INTEGER_

  See INTEGER2 and INTEGER4.  Depending upon the [NO]I4 qualifier,
  either one of these formats will be used.  INTEGER*4 is the
  default.

3 INTEGER2

  INTEGER*2

  RANGE:		-32768 to 32767

  LENGTH:		2 bytes of storage

  REPRESENTATION:	0			54786
			-45			+4882
			'427'O			'67F'X
			'177777'O  is	-1(decimal)
			'FFFF'X    is	-1(decimal
			'100000'O  is	-32768(decimal)

3 INTEGER4

  INTEGER*4

  RANGE:		-2,147,483,648 to 2,147,483,647

  LENGTH:		4 bytes of storage

  REPRESENTATION:	'FFFFFFFF'X is -2147483648(decimal)
			'37777777777'O is -2147483648
			0		54784
			22		+4788

3 REAL4

  REAL*4		REAL

  (REAL is the same as REAL*4 in all conditions.)


  RANGE:		magnitude may range from
			approximately 0.29E-38 to 1.7E38

  SIGNIFICANT DIGITS:	7

  LENGTH:		4 bytes of storage

  REPRESENTATION:		3.14159			8E-4
			    27564.2E+25			+25E-1
				2.0E1			2.000000000

3 REAL8

  (DOUBLE PRECISION is the same as REAL*8 in all conditions.  )

  RANGE:		magnitude may range from approximately
			0.29D-38 to 1.7D38 for the D_floating
			implementation, or 0.56D-308 to 0.9D308
			for the G_floating implementation

  SIGNIFICANT DIGITS:	typically 16 for D_floating or 15 for
			G_floating

  LENGTH:		8 bytes of storage

  REPRESENTATION:		3.14159			8D-4
			    27564.2D+25			+25D1

				2.0D121 (valid only as a
					 G_floating)

3 REAL16

  REAL*16

  RANGE:		magnitude may range from approximately
			0.84Q-4932 to 0.59Q4932

  SIGNIFICANT DIGITS:	typically 33 digits 
  
  LENGTH:		16 bytes of storage

  REPRESENTATION:		3.14159			8Q-4
			    27564.2Q+25			+25Q1
				2.0Q121 

3 COMPLEX

  COMPLEX*8			COMPLEX

  (COMPLEX is the same as COMPLEX*8 in all conditions.  )

  RANGE:		magnitude may range from
			approximately 0.29E-38 to 1.7E38

  SIGNIFICANT DIGITS:	7

  LENGTH:		8 bytes of storage

  REPRESENTATION:	(1.70398,-17777)	(145E+2,0.)

3 COMPLEX16

  COMPLEX*16			DOUBLE COMPLEX

  (COMPLEX and DOUBLE COMPLEX are the same in all conditions.)

  RANGE:		magnitude may range from approximately
			0.29D-38 to 1.7D38 for the D_floating
			implementation, or 0.56D-308 to 0.9D308
			for the G_floating implementation

  SIGNIFICANT DIGITS:	typically 16 for D_floating or 15 for
			G_floating

  LENGTH:		16 bytes of storage

  REPRESENTATION:	(1.70398,-17777)	(145D+2,0.)
			(one of the pair must be REAL*8 constant)

3 CHARACTER

  CHARACTER

  The length of a character constant must be in the range 1 to
  2000.

  The storage requirements (in bytes) is the number of characters
  specified, which can be in the range 1 to 65535.  

  REPRESENTATION:	'WHAT!?'	'C3P0+R2D2'
			'AIN''T'
