[BACK]Return to ex.mar CVS log [TXT] [DIR] Up to [Research Unix] / researchv10no / cmd / f2c

Annotation of researchv10no/cmd/f2c/ex.mar, revision 1.1

1.1     ! root        1: I.f&3�&$PP  subroutine zork(i)
        !             2:        integer i,j
        !             3:        inquire(4,recl=i,nextrec=j)
        !             4:        call foo(j)
        !             5:        end
        !             6: I1.f&�[��55  data i/o'12'/
        !             7:        j = o'13'
        !             8:        call foo(i,j,b'101')
        !             9:        end
        !            10: I2.f&Dc��99  function foo(x)
        !            11:        integer x
        !            12:        foo = alog10(float(x))
        !            13:        end
        !            14: L.f&Թ�Q&jj  logical b(3)
        !            15:        integer i
        !            16:        b(1) = .false.
        !            17:        b(2) = .true.
        !            18:        b(3) = .false.
        !            19:        write(*,*) (b(i), i = 1, 3)
        !            20:        end
        !            21: a.f&]���&33  integer i3(3)
        !            22:        data i3/1,2,3/
        !            23:        write(*,*) i3
        !            24:        end
        !            25: a1.f&�<�8OO  subroutine goo(a,n)
        !            26:        integer j, n
        !            27:        double precision a(n)
        !            28:        call foo(a(j))
        !            29:        end
        !            30: a2.f&�h��.&�  subroutine goo(a,n)
        !            31:        integer j, n
        !            32:        double precision a(n)
        !            33:        common /zork/b
        !            34:        double precision b(4), be(4), c(4), ce(4)
        !            35:        equivalence (b(1), be(1)), (c(1),ce(1))
        !            36:        logical init(2), init1
        !            37:        real z(4)
        !            38:        data init/.true., .true./, init1/.false./
        !            39:        call foo(z(n), 23, init1, init, init(2), be(j), a(j), ce(j))
        !            40:        end
        !            41: b.f&s����  block data
        !            42:        common /zork/ a, b, c
        !            43:        double precision a(2)
        !            44:        integer b(2)
        !            45:        logical c
        !            46:        data a/1.d0, 2.d0/
        !            47:        data b/3, 4/
        !            48:        data c/.true./
        !            49:        end
        !            50: b1.f&=��   �        call foo(o'1')
        !            51:        end
        !            52: c.f&�
        !            53: �yy       integer function c(n)
        !            54:        character*1 a(4)
        !            55:        data a/'a','b','c','d'/
        !            56:        c = ichar(a(n)) + ichar(a(n+1))
        !            57:        call zork(a(n))
        !            58:        end
        !            59: c1.f&&x��BB  subroutine foo(i,c)
        !            60:        character*1 c
        !            61:        integer i
        !            62:        i = ichar(c)
        !            63:        end
        !            64: c2.f&o���bb  character*8 zork
        !            65:        data zork/'abcdefhj'/
        !            66:        n = ichar(zork(3:3))
        !            67:        call foo(n,ichar(zork(4:4)))
        !            68:        end
        !            69: c3.f&�9�
u��  character*1 c(10)
        !            70:        data c/'a','b','c','d','e','f','g','h','i','j'/
        !            71:        do 10 i = 1, 10
        !            72:                if (ichar(c(i)) .lt. ichar('e')) call foo(i)
        !            73:  10            continue
        !            74:        end
        !            75: c4.f&W]�1CC  subroutine zork(a,b)
        !            76:        character*8 c
        !            77:        call foo(a,c)
        !            78:        b = a(c)
        !            79:        end
        !            80: c5.f&o]��OO  subroutine zork(a,b)
        !            81:        external a
        !            82:        character*8 c
        !            83:        call foo(a,c)
        !            84:        b = a(c)
        !            85:        end
        !            86: c6.f&�I�
��  character*72 buffer
        !            87:        read(*,'(A)') buffer
        !            88:        j = 1
        !            89:        do 10 i = 1, 72
        !            90:                if (buffer(i:i) .ne. ' ') j = i
        !            91:  10            continue
        !            92:        write(*, '(A)') buffer(1:j)
        !            93:        end
        !            94: c7.f&BO����  character*72 buffer
        !            95:        read(*,'(A)') buffer
        !            96:        j = 2
        !            97:        do 10 i = 1, 72
        !            98:                if (buffer(i:i) .ne. ' ') j = i+1
        !            99:  10            continue
        !           100:        write(*, '(A)') buffer(1:j-1)
        !           101:        end
        !           102: c8.f&�V��      ��     subroutine foo(i,j)
        !           103:        character*72 b
        !           104:        integer j(*), k, L(2)
        !           105:        k = i
        !           106:        L(2) = k
        !           107:        call goo(b(1:i), b(2:i), b(1:i+1), b(1:j(2)), b(1:k), b(1:L(2)))
        !           108:        end
        !           109: c9.f&�n�>
        !           110: ��    common /zork/ a, b, c
        !           111:        double precision a(3), a1
        !           112:        integer b(4), b1
        !           113:        logical c(2), c1
        !           114:        equivalence (a(3), a1), (b(2), b1), (c(1), c1)
        !           115:        call foo(a,a1,b,b1,c,c1)
        !           116:        end
        !           117: ca.f&���AA  integer function c(n,a)
        !           118:        character*1 a(4)
        !           119:        c = ichar(a(n))
        !           120:        end
        !           121: cb.f&�i�n�&  program main
        !           122: �eCOMMON RVCN01,IVCN01,IVCN02,IACN11(20)
        !           123:        ivcn01 = 3
        !           124:        iacn11(13) = 23
        !           125:        call zork
        !           126:        end
        !           127:        subroutine zork
        !           128: �=COMMON //RVCN01
        !           129:        rvcn01 = 4.2
        !           130:        call zap
        !           131:        end
        !           132:        subroutine zap
        !           133: �HCOMMON RVDN01,IVCN01,IVCN02
        !           134:        ivcn02 = 77
        !           135:        call zot
        !           136:        end
        !           137:        subroutine zot
        !           138: �RCOMMON RVCN01,IVCN01,IVCN02,IACN11
        !           139:        iacn11 = -49
        !           140:        call last
        !           141:        end
        !           142:        subroutine last
        !           143: �fCOMMON RVCN01,IVCN01,IVCN02,IACN11(20)
        !           144:        write(*,*) rvcn01, ivcn01, ivcn02, iacn11(1), iacn11(13)
        !           145:        end
        !           146: cb1.f&��R
