SUBROUTINE

 Begins a subroutine subprogram and names the dummy arguments.  The
 CALL statement transfers control to a subroutine subprogram; a
 RETURN or END statement returns control to the calling program
 unit.  Statement format:

    [prefx] SUBROUTINE nam [([p[,p]...])]

    prefx Is one of the following keywords:

          RECURSIVE    Permits direct recursion to occur.  
          
          PURE         Restricts the procedure from having
                       side effects.

          ELEMENTAL    Specifies PURE with certain constraints
                       on a dummy argument:

                       o It must be scalar and cannot have the 
                         POINTER attribute. 
                       o It cannot appear in a specification 
                         expression, except as an argument to the 
                         BIT_SIZE, KIND, or LEN intrinsic functions 
                         or the numeric inquiry intrinsic functions
                       o It must not be *
                       o It must not be a dummy procedure

                       An explicit interface must be visible to the
                       caller of an ELEMENTAL procedure.

                       If ELEMENTAL is specified, RECURSIVE must not 
                       be specified.

    nam  Is a symbolic name for the subroutine.  The name must 
         be unique among all global names in the program.

    p    Is an unsubscripted variable name specifying a dummy 
         argument.  An asterisk (*) as a dummy argument specifies 
         that the actual argument is an alternate return argument.  

 The arguments must agree in order, number, and type with the actual
 arguments of the statement invoking the subroutine.  A dummy
 argument must not be defined as an array with more elements than
 the actual argument holds.  When control transfers to the
 subroutine, the values of any actual arguments in the CALL
 statement are associated with any corresponding dummy arguments in
 the SUBROUTINE statement.  The statements in the subprogram are
 then executed.

 The SUBROUTINE statement must be the first statement of a
 subroutine, unless an OPTIONS statement is specified.

 A subroutine subprogram cannot contain a FUNCTION statement, a
 BLOCK DATA statement, a PROGRAM statement, or another SUBROUTINE
 statement.

 ENTRY statements are allowed to specify multiple entry points in
 the subroutine.

 The array declarator for a dummy argument can itself contain
 integer values that are dummy arguments or are references to a
 common block, providing for adjustable size arrays in subroutines.
 The upper bound of the array declarator for a dummy argument can be
 specified as an asterisk, in which case the upper bound of the
 dummy argument assumes the size of the upper bound of the actual
 argument.  The size in a character string declarator for a dummy
 argument can be specified as an asterisk in parentheses, in which
 case the size of the actual argument is passed to the dummy
 argument.

 The values of the actual arguments in the invoking program unit
 become the values of the dummy arguments in the function.  If you
 modify a dummy argument, the corresponding actual argument in the
 invoking program unit is also modified; the actual argument must be
 a variable if it is to be modified.

 If the actual argument is a character constant, the dummy argument
 can be either character or numeric in type, unless the name of the
 subprogram being invoked is a dummy argument in the invoking
 program unit.  If the actual argument is a Hollerith constant, the
 dummy argument must be numeric.