MODULE Global
    INTEGER, SAVE, ASYNCHRONOUS :: array(4,4,4) = 0
END MODULE Global

PROGRAM Main
    USE Global
    INTEGER :: id
    OPEN (UNIT=11, ASYNCHRONOUS='yes', FILE='/dev/tty')
    READ (UNIT=11, FMT=*, ASYNCHRONOUS='yes', ID=id) array
    CALL Fred(array(3,2:3,2))
    WAIT (UNIT=11, ID=id)
    PRINT *, 'Main', array

CONTAINS

    SUBROUTINE Fred (arg)
        INTEGER, ASYNCHRONOUS :: arg(:)
        INTERFACE
            SUBROUTINE Joe (arg)
                INTEGER :: arg(:)
            END SUBROUTINE Joe
        END INTERFACE
        CALL Joe(arg)
    END SUBROUTINE Fred

END PROGRAM Main

SUBROUTINE Joe (arg)
    INTEGER :: arg(:)
    CALL Alf(arg)
END SUBROUTINE Joe

SUBROUTINE Alf (arg)
    INTEGER :: arg(*)
    CALL Bert
END SUBROUTINE Alf

SUBROUTINE Bert
    PRINT *, 'Now start typing'
END SUBROUTINE Bert



111  112  113  114  121  122
123  124  131  132  133  134
141  142  143  144  211  212
213  214  221  222  223  224
231  232  233  234  241  242
243  244  311  312  313  314
321  322  323  324  331  332
333  334  341  342  343  344
411  412  413  414  421  422
423  424  431  432  433  434
441  442  443  444



Intel 10.1 'supports' asynchronous I/O by doing it synchronously, which
is a very reasonable solution to this fiasco.  No other compiler I
currently have access to supports it.

You can test what it would do by removing the I/O in the main program
and replacing subroutine Bert by the following.  Yes, I know that this
makes the program not conforming.

SUBROUTINE Bert
    USE Global
    DO i = 1, 4
        DO j = 1, 4
            DO k = 1, 4
                array(i,j,k) = i+10*j+100*k
            END DO
        END DO
    END DO
END SUBROUTINE Bert