�  program main
        !           147: �eCOMMON RVCN01,IVCN01,IVCN02,IACN11(20)
        !           148:        ivcn01 = 3
        !           149:        iacn11(13) = 23
        !           150:        call zork
        !           151:        end
        !           152:        subroutine last
        !           153: ��COMMON RVCN01,IVCN01,IVCN02,IACN11(20)
        !           154:        equivalence (ivcn01,k)
        !           155:        write(*,*) rvcn01, ivcn01, ivcn02, iacn11(1), iacn11(13),k
        !           156:        end
        !           157: cb2.f&<��ph  program main
        !           158: �TCOMMON RVCN01,IVCN01,IVCN02,IACN11(20)
        !           159:        ivcn01 = 3
        !           160:        iacn11(13) = 23
        !           161:        call zork
        !           162:        end
        !           163: cb3.f&����.  program main
        !           164: �eCOMMON RVCN01,IVCN01,IVCN02,IACN11(20)
        !           165:        ivcn01 = 3
        !           166:        iacn11(13) = 23
        !           167:        call zork
        !           168:        end
        !           169:        subroutine zork
        !           170: �=COMMON //RVCN01
        !           171:        rvcn01 = 4.2
        !           172:        call zap
        !           173:        end
        !           174:        subroutine zap
        !           175: �HCOMMON RVDN01,IVCN01,IVCN02
        !           176:        ivcn02 = 77
        !           177:        call zot
        !           178:        end
        !           179:        subroutine zot
        !           180: �RCOMMON RVCN01,IVCN01,IVCN02,IACN11
        !           181:        iacn11 = -49
        !           182:        call last
        !           183:        end
        !           184:        subroutine last
        !           185: �~COMMON RVCN01,IVCN01,IVCN02,IACN11(20)
        !           186:        write(*,*) rvcn01, ivcn01, ivcn02, iacn11(1), iacn11(13), iacn11(15)
        !           187:        end
        !           188:        block data
        !           189: �BCOMMON RVCN01,IVCN01,IVCN02,IACN11(20)
        !           190:        data iacn11(15)/102/
        !           191:        end
        !           192: cd.f&q=�;VV  subroutine zork(i)
        !           193:        integer x
        !           194:        integer i(x)
        !           195:        common /com/ x
        !           196:        call zork(i(3), x)
        !           197:        end
        !           198: cf.f&�&����$CHARACTER*10 FUNCTION CF716(IVD001)
        !           199: �>IF (IVD001 - 2) 70010, 70020, 70030
        !           200: 70010 CF716 = 'FIRST AID'
        !           201: �"RETURN
        !           202: 70020 CF716 = 'SECONDRATE'
        !           203: �"RETURN
        !           204: 70030 CF716 = 'THIRDCLASS'
        !           205: �RETURN
        !           206: �END
        !           207: cx2.f&GA��jkj  complex c(5,3)
        !           208:        c(3,2) = (2,2)
        !           209:        call foo(c)
        !           210:        end
        !           211:        subroutine foo(c)
        !           212:        complex c(5,3)
        !           213:        c(2,2) = (1,1)
        !           214:        end
        !           215: d.f&IJ�,ABA  subroutine foo(f)
        !           216:        external f
        !           217:        character*32 f
        !           218:        call goo(f)
        !           219:        end
        !           220: d1.f&�J�����  subroutine foo(f)
        !           221:        external f
        !           222:        character*32 f, x
        !           223:        x = f(6)
        !           224:        call goo(f, x)
        !           225:        end
        !           226:        subroutine goo(f,x)
        !           227:        external f
        !           228:        character*(*) f, x
        !           229:        write(*,*) x, f(3)
        !           230:        end
        !           231: d2.f&���V`a`  subroutine foo(j, k)
        !           232:        integer j, k
        !           233:        real r
        !           234:        do 10 r = goo(min(j,k)), 10
        !           235:  10            write(*,*) r
        !           236:        end
        !           237: d3.f&!���FGF  character*3 zot
        !           238:        data r/4.2/
        !           239:        data zot/'abc'/
        !           240:        call foo(r, zot)
        !           241:        end
        !           242: de.f&�V� F&       &�>SUBROUTINE SN707(IVD001,IVD002,IVD003,I2D001,I2D002,IVD004)
        !           243: C
        !           244: �;DIMENSION I2D001(IVD002/3:3,1:5),I2D002(1:2,1:IVD003**2)
        !           245: C
        !           246: �?IF (IVD001 - 1) 70010, 70010, 70020
        !           247: 70010 IVD004 = I2D001(1,5)
        !           248: �4RETURN
        !           249: 70020 IVD004 = I2D002(1,4)
        !           250:        call foo(ivd003)
        !           251: �RETURN
        !           252: �END
        !           253: doo.f&B��!s+,+  subroutine doo(n,x)
        !           254:        read(7,rec=n) x
        !           255:        end
        !           256: e.f&@n�"��&�&�  subroutine comtst
        !           257:        double precision d, x(5)
        !           258:        integer y, z, z1
        !           259:        equivalence (x(3),y)
        !           260:        integer*2 i2(8), i21, i22, i23
        !           261:        integer i4, i41, i42
        !           262:        equivalence (i2(4),d)
        !           263:        common /xyz/ a,b
        !           264:        common /pqr/ c, r1
        !           265:        common /abc/ e
        !           266:        double precision a(3), c(4), d1(5),� d2, e(3)
        !           267:        real b(2), r1(5)
        !           268:        equivalence (i21,b), (i22,r), (i4,i2(3)), (i41,a(2)),(i42,e(2))
        !           269:        equivalence (i23,i2(3)), (z,z1), (d2,d1(3))
        !           270: c      automatic x, y
        !           271:        call foo(x,y,i2,d,a(2),b(2),c(2),d,e(2),i21,i22,i2(2),d1(2))
        !           272:        end
        !           273: e1.f&c�#��N�CHARACTER*1  IFMT1(20)
        !           274: �CHARACTER*20 IFMT1C
        !           275: �EQUIVALENCE (IFMT1(1), IFMT1C)
        !           276: �DATA IFMT1( 1) /'('/
        !           277: �DATA IFMT1( 2) /'1'/
        !           278: �DATA IFMT1( 3) /'A'/
        !           279: �DATA IFMT1( 4) /'1'/
        !           280: �DATA IFMT1( 5) /','/
        !           281: �DATA IFMT1( 6) /'5'/
        !           282: �DATA IFMT1( 7) /'X'/
        !           283: �DATA IFMT1( 8) /','/
        !           284: �DATA IFMT1( 9) /'2'/
        !           285: �DATA IFMT1(10) /'A'/
        !           286: �DATA IFMT1(11) /'1'/
        !           287: �DATA IFMT1(12) /','/
        !           288: �DATA IFMT1(13) /' '/
        !           289: �DATA IFMT1(14) /' '/
        !           290: �DATA IFMT1(15) /'X'/
        !           291: �DATA IFMT1(16) /','/
        !           292: �DATA IFMT1(17) /'2'/
        !           293: �DATA IFMT1(18) /'A'/
        !           294: �DATA IFMT1(19) /'1'/
        !           295: �DATA IFMT1(20) /')'/
        !           296: �WRITE(6, IFMT1C)
        !           297: �END
        !           298: e2.f&�f�$5�q"  common /abc/ a
        !           299:        equivalence(a,b)
        !           300: �CHARACTER*1  IFMT1(20)
        !           301: �CHARACTER*20 IFMT1C
        !           302: �EQUIVALENCE (IFMT1(1), IFMT1C)
        !           303: �DATA IFMT1( 1) /'('/
        !           304: �DATA IFMT1( 2) /'1'/
        !           305: �DATA IFMT1( 3) /'A'/
        !           306: �DATA IFMT1( 4) /'1'/
        !           307: �DATA IFMT1( 5) /','/
        !           308: �DATA IFMT1( 6) /'5'/
        !           309: �DATA IFMT1( 7) /'X'/
        !           310: �DATA IFMT1( 8) /','/
        !           311: �DATA IFMT1( 9) /'2'/
        !           312: �DATA IFMT1(10) /'A'/
        !           313: �DATA IFMT1(11) /'1'/
        !           314: �DATA IFMT1(12) /','/
        !           315: �DATA IFMT1(13) /' '/
        !           316: �DATA IFMT1(14) /' '/
        !           317: �DATA IFMT1(15) /'X'/
        !           318: �DATA IFMT1(16) /','/
        !           319: �DATA IFMT1(17) /'2'/
        !           320: �DATA IFMT1(18) /'A'/
        !           321: �DATA IFMT1(19) /'1'/
        !           322: �DATA IFMT1(20) /')'/
        !           323: �WRITE(6, IFMT1C)
        !           324: �END
        !           325: e3.f&���%��  subroutine comtst
        !           326:        double precision d, x(5)
        !           327:        integer y, z, z1
        !           328:        equivalence (x(3),y)
        !           329:        integer*2 i2(8), i21, i22, i23
        !           330:        integer i4, i41, i42
        !           331:        equivalence (i2(4),d)
        !           332:        common /xyz/ a,b
        !           333:        common /pqr/ c, r1
        !           334:        common /abc/ e
        !           335:        double precision a(3), c(4), d1(5),� d2, e(3)
        !           336:        real b(2), r1(5)
        !           337:        equivalence (i21,b), (i22,r), (i4,i2(3)), (i41,a(2)),(i42,e(2))
        !           338:        equivalence (i23,i2(3)), (z,z1), (d2,d1(3))
        !           339:        data r/1.2/, i4/4321/, i2(7),i2(8)/7,8/, d2/3.4/, d1(5)/5.6/
        !           340: c      automatic x, y
        !           341:        call foo(x,y,i2,d,a(2),b(2),c(2),d ,e(2),i21,i22,i2(2),d1(2))
        !           342:        end
        !           343: e4.f&�K�&        �&�&�    common /zork/ a, b
        !           344:        double precision a(10), ae, c(4), ce
        !           345:        integer b(3), be
        !           346:        equivalence (a(3),ae), (b(2), be), (c(3), ce)
        !           347:        call foo(ae, be, ce)
        !           348:        end
        !           349:        subroutine foo(a,b,c)
        !           350:        double precision a, c
        !           351:        integer b
        !           352:        common /zork/ ac, bc
        !           353:        double precision ac(10�), ae
        !           354:        integer bc(3), be, j, k
        !           355:        equivalence (ac(5),ae), (bc(3), be)
        !           356:        m = 3
        !           357:        j = be + bc(1)
        !           358:        k = j + 3
        !           359:        call zoo(a,b,c,ae,be,j,k,m)
        !           360:        end
        !           361: ec.f&ó�'�!���  subroutine gulp
        !           362:        common /abc/x,y
        !           363:        double precision x(4)
        !           364:        integer y(3)
        !           365:        double precision xe
        !           366:        integer ye
        !           367:        equivalence (xe, y(2)), (ye, x(2))
        !           368:        call foo(xe, ye)
        !           369:        end
        !           370: f.f&�H�({"/0/  double precision x
        !           371:        x = 0.3
        !           372:        call foo(x)
        !           373:        end
        !           374: f0.f&F[�)�"|&u&Y  write(6,90001)
        !           375: 90001 FORMAT(' ','\\','\\','\\','\\','xy\\','\\','\\','\\','\\','\\','\\
        !           376: �D1','\\','\\','\\','\\','\\','\\','\\','\\','\\','\\','\\','\\','\\'
        !           377: �D2,'\\','\\','\\','\\','\\','\\','\\','\\','\\','\\','\\','\\','\\',
        !           378: �C3'\\','\\','\\','\\','\\','\\','\\','\\','\\','\\','\\','\\','\\',
        !           379: �D4'\\','\\','\\','\\','\\','\\','\\','\\','\\','\\','\\','End')
        !           380:        end
        !           381: f1.f&9��*h$��V  write(6,90001)
        !           382: 90001 FORMAT(' Here is a very long string which should be broken into
        !           383: �C1several pieces while it is being printed out.  The pieces will be
        !           384: �H2different, depending on whether or not the -A flag is in effect')
        !           385:        end
        !           386: f2.f&�S�+t%���  integer i,j
        !           387:  10    format(' Hello, world!')
        !           388:  20    format(' Hello again.')
        !           389:  30    format(' goodbye!')
        !           390:        assign 10 to i
        !           391:        assign 20 to j
        !           392:        write(6,i)
        !           393:        write(6,j)
        !           394:        assign 30 to i
        !           395:        write(6,i)
        !           396:        end
        !           397: f3.f&,V�,P&$%$  write(6,'(" Hello, world!")')
        !           398:        end
        !           399: foo.f&}2�-�&+,+  integer x(2)
        !           400:        data (x(i),i=1,2)/1,2/
        !           401:        end
        !           402: fp1.f&�
        !           403: �.�&$%$    subroutine foo(x)
        !           404:        x = x + .3
        !           405:        end
        !           406: g.f&4��/2'���  subroutine foo(n)
        !           407:        if (n .le. 3) then
        !           408:                assign 10 to i
        !           409:        else
        !           410:                assign 20 to i
        !           411:                end if
        !           412:        go to i, (10,20)
        !           413:  10    write(*,*) 'got 10'
        !           414:        go to 999
        !           415:  20    write(*,*) 'to 20'
        !           416:  999   end
        !           417: g1.f&��0(���  subroutine foo(n)
        !           418:        go to 2
        !           419: 1      go to i, (10,20)
        !           420:  10    write(*,*) 'got 10'
        !           421:        go to 999
        !           422:  20    write(*,*) 'to 20'
        !           423:        go to 999
        !           424: 2      if (n .le. 3) then
        !           425:                assign 10 to i
        !           426:        else
        !           427:                assign 20 to i
        !           428:                end if
        !           429:        go to 1
        !           430:  999   end
        !           431: goo.f&�@�1�(RSR  logical function zork(i,j,k)
        !           432:        zork = i .eq. j .or. j .eq. k .neqv. j .lt. k
        !           433:        end
        !           434: h.f&���2l)ccW  character*18 h
        !           435:        h = '('' Hello, world!'')'
        !           436:        write(6,h)
        !           437: c      write(6,'('' Hello, world!'')�')
        !           438:        end
        !           439: h0.f&5��3�)DED  write(6,10)
        !           440:  10    format(' Hello\\, world! "Can''t complain."')
        !           441:        end
        !           442: h1.f&�
        !           443: �4\*=>=    subroutine foo(a,b)
        !           444:        character *6 a, b
        !           445:        write(6, a//b)
        !           446:        end
        !           447: h2.f&n�5�*WXW  integer zot(10)
        !           448:        data zot/1h(,1h6,1hh,1h ,1hh,1he,1hl,1hl,1ho,1h)/
        !           449:        write(6,zot)
        !           450:        end
        !           451: h3.f&7W�6:+'('  write(6,10)
        !           452:  10    format(6h hello)
        !           453:        end
        !           454: h4.f&BW�7�+=>=  assign 10 to i
        !           455:        write(6,i)
        !           456: 10     format(' Hello, world!')
        !           457:        end
        !           458: i.f&YN�8�+���  subroutine foo(i,j,c)
        !           459:        character*1 c(4), d
        !           460:        i = ichar(c(3))
        !           461:        j = ichar(d(1))
        !           462:        j = ichar(c(1)) + ichar(c(2)) + ichar('B')
        !           463:        c(2) = char(j)
        !           464:        end
        !           465: i2.f&$�9�,=>=  subroutine foo(j)
        !           466:        character*2 d
        !           467:        j = ichar(d(2)(2:2))
        !           468:        end
        !           469: l.f&�<�:�,��X  subroutine foo(lvcomp, lvn001, lpn002, lpn003)
        !           470:        logical lvcomp, LVN001, lpn002, lpn003
        !           471: �LVN001 = .TRUE.
        !           472: �7LVCOMP = LVN001.EQV.LPN002.AND..TRUE..NEQV.LPN003
        !           473:        end
        !           474: m.f&�@�;�-  data i/5/
        !           475:        j = i + o'2'
        !           476:        end
        !           477: m1.f&�j�<.`a`  write (*,*) 'Hello, world'
        !           478:        write (6,100)
        !           479: 100    format ("I/O, I/O, it's off to work we go")
        !           480:        end
        !           481: n.f&YD�=�.OPO  real for, x, sin
        !           482:        external sin
        !           483:        x = 1. + for(2.d0) + sin(3)
        !           484:        call foo(x)
        !           485:        end
        !           486: o.f&r��>/JKJ  open(4,file='/dev/stderr',blank='null')
        !           487:        write(4,*) 'Hello, world!'
        !           488:        end
        !           489: p.f&b�?s/���  implicit double precision (a-h,o-z)
        !           490:        real zork
        !           491:        parameter(zap=3.4d0, zot=1.2, zork=6.1)
        !           492:        call foo(zap, zot, dble(zot), zork)
        !           493:        end
        !           494: p1.f&k=�@0;<;  parameter (p1 = 0.1, dp1 = 0.1d0)
        !           495:        call foo(p1, dp1)
        !           496:        end
        !           497: p2.f&�i�A{0���  implicit double precision (a-z)
        !           498:        parameter(one=1.0, two=2.0, three=3.0)
        !           499:        call foo(one, two, three)
        !           500:        end
        !           501:        subroutine foo(a,b,c)
        !           502:        real a,b,c
        !           503:        end
        !           504: r.f&�2�B11TUT  read(5,10,end=20,iostat=j) i
        !           505:  10    format(i6)
        !           506:        write(*,*) 'got i, j= ', i, j
        !           507:  20    end
        !           508: r1.f&�4�C�1�  read(5,10,end=20,iostat=j,err=30) i
        !           509:  10    format(i6)
        !           510:        call gotij(i,j)
        !           511:        goto 40
        !           512:  20    call gotend
        !           513:        goto 40
        !           514:  30    call goterr
        !           515:  40    end
        !           516: r2.f&'5�DN2sts  read(5,10,end=20,err=30) i
        !           517:  10    format(i6)
        !           518:        call goti(i)
        !           519:        goto 40
        !           520:  20    call gotend
        !           521:        goto 40
        !           522:  30    call goterr
        !           523:  40    end
        !           524: r3.f&9`�E�2KLK  read(5,10,end=20) i
        !           525:  10    format(i6)
        !           526:        write(*,*) 'got i, j= ', i, j
        !           527:  20    end
        !           528: r4.f&[m�FV3���  character*10 zot(2)
        !           529:        integer i, j, k, l, m
        !           530:        data zot/' 1234 5678', ' -123 -456'/
        !           531:        data i/1/
        !           532:        read(zot(i),10) l, m
        !           533:        read(zot(2),10) j, k
        !           534:  10    format(2i5)
        !           535:        write(*,*) j, k, l, m
        !           536:        end
        !           537: r5.f&n�G04���  call foo('(2i5)')
        !           538:        end
        !           539:        subroutine foo(s)
        !           540:        character*(*)s
        !           541:        character*10 zot
        !           542:        integer l, m
        !           543:        data zot/' 1234 5678'/
        !           544:        read(zot,s) l, m
        !           545:        write(*,*) l, m
        !           546:        end
        !           547: r6.f&Q��H�4���  subroutine foo(s,l,m)
        !           548:        character*(*)s
        !           549:        character*10 zot, s1
        !           550:        integer l, m
        !           551:        data zot/' 1234 5678'/
        !           552:        data s1/'(2i5)'/
        !           553:        read(s1,s) l, m
        !           554:        end
        !           555: s.f&2�I�5s&c&L  double precision function foo(x)
        !           556:        double precision x
        !           557:        double precision y,z
        !           558: �1SECH(Y)=2.*DEXP(-DABS(Y))/(1.+DEXP(-2.*DABS(Y)))
        !           559: �Foo=(SECH(  10.*(X-0.2D0)))**2
        !           560: � *   +(SECH( 100.*(X-0.4D0)))**4
        !           561: � *   +(SECH(1000.*(X-0.6D0)))**6
        !           562: �z=(SECH(  10.*(X-0.2D0)))**2
        !           563: � *   +(SECH( 100.*(X-0.4D0)))**4
        !           564: �4*   +(SECH(1000.*(X-0.6D0)))**6
        !           565:        foo = foo + z
        !           566:        end
        !           567: s1.f&��J'7

  stop 0
        !           568:        end
        !           569: s2.f&�e�KY7&'&  i(ii) = ii
        !           570:        j = 4
        !           571:        k = i(j + 3)
        !           572:        end
        !           573: sf.f&{�L�7BCB  integer i, j
        !           574:        data j/4/
        !           575:        i = 3
        !           576:        x(i) = i*i
        !           577:        write(*,*) x(j)
        !           578:        end
        !           579: sf1.f&s��M8KLK  integer i, j
        !           580:        x(i) = i*i
        !           581:        y(i) = i + 1
        !           582:        j = 3
        !           583:        write(*,*) x(j), y(j)
        !           584:        end
        !           585: sf2.f&ȵ�N{8PQP
        !           586:        integer i, j
        !           587:        data j/3/
        !           588:        x(i) = i*i
        !           589:        y(i) = i + 1
        !           590:        write(*,*) x(j), y(j)
        !           591:        end
        !           592: w.f&�6�O�8UVU  subroutine w(x,n)
        !           593:        real x(*)
        !           594:        integer i,n
        !           595:        write(*,*,end=20) (x(i),i,i=1,n)
        !           596:  20    end
        !           597: x.f&�s�Pj9YZY  subroutine foo(atan,x,y)
        !           598:        double precision x, y
        !           599:        integer atan
        !           600:        x = atan + datan(y)
        !           601:        end
        !           602: b2.f&2Q�Q�9&�  subroutine frog
        !           603:        common /gosh/ x
        !           604:        double precision x(2), w(2)
        !           605:        integer y, v
        !           606:        equivalence (v, w(2))
        !           607:        data y/4/, v/5/
        !           608:        call poly(x,y)
        !           609:        end
        !           610:        block data grog
        !           611:        common /gosh/ x
        !           612:        double precision x(2)
        !           613:        integer z
        !           614:        equivalence (z,x(1))
        !           615:        data z/23/, x(2)/2.2/
        !           616:        end
        !           617: b3.f&���R;�&�  subroutine zap(abc,def, klm, nop)
        !           618:        if (abc .le. def) then
        !           619:        if (klm .ge. nop) then
        !           620:        if (abc + def .le. 0) then
        !           621:        call foo('some string long enough to cause trouble with formatting
        !           622: & of line breaks because it is likely to run over two or three lines
        !           623: & be�cause it is amazingly long',
        !           624: &a, b, c, d, e, f, abc, def, klm, nop, 'another string argument')
        !           625:        call goo(a, b, c, d, e, f, abc, def, klm, nop, g, h, ijk, lmn,
        !           626: &qrs,tuv,wxy,z,a,b,c,d,e,f,g,h)
        !           627:        endif
        !           628:        endif
        !           629:        endif
        !           630:        end
        !           631: bc.f&Z�S       =HH    subroutine sub1
        !           632:        common x(12)
        !           633:        end
        !           634:        subroutine sub2
        !           635:        common x(12)
        !           636:        end
        !           637: cd1.f&=��Tv=((  complex x
        !           638:        data x/1/
        !           639:        call foo(x)
        !           640:        end
        !           641: cd2.f&&��U�=<<  character*15 h
        !           642:        data h/'hello, world!'/
        !           643:        write(*,*) h
        !           644:        end
        !           645: cen.f&���V$>jj  integer function ifunc(n)
        !           646:        complex cfunc, c
        !           647:        ifunc = n + 1
        !           648:        return
        !           649:        entry cfunc(c,x)
        !           650:        cfunc = c + x
        !           651:        end
        !           652: cen1.f&���W�>��  double complex function zfunc(n)
        !           653:        double complex zfunc
        !           654:        complex cfunc, c
        !           655:        zfunc = cmplx(n + 1, n-1)
        !           656:        return
        !           657:        entry cfunc(c,x)
        !           658:        cfunc = c + x
        !           659:        end
        !           660: cen2.f&&�Xk?��  complex function zfunc(n)
        !           661:        complex zfunc
        !           662:        complex cfunc, c
        !           663:        zfunc = cmplx(n + 1, n-1)
        !           664:        return
        !           665:        entry cfunc(c,x)
        !           666:        cfunc = c + x
        !           667:        end
        !           668: cen3.f&�9�Y@��   complex function zfunc(n)
        !           669:         complex zfunc
        !           670:        complex cfunc, c
        !           671:        zfunc = cmplx(n + 1, n-1)
        !           672:        return
        !           673:        entry cfunc(c,x)
        !           674:        cfunc = c + x
        !           675:        end
        !           676: cen4.f&<�Z�@vv  character*10 function foo(n)
        !           677:        character*10 goo
        !           678:        foo = 'something'
        !           679:        return
        !           680:        entry goo(n)
        !           681:        goo = 'something else'
        !           682:        end
        !           683: cf0.f&�z�[\A  call foo('abc')
        !           684:        end
        !           685: cf1.f&�}�\�A>>  character*4 function zork(n)
        !           686:        zork = 'something'
        !           687:        n = 4
        !           688:        end
        !           689: cf2.f&���]�Ar�%CHARACTER*(*) FUNCTION CF717(CVD001)
        !           690: �CHARACTER*(*) CVD001
        !           691: �CF717 = CVD001
        !           692: �RETURN
        !           693: �END
        !           694: cf3.f&aP�^�B��  subroutine gulp(cf1, thing)
        !           695:        character*(*) cf1, cf2, thing
        !           696:        external cf1, cf2
        !           697:        call foo(cf1, thing)
        !           698:        call goo(cf2, thing)
        !           699:        end
        !           700: cf4.f&
        !           701: l�_&C��$CHARACTER*10 FUNCTION CF716(IVD001)
        !           702: �>IF (IVD001 - 2) 70010, 70020, 70030
        !           703: 70010 CF716 = 'FIRST AID'
        !           704: �"RETURN
        !           705: 70020 CF716 = 'SECONDRATE'
        !           706: �"RETURN
        !           707: 70030 CF716 = 'THIRDCLASS'
        !           708: �RETURN
        !           709: �END
        !           710: cf5.f&{�`
D��  character*10 function recf(n,f)
        !           711:        character*10 f
        !           712:        external f
        !           713:        if (n .le. 0) then
        !           714:                recf = 'abcdefghik'
        !           715:        else
        !           716:                recf = f(0,recf)
        !           717:                endif
        !           718:        end
        !           719: cf6.f&ݾ�a�D99  character*(*) function cf(n)
        !           720:        call foo(cf,'abc',n)
        !           721:        end
        !           722: coo.f&h��bE22  complex function coo(x,y)
        !           723:        coo = cmplx(x,y)
        !           724:        end
        !           725: cx.f&�S�ctEff  complex c(5)
        !           726:        c(3) = (2,2)
        !           727:        call foo(c,2)
        !           728:        end
        !           729:        subroutine foo(c,n)
        !           730:        complex c(5)
        !           731:        c(n) = (1,1)
        !           732:        end
        !           733: cx1.f&�e�d�E^^  subroutine foo(c,n)
        !           734:        complex c(n,n)
        !           735:        c(n,n) = (1,1)
        !           736:        c(1,n-1) = (2,2)
        !           737:        c(n-3,2) = (3,3)
        !           738:        end
        !           739: cx3.f&�}�e�F11  complex function cx(r)
        !           740:        cx = r + 1
        !           741:        return
        !           742:        end
        !           743: e5.f&�8�f�Fee  subroutine snark
        !           744:        common /abc/ x
        !           745:        double precision x(2)
        !           746:        integer y(3)
        !           747:        equivalence (x(1),y(2))
        !           748:        end
        !           749: e6.f&�M�gbGee  subroutine snark
        !           750:        common /abc/ x
        !           751:        double precision x(2)
        !           752:        integer y(5)
        !           753:        equivalence (x(1),y(1))
        !           754:        end
        !           755: ed.f&���h�G��  character*10 abc*5, def(3)
        !           756:        equivalence (def(2),abc)
        !           757:        double precision x(3)
        !           758:        integer y
        !           759:        equivalence (y,x(2))
        !           760:        data x(1),y/ 1.2, 34/
        !           761:        data def(1),abc,def(3)/'it''s howdy', 'doody', 'time'/
        !           762:        call foo(x,y)
        !           763:        end
        !           764: en.f&���i�H�&�  integer function ifunc(n)
        !           765:        character*(*) msg
        !           766:        complex cfunc, c
        !           767:        ifunc = n + 1
        !           768:        return
        !           769:        entry rfunc(x)
        !           770:        rfunc = x + 1.
        !           771:        return
        !           772:        entry ifunc1(msg)
        !           773:        write(*,*) 'ifunc1 has msg = ', msg
        !           774:        ifunc1 = 42
        !           775:        return
        !           776:        entry cfunc(c,x)
        !           777:        cfunc = c + x
        !           778:        end
        !           779:        program g�ulp
        !           780:        character*12 msg
        !           781:        complex c, c1, cfunc
        !           782:        data msg/'hello, there'/, c/(5.6,7.8)/
        !           783:        i = ifunc(23)
        !           784:        x = rfunc(24.)
        !           785:        i1 = ifunc1(msg)
        !           786:        write(*,*) i, x, i1
        !           787:        c1 = cfunc(c, 2.5)
        !           788:        write(*,*) c1
        !           789:        end
        !           790: en0.f&:�j�J��  integer function ifunc(n)
        !           791:        character*(*) msg
        !           792:        ifunc = n + 1
        !           793:        return
        !           794:        entry rfunc(x)
        !           795:        rfunc = x + 1.
        !           796:        return
        !           797:        entry ifunc1(msg)
        !           798:        write(*,*) 'ifunc1 has msg = ', msg
        !           799:        ifunc1 = 42
        !           800:        end
        !           801: en1.f&f�k�Kv&�  integer function ifunc(n)
        !           802:        character*(*) msg
        !           803:        x = n + .5
        !           804:        ifunc = x*x + 1
        !           805:        return
        !           806: c      should be illegal -- x already referenced
        !           807:        entry rfunc(x)
        !           808:        rfunc = x + 1.
        !           809:        return
        !           810:        entry ifunc1(msg)
        !           811:        write(*,*) 'ifunc1 has msg = ', msg
        !           812:        ifunc1 = 42
        !           813:        end
        !           814:        program guzlp
        !           815:        character*12 msg
        !           816:        data msg/'hello, there'/
        !           817:        i = ifunc(23)
        !           818:        x = rfunc(24.)
        !           819:        i1 = ifunc1(msg)
        !           820:        write(*,*) i, x, i1
        !           821:        end
        !           822: en2.f&�l>MM&�  integer function ifunc(n)
        !           823:        character*(*) msg
        !           824:        stf(x) = x + 1
        !           825:        ifunc = stf(n)
        !           826:        return
        !           827:        entry rfunc(x)
        !           828:        rfunc = x + 1.
        !           829:        return
        !           830:        entry ifunc1(msg)
        !           831:        write(*,*) 'ifunc1 has msg = ', msg
        !           832:        ifunc1 = 42
        !           833:        end
        !           834:        program gulp
        !           835:        character*12 msg
        !           836:        data msg/'hello, thQere'/
        !           837:        i = ifunc(23)
        !           838:        x = rfunc(24.)
        !           839:        i1 = ifunc1(msg)
        !           840:        write(*,*) i, x, i1
        !           841:        end
        !           842: en3.f&�i�m�N8� SUBROUTINE SN510(IVD001,IVD002)
        !           843: �INTEGER I2D001(2,2)
        !           844: �COMMON IVC001, IVC002, IVC003
        !           845: �DO 70010 IVN001 = 1, 3
        !           846: �#IVD001 = IVD001 + 1
        !           847: 70010 CONTINUE
        !           848: �IVD002 = IVD001
        !           849: �RETURN
        !           850: �ENTRY EN851(IVD003,IVD004)
        !           851: �IVD004 = 3*IVD003 + 7
        !           852: �RETURN
        !           853: �ENTRY EN852(IVD005)
        !           854: �IVD005 = IVD005 + 100
        !           855: �RETURN
        !           856: �ENTRY EN853(IVD006,IVD007)
        !           857: �IVD007 = 5*(IVD006 + 2) - 16
        !           858: �RETURN
        !           859: �"ENTRY EN854(IVD008,IVD009,IVD010)
        !           860: �#IVD010 = 4*(IVD008 - 2*IVD009) + 5
        !           861: �RETURN
        !           862: �,ENTRY EN855(IVD011, IVD012, IVD013, IVD014)
        !           863: �$IVD014 = IVD013*(2*IVD011 + IVD012)
        !           864: �RETURN
        !           865: �"ENTRY EN856(IVD015,I2D001,IVD016)
        !           866: �IVD016 = 0
        !           867: �DO 70020 IVN001 = 1, IVD015
        !           868: �JDO 70020 IVN002 = 1, IVD015
        !           869: 70020 IVD016 = IVD016 + I2D001(IVN001,IVN002)
        !           870: �RETURN
        !           871: �"ENTRY EN857(RVD017,RVD018,RFD001)
        !           872: �RVD018 = RFD001(RVD017)
        !           873: �RETURN
        !           874: �ENTRY EN858(IVD019,*,*)
        !           875: �RETURN IVD019
        !           876: �ENTRY EN859( )
        !           877: �IVC001 = IVC002 + IVC003
        !           878: �RETURN
        !           879: �ENTRY EN860
        !           880: �IVC003 = IVC001 + IVC002
        !           881: �RETURN
        !           882: �END
        !           883: en4.f&l�n�R��FUNCTION RF513(RVD001)
        !           884: �RF513 = RVD001**2
        !           885: �RETURN
        !           886: �ENTRY EF852(RVD002)
        !           887: �EF852 = 3*RVD002
        !           888: �RETURN
        !           889: �END
        !           890: en5.f&.r�o1S��GSUBROUTINE SN510(IVD001)
        !           891:        entry snark(ivd001,ifcn)
        !           892:        ivd001 = 3
        !           893:        return
        !           894: �ENTRY EN857(IVD001, IFCN)
        !           895: �IVD001 = IFCN(IVD001)
        !           896: �RETURN
        !           897: �END
        !           898: en6.f&�q�p�S��-SUBROUTINE SN510(IVD001)
        !           899:        ivd001 = 3
        !           900:        return
        !           901: �ENTRY EN857(IVD001, IFCN)
        !           902: �IVD001 = IFCN(IVD001)
        !           903: �RETURN
        !           904: �END
        !           905: if.f&�u�q�T++  integer function foo(n)
        !           906:        foo = n + 1
        !           907:        end
        !           908: m1t.f&&K�r�T��#SUBROUTINE M1TIME( CLOCK, PRTOPT )
        !           909: �INTEGER�CLOCK, PRTOPT
        !           910: �CHARACTER*4�LMEAN ,�LAST
        !           911: �DATA�LMEAN/'Mean'/, LAST/'Last'/
        !           912: 
        !           913: �*call foo(clock, prtopt, lmean, last)
        !           914:        end
        !           915: zoo.f&<�s�U�&�BLOCK DATA
        !           916: C�*
        !           917: C�*,  DECLARATION OF VARIABLES IN COMMON BLOCKS
        !           918: �DOUBLE PRECISION AXVD
        !           919: �
COMPLEX AXVC
        !           920: �
LOGICAL AXVB
        !           921: �CHARACTER*6 A6XVK, B6XVK
        !           922: C�*&
        !           923: �1COMMON /BLK9/ AXVS, BXVS, IXVI, AXVD, AXVC, AXVB
        !           924: �COMMON /BLK7/ A6XVK, B6XVK
        !           925: �>DATA AXVS, BXVS, IXVI, AXVD, AXVC, AXVB /34.25E-1, 43.23, 21,
        !           926: �&1�!1.23456, (234.23, 34.9), .TRUE./
        !           927: �'DATA A6XVK, B6XVK /'ABCDE', 'FGHIJK'/
        !           928: C�*&
        !           929: �END
        !           930: z1.f&�A�t_Wcc  double precision function z(a,b)
        !           931:        double precision a, b, zabs
        !           932:        integer unused
        !           933:        z = zabs(a,b)
        !           934:        end
        !           935: z2.f&B�u�Wkk  double precision function z(a,b)
        !           936:        double precision a, b, zabs
        !           937:        integer unused
        !           938:        z = zabs(dcmplx(a,b))
        !           939:        end
        !           940: a3.f&��vwX��  subroutine zot(x)
        !           941:        double precision a, b, c, x
        !           942:        a = x
        !           943:        b = x + .1
        !           944:        c = x + .2
        !           945:        x = (b/c)**2 - 1.0
        !           946:        if ((a/c)**2-1.0) 5,6,7
        !           947:  5     call zip
        !           948:  6     call zap
        !           949:  7     end
        !           950: boo.f&�f6w7Y  subroutine joke(ch)
        !           951:        common /zork/ x
        !           952:        character*1 x(256), ch, y
        !           953:        integer jchar
        !           954:        jchar(y) = ichar(y)
        !           955:        call goo(jchar(ch))
        !           956:        end
        !           957: boo00.f&}_5x�Y4�  common /zot/ a, b, c, d, e, f
        !           958:        real a, c, e, x(7)
        !           959:        double precision b, d, f, y(4)
        !           960:        equivalence (a,x(1)), (b,y(1))
        !           961:        integer i
        !           962:        do 10 i = 1, 7, 3
        !           963:  10            x(i) = i
        !           964:        y(1) = 4
        !           965:        y(4) = 5
        !           966:        d = -3
        !           967:        call foo
        !           968:        a = a + 10
        !           969:        b = b + 10
        !           970:        c = c +10
        !           971:        d = d + 10
        !           972:        e = e +� 10
        !           973:        f = f + 10
        !           974:        call foo
        !           975:        end
        !           976: 
        !           977:        subroutine foo
        !           978:        common /zot/ a, b, c, d, e, f
        !           979:        real a, c, e, x(7)
        !           980:        double precision b, d, f, y(4)
        !           981:        equivalence (a,x(1)), (b,y(1))
        !           982:        integer i
        !           983:        write(*,*) (x(i), i = 1,7,3), (y(i), i = 1, 4, 3)
        !           984:        call goo(b,d)
        !           985:        end
        !           986: 
        !           987:        subro<utine goo(b,d)
        !           988:        double precision b, d
        !           989:        write(*,*) b, d
        !           990:        end
        !           991: boo01.f&u�5y6\r  common /zork/ i,d,j,e
        !           992: �integer*2 i, j
        !           993: �double precision d, e
        !           994: �call foo(i,d,j,e)
        !           995: �end
        !           996: boo1.f&�e6z�\��  subroutine joke(ch,i)
        !           997:        common /zork/ x
        !           998:        character*1 x(256), ch, y
        !           999:        integer i, jchar
        !          1000:        jchar(y) = ichar(y)
        !          1001:        x(jchar(ch)) = char(i)
        !          1002:        end
        !          1003: boo10.f&E�6{e]""  function f(x)
        !          1004:        f = log10(x)
        !          1005:        end
        !          1006: boo11.f&�C7|�]aa  subroutine goo(n)
        !          1007:        common /zork/ w, x
        !          1008:        character*1 w(4), x(2)
        !          1009:        if (x(n) .eq. 'X') call zoo
        !          1010:        end
        !          1011: boo12.f&nn8}2^l&�  subroutine boo12
        !          1012:        common /zork/ a, b, struct
        !          1013:        character*80 a, b, struct,d
        !          1014:        character*40 e(2), f
        !          1015:        equivalence(b,d), (e(2),f)
        !          1016:        write(f,10) f
        !          1017:        write(b,10) a
        !          1018:        write(struct,10) a
        !          1019:  10    format(a80)
        !          1020:        write(d,10) d
        !          1021:        struct = b
        !          1022:        write(b(10:30),10) b(12:32)
        !          1023:        writpe(d(15:25),10) d(20:30)
        !          1024:        write(e(2),f)
        !          1025:        write(f(30:40), f(50:60))
        !          1026:        if (f(4:4) .lt. b(5:5)) f(6:6) = d(7:7)
        !          1027:        end
        !          1028: boo12a.f&{�7~�_zz  subroutine boo12a(n)
        !          1029:        common /zork/ a, b, struct
        !          1030:        character*80 a, b, struct,d
        !          1031:        equivalence(b,d)
        !          1032:        call foo(d(20:30))
        !          1033:        end
        !          1034: boo13.f&-�7c`��  subroutine boo13
        !          1035:        common /zork/ a, b
        !          1036:        character a*3, b(4), c(4), d(8), e(4)
        !          1037:        equivalence (b(1),c(1)), (d(5),e(1))
        !          1038:        if (e(2) .eq. 'z') call grok(e(2))
        !          1039:        if (b(2) .eq. 'x') call grok(b(2))
        !          1040:        if (c(3) .eq. 'y') call grok(c(3))
        !          1041:        end
        !          1042: boo13b.f&/
        !          1043: 8�laOO    character*20 x
        !          1044:        x(7:7) = 'a'
        !          1045:        if (x(8:8) .eq. x(9:9)) call goo(x(10:10))
        !          1046:        end
        !          1047: boo14.f&��7��a�  � subroutine zot(x)
        !          1048:        character*1 x(132)
        !          1049:        x(1) = char(0)
        !          1050:        x(2) = char(1)
        !          1051:        x(3) = char(2)
        !          1052:        x(4) = char(3)
        !          1053:        x(5) = char(4)
        !          1054:        x(6) = char(5)
        !          1055:        x(7) = char(6)
        !          1056:        x(8) = char(7)
        !          1057:        x(9) = char(8)
        !          1058:        x(10) = char(9)
        !          1059:        x(11) = char(10)
        !          1060:        x(12) = char(11)
        !          1061:        x(13) = char(12�)
        !          1062:        x(14) = char(13)
        !          1063:        x(15) = char(14)
        !          1064:        x(16) = char(15)
        !          1065:        x(17) = char(16)
        !          1066:        x(18) = char(17)
        !          1067:        x(19) = char(18)
        !          1068:        x(20) = char(19)
        !          1069:        x(21) = char(20)
        !          1070:        x(22) = char(21)
        !          1071:        x(23) = char(22)
        !          1072:        x(24) = char(23)
        !          1073:        x(25) = char(24)
        !          1074:        x(26) = char(25)
        !          1075:        x(27) = char(26�)
        !          1076:        x(28) = char(27)
        !          1077:        x(29) = char(28)
        !          1078:        x(30) = char(29)
        !          1079:        x(31) = char(30)
        !          1080:        x(32) = char(31)
        !          1081:        x(33) = char(32)
        !          1082:        x(34) = char(33)
        !          1083:        x(35) = char(34)
        !          1084:        x(36) = char(35)
        !          1085:        x(37) = char(36)
        !          1086:        x(38) = char(37)
        !          1087:        x(39) = char(38)
        !          1088:        x(40) = char(39)
        !          1089:        x(41) = char(40�)
        !          1090:        x(42) = char(41)
        !          1091:        x(43) = char(42)
        !          1092:        x(44) = char(43)
        !          1093:        x(45) = char(44)
        !          1094:        x(46) = char(45)
        !          1095:        x(47) = char(46)
        !          1096:        x(48) = char(47)
        !          1097:        x(49) = char(48)
        !          1098:        x(50) = char(49)
        !          1099:        x(51) = char(50)
        !          1100:        x(52) = char(51)
        !          1101:        x(53) = char(52)
        !          1102:        x(54) = char(53)
        !          1103:        x(55) = char(54�)
        !          1104:        x(56) = char(55)
        !          1105:        x(57) = char(56)
        !          1106:        x(58) = char(57)
        !          1107:        x(59) = char(58)
        !          1108:        x(60) = char(59)
        !          1109:        x(61) = char(60)
        !          1110:        x(62) = char(61)
        !          1111:        x(63) = char(62)
        !          1112:        x(64) = char(63)
        !          1113:        x(65) = char(64)
        !          1114:        x(66) = char(65)
        !          1115:        x(67) = char(66)
        !          1116:        x(68) = char(67)
        !          1117:        x(69) = char(68�)
        !          1118:        x(70) = char(69)
        !          1119:        x(71) = char(70)
        !          1120:        x(72) = char(71)
        !          1121:        x(73) = char(72)
        !          1122:        x(74) = char(73)
        !          1123:        x(75) = char(74)
        !          1124:        x(76) = char(75)
        !          1125:        x(77) = char(76)
        !          1126:        x(78) = char(77)
        !          1127:        x(79) = char(78)
        !          1128:        x(80) = char(79)
        !          1129:        x(81) = char(80)
        !          1130:        x(82) = char(81)
        !          1131:        x(83) = char(82�)
        !          1132:        x(84) = char(83)
        !          1133:        x(85) = char(84)
        !          1134:        x(86) = char(85)
        !          1135:        x(87) = char(86)
        !          1136:        x(88) = char(87)
        !          1137:        x(89) = char(88)
        !          1138:        x(90) = char(89)
        !          1139:        x(91) = char(90)
        !          1140:        x(92) = char(91)
        !          1141:        x(93) = char(92)
        !          1142:        x(94) = char(93)
        !          1143:        x(95) = char(94)
        !          1144:        x(96) = char(95)
        !          1145:        x(97) = char(96�)
        !          1146:        x(98) = char(97)
        !          1147:        x(99) = char(98)
        !          1148:        x(100) = char(99)
        !          1149:        x(101) = char(100)
        !          1150:        x(102) = char(101)
        !          1151:        x(103) = char(102)
        !          1152:        x(104) = char(103)
        !          1153:        x(105) = char(104)
        !          1154:        x(106) = char(105)
        !          1155:        x(107) = char(106)
        !          1156:        x(108) = char(107)
        !          1157:        x(109) = char(108)
        !          1158:        x(110) = char(�109)
        !          1159:        x(111) = char(110)
        !          1160:        x(112) = char(111)
        !          1161:        x(113) = char(112)
        !          1162:        x(114) = char(113)
        !          1163:        x(115) = char(114)
        !          1164:        x(116) = char(115)
        !          1165:        x(117) = char(116)
        !          1166:        x(118) = char(117)
        !          1167:        x(119) = char(118)
        !          1168:        x(120) = char(119)
        !          1169:        x(121) = char(120)
        !          1170:        x(122) = char(121)
        !          1171:        x(123)� = char(122)
        !          1172:        x(124) = char(123)
        !          1173:        x(125) = char(124)
        !          1174:        x(126) = char(125)
        !          1175:        x(127) = char(126)
        !          1176:        x(128) = char(127)
        !          1177:        x(129) = char(128)
        !          1178:        x(130) = char(129)
        !          1179:        x(131) = char(130)
        !          1180:        x(132) = char(131)
        !          1181:        end
        !          1182: boo15.f&�p8��kNN  subroutine foo
        !          1183:        character*5 zot
        !          1184:        data zot/'abcde'/
        !          1185:        call glop(zot(3:5))
        !          1186:        end
        !          1187: boo16.f&'m8�#l��!subroutine dlu (na,a,nb,b,error)
        !          1188: �0implicit integer(i-n),double precision(a-h,o-z)
        !          1189: �dimension a(na,na,1),b(na,1)
        !          1190: �integer error
        !          1191: �9entry dlu1f (na,a,nb,b,error)
        !          1192:        call goo(na,a,nb,b,error)
        !          1193: �end
        !          1194: boo17.f&�&8�m..10        format(' hello, world!')
        !          1195:        write(6,10)
        !          1196:        end
        !          1197: boo18.f&�q8�emY&�  subroutine boo12
        !          1198:        common /zork/ a, b, struct
        !          1199:        integer a(10), b(10), struct,d(5)
        !          1200:        integer e(20), f(10)
        !          1201:        equivalence(b(1),d(1)), (e(8),f(1))
        !          1202:        write(*,f) f
        !          1203:        write(*,b) a
        !          1204:        write(struct,10) a
        !          1205:  10    format(a80)
        !          1206:        write(*,d) d
        !          1207:        struct = b(4)
        !          1208:        write(*,b(5)) b(7)]
        !          1209:        write(*,d(3)) d(3)
        !          1210:        write(*,e(2))
        !          1211:        write(f(4), f(8))
        !          1212:        if (f(4) .lt. b(5)) f(6) = d(7)
        !          1213:        end
        !          1214: boo1a.f&��6��nkk  subroutine joke(ch,i)
        !          1215:        common /zork/ x
        !          1216:        character*1 x(256), ch, y
        !          1217:        integer i
        !          1218:        x(ichar(ch)) = char(i)
        !          1219:        end
        !          1220: boo2.f&0{6�toFF  subroutine joke(ch,i)
        !          1221:        character*1 ch
        !          1222:        integer i
        !          1223:        i = ichar(ch)
        !          1224:        end
        !          1225: boo3.f&�q6��oww  subroutine joke(ch,i,ch)
        !          1226:        character*1 ch
        !          1227:        common /zork/ x
        !          1228:        integer x(256), y
        !          1229:        integer i, jchar
        !          1230:        x(ichar(ch)) = i
        !          1231:        end
        !          1232: boo3a.f&1}6�{p��  subroutine joke(ch,i,ch)
        !          1233:        character*1 ch(10,20)
        !          1234:        common /zork/ x
        !          1235:        integer x(256), y
        !          1236:        integer i, jchar
        !          1237:        x(ichar(ch(4,5))) = i
        !          1238:        end
        !          1239: boo4.f&Ł6�#qNN  subroutine zork(a,b)
        !          1240:        character*1 a,b,c,d(4)
        !          1241:        c = a
        !          1242:        d(3) = c
        !          1243:        b = d(2)
        !          1244:        end
        !          1245: boo5.f&�u6��q@@  subroutine boo5(a,b)
        !          1246:        integer a
        !          1247:        character*1 b
        !          1248:        a = a + b
        !          1249:        end
        !          1250: boo6.f&�6��qJJ  subroutine george(a,b)
        !          1251:        character*11 a
        !          1252:        integer b
        !          1253:        a(b:b) = char(b)
        !          1254:        end
        !          1255: boo7.f&A�6�jr��  subroutine bop(n,L)
        !          1256:        logical L
        !          1257:        integer i, nok, notusd
        !          1258:        idnt(notusd) = notusd
        !          1259: 
        !          1260:        if (L) then
        !          1261:                do 10 i = 1, n
        !          1262:                        if (nok(i) .gt. 0) goto 20
        !          1263:  10                    continue
        !          1264:  20                    continue
        !          1265:                else
        !          1266:                        call glop(idnt(3))
        !          1267:                endif
        !          1268:        end
        !          1269: 
        !          1270: boo8.f&��6�dszz  subroutine bop
        !          1271:        integer notusd, i, x(3)
        !          1272:        data (x(i),i=3,1,-1)/1,2,3/
        !          1273:        idnt(notusd) = notusd
        !          1274:        call glop(idnt(3),x,i)
        !          1275:        end
        !          1276: boo9.f&F�6�tDD  subroutine zot(a,b)
        !          1277:        character*1 a, b
        !          1278:        if (a .lt. b) call foo
        !          1279:        end
        !          1280: boo9a.f&�;7�ltLL  subroutine zot(a,b)
        !          1281:        character*1 a, b
        !          1282:        if (a(1) .lt. b(2,3)) call foo
        !          1283:        end
        !          1284: boo9b.f&�k7��t��  subroutine zot(a,b,c)
        !          1285:        character*1 a(3), b*8,c
        !          1286:        if (a(2) .lt. b(2:2)) call foo
        !          1287:        b(1:1) = a(3)
        !          1288:        b(3:3) = a(4)
        !          1289:        b(4:4) = char(34)
        !          1290:        b(5:5) = char(ichar(b(6:6)) + 3)
        !          1291:        b(6:6) = c(3)
        !          1292:        if (a(3) .gt. c(4)) call goo
        !          1293:        b(7:7) = char(ifunc(4))
        !          1294:        end
        !          1295: boo19.f&Ɓ9��u>>  subroutine boo19(n,s)
        !          1296:        character*20 s
        !          1297:        call foo(s(n:n))
        !          1298:        end
        !          1299: d4.f&DB�Svoo  integer x(10)
        !          1300:        double precision y(3)
        !          1301:        equivalence (x(5),y(1))
        !          1302:        data x(4)/'ab'/, y(1)/1.2/
        !          1303:        call foo(x,y)
        !          1304:        end
        !          1305: d5.f&UEB��vqq  integer x(10)
        !          1306:        double precision y(3)
        !          1307:        equivalence (x(5),y(1))
        !          1308:        data x(4)/'abcd'/, y(1)/1.2/
        !          1309:        call foo(x,y)
        !          1310:        end
        !          1311: d6.f&HB�}w~~  character x(20)
        !          1312:        character*4 y
        !          1313:        character*5 z
        !          1314:        equivalence (y,x(4)), (z,x(8))
        !          1315:        data y/'abcd'/, z/'wxyz'/
        !          1316:        call foo(y,z)
        !          1317:        end
        !          1318: d7.f&_B� x��  integer i, j(2)
        !          1319:        data i/'ab'/, j/'cd','ef'/
        !          1320:        call foo(i,j)
        !          1321:        end
        !          1322:        subroutine foo(i,j)
        !          1323:        integer i, j(2)
        !          1324:        write(*,10) i, j
        !          1325:  10    format(' i = ',a4,', j = ',a4,', ',a4)
        !          1326:        end
        !          1327: d8.f&IOB��xGG  integer x(10)
        !          1328:        data x(1)/37/, x(2)/'abc'/, x(3)/42/
        !          1329:        call foo(x)
        !          1330:        end
        !          1331: cb4.f&�DX�Zy0&�  subroutine foo
        !          1332:        common /zork/ a,b
        !          1333:        common /zorki/c, d
        !          1334:        common /zorke/ e, f
        !          1335:        common /zorkei/ g, h
        !          1336:        double precision a, c, e, g, i, k
        !          1337:        integer b, d, f, fe(2), h, he(2), j, L
        !          1338:        equivalence (f,fe(1)), (h,he(1)), (i,j), (k,L)
        !          1339:        data c,d/1.1d0, 2/, g,h/2.2d0,4 3/, k/4/
        !          1340:        call goo(a,b,c,d,e,fe,g,he,i,j,k,L)
        !          1341:        end
        !          1342: iochk.f&m@���z��  program main
        !          1343:        integer ip, ipa(10)
        !          1344:        integer*2 i2p, i2pa(10)
        !          1345:        real rp, rpa(10)
        !          1346:        double precision dp, dpa(10)
        !          1347:        complex cp, cpa(10)
        !          1348:        double complex zp, zpa(10)
        !          1349:        character*10 c10p, c10pa(10)
        !          1350:        logical Lp, Lpa(10)
        !          1351:        call goo(ip, ipa, i2p, i2pa, rp, rpa, dp, d
pa, cp, cpa,
        !          1352: �g1                   zp, zpa, c10p, c10pa, Lp, Lpa)
        !          1353:        end
        !          1354:        subroutine goo(ip, ipa, i2p, i2pa, rp, rpa, dp, dpa, cp, cpa,
        !          1355: �_1                   zp, zpa, c10p, c10pa, Lp, Lpa)
        !          1356:        common /zork/ zc, zca, dc, dca, cc, cca, rc, rca, Lc, Lca,
        !          1357: ��1           ic, ica, i2c, i2ca
        !          1358:        common /zorkc/ c10c, c10ca
        !          1359:        integer i, ic, ip, ia(10), ica(10), ipa(10)
        !          1360:        integer*2 i2, i2c, i2p, i2a(10), i2ca(10), i2pa(10)
        !          1361:        real r, rc, rp, ra(10), rca(10), rpa(10)
        !          1362:        double precision d, dc, dp, da(10), dca(10), dpa(10)
        !          1363:        complex� c, cc, cp, ca(10), cca(10), cpa(10)
        !          1364:        double complex z, zc, zp, za(10), zca(10), zpa(10)
        !          1365:        character*10 c10, c10c, c10p, c10a(10), c10ca(10), c10pa(10)
        !          1366:        logical L, Lc, Lp, La(10), Lca(10), Lpa(10)
        !          1367: 
        !          1368:        read(*,*)
        !          1369: �=x   i, ic, ip, ia(10), ica(3), ipa(4), ia, ica, ipa
        !          1370:        read(*,*)
        !          1371: �Ex   i2, i2c, i2p, i2a(3), i2ca(4), i2pa(5), i2a, i2ca, i2pa
        !          1372:        read(*,*)
        !          1373: �<x   r, rc, rp, ra(3), rca(4), rpa(5), ra, rca, rpa
        !          1374:        read(*,*)
        !          1375: �<x   d, dc, dp, da(3), dca(4), dpa(5), da, dca, dpa
        !          1376:        read(*,*)
        !          1377: �<x   c, cc, cp, ca(3), cca(4), cpa(5), ca, cca, cpa
        !          1378:        read(*,*)
        !          1379: �<x   z, zc, zp, za(3), zca(4), zpa(5), za, zca, zpa
        !          1380:        read(*,*)
        !          1381: �Ix   c10, c10c, c10p, c10a(3),c10ca(4),c10pa(5),c10a,c10ca,c10pa
        !          1382:        read(*,*)
        !          1383: �@x   L, Lc, Lp, La(3), Lca(4), Lpa(5), La, Lca, Lpa
        !          1384:        read(*,'(a)')
        !          1385: �3x   i, ic, ip, ia(10), ica(3), ipa(4), ia, ica, ipa,
        !          1386: �;x   i2, i2c, i2p, i2a(3), i2ca(4), i2pa(5), i2a, i2ca, i2pa,
        !          1387: �2x   r, rc, rp, ra(3), rca(4), rpa(5), ra, rca, rpa,
        !          1388: �2x   d, dc, dp, da(3), dca(4), dpa(5), da, dca, dpa,
        !          1389: �2x   c, cc, cp, ca(3), cca(4), cpa(5), ca, cca, cpa,
        !          1390: �2x   z, zc, zp, za(3), zca(4), zpa(5), za, zca, zpa,
        !          1391: �?x   c10, c10c, c10p, c10a(3),c10ca(4),c10pa(5),c10a,c10ca,c10pa,
        !          1392: �Fx   L, Lc, Lp, La(3), Lca(4), Lpa(5), La, Lca, Lpa
        !          1393:        read('stuff','(a)')
        !          1394: �3x   i, ic, ip, ia(10), ica(3), ipa(4), ia, ica, ipa,
        !          1395: �;x   i2, i2c, i2p, i2a(3), i2ca(4), i2pa(5), i2a, i2ca, i2pa,
        !          1396: �2x   r, rc, rp, ra(3), rca(4), rpa(5), ra, rca, rpa,
        !          1397: �2x   d, dc, dp, da(3), dca(4), dpa(5), da, dca, dpa,
        !          1398: �2x   c, cc, cp, ca(3), cca(4), cpa(5), ca, cca, cpa,
        !          1399: �2x   z, zc, zp, za(3), zca(4), zpa(5), za, zca, zpa,
        !          1400: �?x   c10, c10c, c10p, c10a(3),c10ca(4),c10pa(5),c10a,c10ca,c10pa,
        !          1401: �:x   L, Lc, Lp, La(3), Lca(4), Lpa(5), La, Lca, Lpa
        !          1402:        read(5)
        !          1403: �3x   i, ic, ip, ia(10), ica(3), ipa(4), ia, ica, ipa,
        !          1404: �;x   i2, i2c, i2p, i2a(3), i2ca(4), i2pa(5), i2a, i2ca, i2pa,
        !          1405: �2x   r, rc, rp, ra(3), rca(4), rpa(5), ra, rca, rpa,
        !          1406: �2x   d, dc, dp, da(3), dca(4), dpa(5), da, dca, dpa,
        !          1407: �2x   c, cc, cp, ca(3), cca(4), cpa(5), ca, cca, cpa,
        !          1408: �2x   z, zc, zp, za(3), zca(4), zpa(5), za, zca, zpa,
        !          1409: �?x   c10, c10c, c10p, c10a(3),c10ca(4),c10pa(5),c10a,c10ca,c10pa,
        !          1410: �=x   L, Lc, Lp, La(3), Lca(4), Lpa(5), La, Lca, Lpa
        !          1411:        write(*,*)
        !          1412: �3x   i, ic, ip, ia(10), ica(3), ipa(4), ia, ica, ipa,
        !          1413: �;x   i2, i2c, i2p, i2a(3), i2ca(4), i2pa(5), i2a, i2ca, i2pa,
        !          1414: �2x   r, rc, rp, ra(3), rca(4), rpa(5), ra, rca, rpa,
        !          1415: �2x   d, dc, dp, da(3), dca(4), dpa(5), da, dca, dpa,
        !          1416: �2x   c, cc, cp, ca(3), cca(4), cpa(5), ca, cca, cpa,
        !          1417: �2x   z, zc, zp, za(3), zca(4), zpa(5), za, zca, zpa,
        !          1418: �?x   c10, c10c, c10p, c10a(3),c10ca(4),c10pa(5),c10a,c10ca,c10pa,
        !          1419: �Ax   L, Lc, Lp, La(3), Lca(4), Lpa(5), La, Lca, Lpa
        !          1420:        write(*,'(a)')
        !          1421: �3x   i, ic, ip, ia(10), ica(3), ipa(4), ia, ica, ipa,
        !          1422: �;x   i2, i2c, i2p, i2a(3), i2ca(4), i2pa(5), i2a, i2ca, i2pa,
        !          1423: �2x   r, rc, rp, ra(3), rca(4), rpa(5), ra, rca, rpa,
        !          1424: �2x   d, dc, dp, da(3), dca(4), dpa(5), da, dca, dpa,
        !          1425: �2x   c, cc, cp, ca(3), cca(4), cpa(5), ca, cca, cpa,
        !          1426: �2x   z, zc, zp, za(3), zca(4), zpa(5), za, zca, zpa,
        !          1427: �?x   c10, c10c, c10p, c10a(3),c10ca(4),c10pa(5),c10a,c10ca,c10pa,
        !          1428: �Gx   L, Lc, Lp, La(3), Lca(4), Lpa(5), La, Lca, Lpa
        !          1429:        write('stuff','(a)')
        !          1430: �3x   i, ic, ip, ia(10), ica(3), ipa(4), ia, ica, ipa,
        !          1431: �;x   i2, i2c, i2p, i2a(3), i2ca(4), i2pa(5), i2a, i2ca, i2pa,
        !          1432: �2x   r, rc, rp, ra(3), rca(4), rpa(5), ra, rca, rpa,
        !          1433: �2x   d, dc, dp, da(3), dca(4), dpa(5), da, dca, dpa,
        !          1434: �2x   c, cc, cp, ca(3), cca(4), cpa(5), ca, cca, cpa,
        !          1435: �2x   z, zc, zp, za(3), zca(4), zpa(5), za, zca, zpa,
        !          1436: �?x   c10, c10c, c10p, c10a(3),c10ca(4),c10pa(5),c10a,c10ca,c10pa,
        !          1437: �;x   L, Lc, Lp, La(3), Lca(4), Lpa(5), La, Lca, Lpa
        !          1438:        write(5)
        !          1439: �3x   i, ic, ip, ia(10), ica(3), ipa(4), ia, ica, ipa,
        !          1440: �;x   i2, i2c, i2p, i2a(3), i2ca(4), i2pa(5), i2a, i2ca, i2pa,
        !          1441: �2x   r, rc, rp, ra(3), rca(4), rpa(5), ra, rca, rpa,
        !          1442: �2x   d, dc, dp, da(3), dca(4), dpa(5), da, dca, dpa,
        !          1443: �2x   c, cc, cp, ca(3), cca(4), cpa(5), ca, cca, cpa,
        !          1444: �2x   z, zc, zp, za(3), zca(4), zpa(5), za, zca, zpa,
        !          1445: �?x   c10, c10c, c10p, c10a(3),c10ca(4),c10pa(5),c10a,c10ca,c10pa,
        !          1446: �6x   L, Lc, Lp, La(3), Lca(4), Lpa(5), La, Lca, Lpa
        !          1447:        end
        !          1448: procargs.f&��,���  subroutine zot(n,grok,gulp)
        !          1449:        external grok,gulp
        !          1450:        real gulp
        !          1451:        external foo,foo1
        !          1452:        integer foo1
        !          1453:        intrinsic dsqrt
        !          1454:        call goo(zot,foo,foo1,dsqrt,grok,gulp,n-1)
        !          1455:        end
        !          1456: * zot:  TNAME, CLPROC, STGEXT, TYSUBR,         PTHISPROC
        !          1457: * foo:  TNAME, CLPROC, STGEXT, TYUNKNOWN,      P�EXTERNAL
        !          1458: * foo1:        TNAME, CLPROC,  STGEXT, TYLONG,         PEXTERNAL
        !          1459: *dsqrt:was: TADDR, 0   STGEXT, 0
        !          1460: *dsqrt:now: TADDR, CLPROC      STGEXT, TYDREAL
        !          1461: * grok:        TEXPR(OPWHATSIN,TNAME); TNAME, TYREAL, CLPROC, STGARG,  PEXTERNAL
        !          1462: * gulp:        TEXPR(OPWHATSIN,TNAME); TNAME, TYREAL, CLPROC, STGARG, PEXTERNAL
        !          1463: b4.f&�zH�X�PP  character*10 mdr_queue
        !          1464:        CALLN_SPAWN('$ PRINT/DELETE/QUEUE='//MDR_QUEUE())
        !          1465:        end
        !          1466: b5.f&YH�͏e�subroutine abstr(rwk,rate)
        !          1467: �dimension rwk(rate)
        !          1468: �
integer rate
        !          1469: �RETURN
        !          1470: �END
        !          1471: b6.f&D�H�G���SUBROUTINE COLOUT(LINE, RN, J)
        !          1472: �CHARACTER*8 LINE, RN(*)
        !          1473: �EXTERNAL EXINDX
        !          1474: �/INTEGER EXINDX, J, N
        !          1475:  30   N = EXINDX(LINE, J)
        !          1476: �RN(N) = RN(EXINDX(LINE,J))
        !          1477: �END
        !          1478: b7.f&ȸH��``  subroutine foo(a,b,c)
        !          1479:        character*8 a,b,c
        !          1480:        external b,c
        !          1481:        a = b(c(3,a//c(1,'def'))//c(4,a))
        !          1482:        end
        !          1483: b8.f&��H���M�character  word*60�
        !          1484: 1100�$goto (1500,1100)jarg(word)
        !          1485: 1500   end
        !          1486: b9.f&��H����&t  program f2ctest
        !          1487:        character s*10,clower
        !          1488:        s='AbCdEfGhIjKl'
        !          1489:        do 20 i=1,10
        !          1490: 20        s(i:i)=clower(s(i:i))
        !          1491:        print *,s
        !          1492:        end
        !          1493: �]CHARACTER*(*) FUNCTION CLOWER(C)
        !          1494: C
        !          1495: C  Return lower case equivalent of character string "C"
        !          1496: C
        !          1497: �CHARACTER C*(*),T
        !          1498: C
        !          1499: �L=MIN0(LEN(C),LEN(CLOWER))
        !          1500: �CLOWER=' '
        !          1501: �DO 10 I=1,L
        !          1502: �              T=C(I:I)
        !          1503: �      5IF(T .GE. 'A' .AND. T .LE. 'Z')T=CHAR(ICHAR(T)+32)
        !          1504: 10�CLOWER(I:I)=T
        !          1505: �RETURN
        !          1506: �END
        !          1507: I.f&3�&$PQI1.f&�[��56I2.f&Dc��9:L.f&Թ�Q&jka.f&]���&34a1.f&�<�8OPa2.f&�h��.&0&a3.f&��vwX��b.f&s����b1.f&=��       �b2.f&2Q�Q�9&&b3.f&���R;�&�&b4.f&�zH�X�PQb5.f&YH�͏eVb6.f&D�H�G���b7.f&ȸH��`ab8.f&��H���MDb9.f&��H����&�&bc.f&Z�S =HIboo.f&�f6w7Y�boo00.f&}_5x�Y47boo01.f&u�5y6\r_boo1.f&�e6z�\��boo10.f&E�6{e]"#boo11.f&�C7|�]abboo12.f&nn8}2^l&n&boo12a.f&{�7~�_z{boo13.f&-�7c`��boo13b.f&/
        !          1508: 8�laOPboo14.f&��7��a�        �     boo15.f&�p8��kNOboo16.f&'m8�#l��boo17.f&�&8�m./boo18.f&�q8�emY&[&boo19.f&Ɓ9��u>?boo1a.f&��6��nklboo2.f&0{6�toFGboo3.f&�q6��owxboo3a.f&1}6�{p��boo4.f&Ł6�#qNOboo5.f&�u6��q@Aboo6.f&�6��qJKboo7.f&A�6�jr��boo8.f&��6�dsz{boo9.f&F�6�tDEboo9a.f&�;7�ltLMboo9b.f&�k7��t��c.f&�
        !          1509: �yzc1.f&&x��BCc2.f&o���bcc3.f&�9�
u��c4.f&W]�1CDc5.f&o]��OPc6.f&�I�
��c7.f&BO����c8.f&�V��   ��c9.f&�n�>
        !          1510: ��ca.f&���ABcb.f&�i�n�&�&cb1.f&��R
��cb2.f&<��phfcb3.f&����.cb4.f&�DX�Zy0&2&cd.f&q=�;VWcd1.f&=��Tv=()cd2.f&&��U�=<=cen.f&���V$>jkcen1.f&���W�>��cen2.f&&�Xk?��cen3.f&�9�Y@��cen4.f&<�Z�@vwcf.f&�&����cf0.f&�z�[\Acf1.f&�}�\�A>?cf2.f&���]�Arccf3.f&aP�^�B��cf4.f&
        !          1511: l�_&C��cf5.f&{�`
D��cf6.f&ݾ�a�D9:coo.f&h��bE23cx.f&�S�ctEfgcx1.f&�e�d�E^_cx2.f&GA��jkcx3.f&�}�e�F12d.f&IJ�,ABd1.f&�J����d2.f&���V`ad3.f&!���FGd4.f&DB�Svopd5.f&UEB��vqrd6.f&HB�}w~d7.f&_B� x��d8.f&IOB��xGHde.f&�V� F&    &doo.f&B��!s+,e.f&@n�"��&�&e1.f&c�#��Ne2.f&�f�$5�qe3.f&���%�e4.f&�K�&  �&�&e5.f&�8�f�Fefe6.f&�M�gbGefec.f&ó�'�!��ed.f&���h�G��en.f&���i�H�&�&en0.f&:�j�J��en1.f&f�k�Kv&x&en2.f&�l>MM&O&en3.f&�i�m�N8�en4.f&l�n�R�uen5.f&.r�o1S��en6.f&�q�p�S�wf.f&�H�({"/0f0.f&F[�)�"|&u&f1.f&9��*h$��f2.f&�S�+t%��f3.f&,V�,P&$%foo.f&}2�-�&+,fp1.f&�
        !          1512: �.�&$%g.f&4��/2'��g1.f&��0(��goo.f&�@�1�(RSh.f&���2l)cch0.f&5��3�)DEh1.f&�
        !          1513: �4\*=>h2.f&n�5�*WXh3.f&7W�6:+'(h4.f&BW�7�+=>i.f&YN�8�+��i2.f&$�9�,=>if.f&�u�q�T+,iochk.f&m@���z�Kl.f&�<�:�,��m.f&�@�;�-m1.f&�j�<.`am1t.f&&K�r�T��n.f&YD�=�.OPo.f&r��>/JKp.f&b�?s/��p1.f&k=�@0;<p2.f&�i�A{0��procargs.f&��,��r.f&�2�B11TUr1.f&�4�C�1�r2.f&'5�DN2str3.f&9`�E�2KLr4.f&[m�FV3��r5.f&n�G04��r6.f&Q��H�4��s.f&2�I�5s&c&s1.f&��J'7
s2.f&�e�KY7&'sf.f&{�L�7BCsf1.f&s��M8KLsf2.f&ȵ�N{8PQw.f&�6�O�8UVx.f&�s�Pj9YZz1.f&�A�t_Wcdz2.f&B�u�Wklzoo.f&<�s�U�&�&���
unix.superglobalmegacorp.com

This archive runs on limited infrastructure. Preserving old code on modern bandwidth. Automated agents are requested to crawl responsibly.