
(/VERSIONCHECK 2) 

(DEFUN |FORTRAN;makeRep| (|b| $) (CONS (SPADCALL (QREFELT $ 12)) |b|)) 

(PUT '|FORTRAN;codeFrom| '|SPADreplace| 'QCDR) 

(DEFUN |FORTRAN;codeFrom| (|u| $) (QCDR |u|)) 

(DEFUN |FORTRAN;outputAsFortran;$V;3| (|p| $)
  (PROG (#1=#:G1839 |expr| |intrinsics| |body| #2=#:G1838 |l| #3=#:G1837
         |tempName|)
    (RETURN
     (SEQ (SPADCALL (SPADCALL 25000 (QREFELT $ 15)) (QREFELT $ 17))
          (LETT |tempName| 'FPTEMP . #4=(|FORTRAN;outputAsFortran;$V;3|))
          (SPADCALL |tempName| (QREFELT $ 21)) (|initialiseIntrinsicList|)
          (LETT |body|
                (PROGN
                 (LETT #3# NIL . #4#)
                 (SEQ (LETT |l| NIL . #4#)
                      (LETT #2# (|FORTRAN;codeFrom| |p| $) . #4#) G190
                      (COND
                       ((OR (ATOM #2#) (PROGN (LETT |l| (CAR #2#) . #4#) NIL))
                        #5=(GO G191)))
                      (SEQ
                       (EXIT
                        (LETT #3# (CONS (SPADCALL |l| (QREFELT $ 23)) #3#)
                              . #4#)))
                      (LETT #2# (CDR #2#) . #4#) #6=(GO G190) G191
                      (EXIT (NREVERSE0 #3#))))
                . #4#)
          (LETT |intrinsics| (|getIntrinsicList|) . #4#)
          (SPADCALL (QREFELT $ 24))
          (|fortFormatHead| (SPADCALL (QREFELT $ 7) (QREFELT $ 27))
                            (SPADCALL (QREFELT $ 6) (QREFELT $ 28))
                            (SPADCALL (QREFELT $ 8) (QREFELT $ 30)))
          (SPADCALL (QREFELT $ 9) (QREFELT $ 31))
          (SPADCALL (QCAR |p|) (QREFELT $ 31))
          (SPADCALL |tempName| (QREFELT $ 32))
          (|fortFormatIntrinsics| |intrinsics|)
          (SPADCALL |tempName| (QREFELT $ 33))
          (SEQ (LETT |expr| NIL . #4#) (LETT #1# |body| . #4#) G190
               (COND
                ((OR (ATOM #1#) (PROGN (LETT |expr| (CAR #1#) . #4#) NIL))
                 #5#))
               (SEQ (EXIT (|displayLines1| |expr|))) (LETT #1# (CDR #1#) . #4#)
               #6# G191 (EXIT NIL))
          (|dispStatement| 'END) (EXIT (SPADCALL (QREFELT $ 34))))))) 

(DEFUN |FORTRAN;mkString| (|l| $)
  (SPADCALL (SPADCALL (SPADCALL |l| (QREFELT $ 30)) (QREFELT $ 37))
            (QREFELT $ 39))) 

(DEFUN |FORTRAN;checkVariables| (|user| |target| $)
  (PROG (|s2| |s1|)
    (RETURN
     (SEQ
      (COND
       ((NULL
         (SPADCALL
          (SPADCALL (SPADCALL (ELT $ 40) |user| (QREFELT $ 42)) |target|
                    (QREFELT $ 43))
          NIL (QREFELT $ 45)))
        (SEQ
         (LETT |s1| (|FORTRAN;mkString| |user| $)
               . #1=(|FORTRAN;checkVariables|))
         (LETT |s2| (|FORTRAN;mkString| |target| $) . #1#)
         (EXIT
          (|error|
           (LIST "Incompatible variable lists:" (SPADCALL |s1| (QREFELT $ 46))
                 (SPADCALL |s2| (QREFELT $ 46)))))))
       ('T (SPADCALL (QREFELT $ 34)))))))) 

(DEFUN |FORTRAN;coerce;E$;6| (|u| $)
  (PROG (|l|)
    (RETURN
     (SEQ
      (|FORTRAN;checkVariables| (SPADCALL |u| (QREFELT $ 48)) (QREFELT $ 8) $)
      (LETT |l|
            (LIST (SPADCALL (QREFELT $ 6) |u| (QREFELT $ 49))
                  (SPADCALL (QREFELT $ 50)))
            |FORTRAN;coerce;E$;6|)
      (EXIT (|FORTRAN;makeRep| |l| $)))))) 

(DEFUN |FORTRAN;coerce;E$;7| (|u| $)
  (PROG (|eList| #1=#:G1869 |w| #2=#:G1870 |v| #3=#:G1868 |aeList| #4=#:G1867
         #5=#:G1866 |veList| #6=#:G1865 #7=#:G1864 |vList|)
    (RETURN
     (SEQ
      (COND
       ((QEQCAR (SPADCALL (SPADCALL |u| (QREFELT $ 53)) (QREFELT $ 55)) 1)
        (|error| "left hand side is not a kernel"))
       ('T
        (SEQ
         (LETT |vList| (SPADCALL (SPADCALL |u| (QREFELT $ 53)) (QREFELT $ 48))
               . #8=(|FORTRAN;coerce;E$;7|))
         (COND
          ((NULL (EQL (LENGTH |vList|) (LENGTH (QREFELT $ 8))))
           (EXIT (|error| "Incorrect number of arguments"))))
         (LETT |veList|
               (PROGN
                (LETT #7# NIL . #8#)
                (SEQ (LETT |w| NIL . #8#) (LETT #6# |vList| . #8#) G190
                     (COND
                      ((OR (ATOM #6#) (PROGN (LETT |w| (CAR #6#) . #8#) NIL))
                       #9=(GO G191)))
                     (SEQ
                      (EXIT
                       (LETT #7# (CONS (SPADCALL |w| (QREFELT $ 56)) #7#)
                             . #8#)))
                     (LETT #6# (CDR #6#) . #8#) #10=(GO G190) G191
                     (EXIT (NREVERSE0 #7#))))
               . #8#)
         (LETT |aeList|
               (PROGN
                (LETT #5# NIL . #8#)
                (SEQ (LETT |w| NIL . #8#) (LETT #4# (QREFELT $ 8) . #8#) G190
                     (COND
                      ((OR (ATOM #4#) (PROGN (LETT |w| (CAR #4#) . #8#) NIL))
                       #9#))
                     (SEQ
                      (EXIT
                       (LETT #5# (CONS (SPADCALL |w| (QREFELT $ 56)) #5#)
                             . #8#)))
                     (LETT #4# (CDR #4#) . #8#) #10# G191
                     (EXIT (NREVERSE0 #5#))))
               . #8#)
         (LETT |eList|
               (PROGN
                (LETT #3# NIL . #8#)
                (SEQ (LETT |v| NIL . #8#) (LETT #2# |aeList| . #8#)
                     (LETT |w| NIL . #8#) (LETT #1# |veList| . #8#) G190
                     (COND
                      ((OR (ATOM #1#) (PROGN (LETT |w| (CAR #1#) . #8#) NIL)
                           (ATOM #2#) (PROGN (LETT |v| (CAR #2#) . #8#) NIL))
                       #9#))
                     (SEQ
                      (EXIT
                       (LETT #3# (CONS (SPADCALL |w| |v| (QREFELT $ 57)) #3#)
                             . #8#)))
                     (LETT #1# (PROG1 (CDR #1#) (LETT #2# (CDR #2#) . #8#))
                           . #8#)
                     #10# G191 (EXIT (NREVERSE0 #3#))))
               . #8#)
         (EXIT
          (SPADCALL
           (SPADCALL (SPADCALL |u| (QREFELT $ 58)) |eList| (QREFELT $ 60))
           (QREFELT $ 51)))))))))) 

(DEFUN |FORTRAN;coerce;E$;8| (|u| $)
  (PROG (|l|)
    (RETURN
     (SEQ
      (|FORTRAN;checkVariables| (SPADCALL |u| (QREFELT $ 63)) (QREFELT $ 8) $)
      (LETT |l|
            (LIST (SPADCALL (QREFELT $ 6) |u| (QREFELT $ 64))
                  (SPADCALL (QREFELT $ 50)))
            |FORTRAN;coerce;E$;8|)
      (EXIT (|FORTRAN;makeRep| |l| $)))))) 

(DEFUN |FORTRAN;coerce;E$;9| (|u| $)
  (PROG (|eList| #1=#:G1889 |w| #2=#:G1890 |v| #3=#:G1888 |aeList| #4=#:G1887
         #5=#:G1886 |veList| #6=#:G1885 #7=#:G1884 |vList|)
    (RETURN
     (SEQ
      (COND
       ((QEQCAR (SPADCALL (SPADCALL |u| (QREFELT $ 67)) (QREFELT $ 68)) 1)
        (|error| "left hand side is not a kernel"))
       ('T
        (SEQ
         (LETT |vList| (SPADCALL (SPADCALL |u| (QREFELT $ 67)) (QREFELT $ 63))
               . #8=(|FORTRAN;coerce;E$;9|))
         (COND
          ((NULL (EQL (LENGTH |vList|) (LENGTH (QREFELT $ 8))))
           (EXIT (|error| "Incorrect number of arguments"))))
         (LETT |veList|
               (PROGN
                (LETT #7# NIL . #8#)
                (SEQ (LETT |w| NIL . #8#) (LETT #6# |vList| . #8#) G190
                     (COND
                      ((OR (ATOM #6#) (PROGN (LETT |w| (CAR #6#) . #8#) NIL))
                       #9=(GO G191)))
                     (SEQ
                      (EXIT
                       (LETT #7# (CONS (SPADCALL |w| (QREFELT $ 69)) #7#)
                             . #8#)))
                     (LETT #6# (CDR #6#) . #8#) #10=(GO G190) G191
                     (EXIT (NREVERSE0 #7#))))
               . #8#)
         (LETT |aeList|
               (PROGN
                (LETT #5# NIL . #8#)
                (SEQ (LETT |w| NIL . #8#) (LETT #4# (QREFELT $ 8) . #8#) G190
                     (COND
                      ((OR (ATOM #4#) (PROGN (LETT |w| (CAR #4#) . #8#) NIL))
                       #9#))
                     (SEQ
                      (EXIT
                       (LETT #5# (CONS (SPADCALL |w| (QREFELT $ 69)) #5#)
                             . #8#)))
                     (LETT #4# (CDR #4#) . #8#) #10# G191
                     (EXIT (NREVERSE0 #5#))))
               . #8#)
         (LETT |eList|
               (PROGN
                (LETT #3# NIL . #8#)
                (SEQ (LETT |v| NIL . #8#) (LETT #2# |aeList| . #8#)
                     (LETT |w| NIL . #8#) (LETT #1# |veList| . #8#) G190
                     (COND
                      ((OR (ATOM #1#) (PROGN (LETT |w| (CAR #1#) . #8#) NIL)
                           (ATOM #2#) (PROGN (LETT |v| (CAR #2#) . #8#) NIL))
                       #9#))
                     (SEQ
                      (EXIT
                       (LETT #3# (CONS (SPADCALL |w| |v| (QREFELT $ 70)) #3#)
                             . #8#)))
                     (LETT #1# (PROG1 (CDR #1#) (LETT #2# (CDR #2#) . #8#))
                           . #8#)
                     #10# G191 (EXIT (NREVERSE0 #3#))))
               . #8#)
         (EXIT
          (SPADCALL
           (SPADCALL (SPADCALL |u| (QREFELT $ 71)) |eList| (QREFELT $ 72))
           (QREFELT $ 65)))))))))) 

(DEFUN |FORTRAN;coerce;E$;10| (|u| $)
  (PROG (|l|)
    (RETURN
     (SEQ
      (|FORTRAN;checkVariables| (SPADCALL |u| (QREFELT $ 75)) (QREFELT $ 8) $)
      (LETT |l|
            (LIST (SPADCALL (QREFELT $ 6) |u| (QREFELT $ 76))
                  (SPADCALL (QREFELT $ 50)))
            |FORTRAN;coerce;E$;10|)
      (EXIT (|FORTRAN;makeRep| |l| $)))))) 

(DEFUN |FORTRAN;coerce;E$;11| (|u| $)
  (PROG (|eList| #1=#:G1909 |w| #2=#:G1910 |v| #3=#:G1908 |aeList| #4=#:G1907
         #5=#:G1906 |veList| #6=#:G1905 #7=#:G1904 |vList|)
    (RETURN
     (SEQ
      (COND
       ((QEQCAR (SPADCALL (SPADCALL |u| (QREFELT $ 79)) (QREFELT $ 80)) 1)
        (|error| "left hand side is not a kernel"))
       ('T
        (SEQ
         (LETT |vList| (SPADCALL (SPADCALL |u| (QREFELT $ 79)) (QREFELT $ 75))
               . #8=(|FORTRAN;coerce;E$;11|))
         (COND
          ((NULL (EQL (LENGTH |vList|) (LENGTH (QREFELT $ 8))))
           (EXIT (|error| "Incorrect number of arguments"))))
         (LETT |veList|
               (PROGN
                (LETT #7# NIL . #8#)
                (SEQ (LETT |w| NIL . #8#) (LETT #6# |vList| . #8#) G190
                     (COND
                      ((OR (ATOM #6#) (PROGN (LETT |w| (CAR #6#) . #8#) NIL))
                       #9=(GO G191)))
                     (SEQ
                      (EXIT
                       (LETT #7# (CONS (SPADCALL |w| (QREFELT $ 81)) #7#)
                             . #8#)))
                     (LETT #6# (CDR #6#) . #8#) #10=(GO G190) G191
                     (EXIT (NREVERSE0 #7#))))
               . #8#)
         (LETT |aeList|
               (PROGN
                (LETT #5# NIL . #8#)
                (SEQ (LETT |w| NIL . #8#) (LETT #4# (QREFELT $ 8) . #8#) G190
                     (COND
                      ((OR (ATOM #4#) (PROGN (LETT |w| (CAR #4#) . #8#) NIL))
                       #9#))
                     (SEQ
                      (EXIT
                       (LETT #5# (CONS (SPADCALL |w| (QREFELT $ 81)) #5#)
                             . #8#)))
                     (LETT #4# (CDR #4#) . #8#) #10# G191
                     (EXIT (NREVERSE0 #5#))))
               . #8#)
         (LETT |eList|
               (PROGN
                (LETT #3# NIL . #8#)
                (SEQ (LETT |v| NIL . #8#) (LETT #2# |aeList| . #8#)
                     (LETT |w| NIL . #8#) (LETT #1# |veList| . #8#) G190
                     (COND
                      ((OR (ATOM #1#) (PROGN (LETT |w| (CAR #1#) . #8#) NIL)
                           (ATOM #2#) (PROGN (LETT |v| (CAR #2#) . #8#) NIL))
                       #9#))
                     (SEQ
                      (EXIT
                       (LETT #3# (CONS (SPADCALL |w| |v| (QREFELT $ 82)) #3#)
                             . #8#)))
                     (LETT #1# (PROG1 (CDR #1#) (LETT #2# (CDR #2#) . #8#))
                           . #8#)
                     #10# G191 (EXIT (NREVERSE0 #3#))))
               . #8#)
         (EXIT
          (SPADCALL
           (SPADCALL (SPADCALL |u| (QREFELT $ 83)) |eList| (QREFELT $ 84))
           (QREFELT $ 77)))))))))) 

(PUT '|FORTRAN;coerce;R$;12| '|SPADreplace| '(XLAM (|u|) |u|)) 

(DEFUN |FORTRAN;coerce;R$;12| (|u| $) |u|) 

(DEFUN |FORTRAN;coerce;$Of;13| (|u| $) (SPADCALL (QREFELT $ 6) (QREFELT $ 28))) 

(DEFUN |FORTRAN;coerce;L$;14| (|c| $) (|FORTRAN;makeRep| |c| $)) 

(DEFUN |FORTRAN;coerce;Fc$;15| (|c| $) (|FORTRAN;makeRep| (LIST |c|) $)) 

(DEFUN |FORTRAN;coerce;E$;16| (|u| $)
  (PROG (|l|)
    (RETURN
     (SEQ
      (|FORTRAN;checkVariables| (SPADCALL |u| (QREFELT $ 93)) (QREFELT $ 8) $)
      (LETT |l|
            (LIST (SPADCALL (QREFELT $ 6) |u| (QREFELT $ 94))
                  (SPADCALL (QREFELT $ 50)))
            |FORTRAN;coerce;E$;16|)
      (EXIT (|FORTRAN;makeRep| |l| $)))))) 

(DEFUN |FORTRAN;coerce;E$;17| (|u| $)
  (PROG (|eList| #1=#:G1935 |w| #2=#:G1936 |v| #3=#:G1934 |aeList| #4=#:G1933
         #5=#:G1932 |veList| #6=#:G1931 #7=#:G1930 |vList|)
    (RETURN
     (SEQ
      (COND
       ((QEQCAR (SPADCALL (SPADCALL |u| (QREFELT $ 97)) (QREFELT $ 98)) 1)
        (|error| "left hand side is not a kernel"))
       ('T
        (SEQ
         (LETT |vList| (SPADCALL (SPADCALL |u| (QREFELT $ 97)) (QREFELT $ 93))
               . #8=(|FORTRAN;coerce;E$;17|))
         (COND
          ((NULL (EQL (LENGTH |vList|) (LENGTH (QREFELT $ 8))))
           (EXIT (|error| "Incorrect number of arguments"))))
         (LETT |veList|
               (PROGN
                (LETT #7# NIL . #8#)
                (SEQ (LETT |w| NIL . #8#) (LETT #6# |vList| . #8#) G190
                     (COND
                      ((OR (ATOM #6#) (PROGN (LETT |w| (CAR #6#) . #8#) NIL))
                       #9=(GO G191)))
                     (SEQ
                      (EXIT
                       (LETT #7# (CONS (SPADCALL |w| (QREFELT $ 99)) #7#)
                             . #8#)))
                     (LETT #6# (CDR #6#) . #8#) #10=(GO G190) G191
                     (EXIT (NREVERSE0 #7#))))
               . #8#)
         (LETT |aeList|
               (PROGN
                (LETT #5# NIL . #8#)
                (SEQ (LETT |w| NIL . #8#) (LETT #4# (QREFELT $ 8) . #8#) G190
                     (COND
                      ((OR (ATOM #4#) (PROGN (LETT |w| (CAR #4#) . #8#) NIL))
                       #9#))
                     (SEQ
                      (EXIT
                       (LETT #5# (CONS (SPADCALL |w| (QREFELT $ 99)) #5#)
                             . #8#)))
                     (LETT #4# (CDR #4#) . #8#) #10# G191
                     (EXIT (NREVERSE0 #5#))))
               . #8#)
         (LETT |eList|
               (PROGN
                (LETT #3# NIL . #8#)
                (SEQ (LETT |v| NIL . #8#) (LETT #2# |aeList| . #8#)
                     (LETT |w| NIL . #8#) (LETT #1# |veList| . #8#) G190
                     (COND
                      ((OR (ATOM #1#) (PROGN (LETT |w| (CAR #1#) . #8#) NIL)
                           (ATOM #2#) (PROGN (LETT |v| (CAR #2#) . #8#) NIL))
                       #9#))
                     (SEQ
                      (EXIT
                       (LETT #3# (CONS (SPADCALL |w| |v| (QREFELT $ 100)) #3#)
                             . #8#)))
                     (LETT #1# (PROG1 (CDR #1#) (LETT #2# (CDR #2#) . #8#))
                           . #8#)
                     #10# G191 (EXIT (NREVERSE0 #3#))))
               . #8#)
         (EXIT
          (SPADCALL
           (SPADCALL (SPADCALL |u| (QREFELT $ 101)) |eList| (QREFELT $ 102))
           (QREFELT $ 95)))))))))) 

(DEFUN |FORTRAN;coerce;E$;18| (|u| $)
  (PROG (|l|)
    (RETURN
     (SEQ
      (|FORTRAN;checkVariables| (SPADCALL |u| (QREFELT $ 105)) (QREFELT $ 8) $)
      (LETT |l|
            (LIST (SPADCALL (QREFELT $ 6) |u| (QREFELT $ 106))
                  (SPADCALL (QREFELT $ 50)))
            |FORTRAN;coerce;E$;18|)
      (EXIT (|FORTRAN;makeRep| |l| $)))))) 

(DEFUN |FORTRAN;coerce;E$;19| (|u| $)
  (PROG (|eList| #1=#:G1955 |w| #2=#:G1956 |v| #3=#:G1954 |aeList| #4=#:G1953
         #5=#:G1952 |veList| #6=#:G1951 #7=#:G1950 |vList|)
    (RETURN
     (SEQ
      (COND
       ((QEQCAR (SPADCALL (SPADCALL |u| (QREFELT $ 109)) (QREFELT $ 110)) 1)
        (|error| "left hand side is not a kernel"))
       ('T
        (SEQ
         (LETT |vList|
               (SPADCALL (SPADCALL |u| (QREFELT $ 109)) (QREFELT $ 105))
               . #8=(|FORTRAN;coerce;E$;19|))
         (COND
          ((NULL (EQL (LENGTH |vList|) (LENGTH (QREFELT $ 8))))
           (EXIT (|error| "Incorrect number of arguments"))))
         (LETT |veList|
               (PROGN
                (LETT #7# NIL . #8#)
                (SEQ (LETT |w| NIL . #8#) (LETT #6# |vList| . #8#) G190
                     (COND
                      ((OR (ATOM #6#) (PROGN (LETT |w| (CAR #6#) . #8#) NIL))
                       #9=(GO G191)))
                     (SEQ
                      (EXIT
                       (LETT #7# (CONS (SPADCALL |w| (QREFELT $ 111)) #7#)
                             . #8#)))
                     (LETT #6# (CDR #6#) . #8#) #10=(GO G190) G191
                     (EXIT (NREVERSE0 #7#))))
               . #8#)
         (LETT |aeList|
               (PROGN
                (LETT #5# NIL . #8#)
                (SEQ (LETT |w| NIL . #8#) (LETT #4# (QREFELT $ 8) . #8#) G190
                     (COND
                      ((OR (ATOM #4#) (PROGN (LETT |w| (CAR #4#) . #8#) NIL))
                       #9#))
                     (SEQ
                      (EXIT
                       (LETT #5# (CONS (SPADCALL |w| (QREFELT $ 111)) #5#)
                             . #8#)))
                     (LETT #4# (CDR #4#) . #8#) #10# G191
                     (EXIT (NREVERSE0 #5#))))
               . #8#)
         (LETT |eList|
               (PROGN
                (LETT #3# NIL . #8#)
                (SEQ (LETT |v| NIL . #8#) (LETT #2# |aeList| . #8#)
                     (LETT |w| NIL . #8#) (LETT #1# |veList| . #8#) G190
                     (COND
                      ((OR (ATOM #1#) (PROGN (LETT |w| (CAR #1#) . #8#) NIL)
                           (ATOM #2#) (PROGN (LETT |v| (CAR #2#) . #8#) NIL))
                       #9#))
                     (SEQ
                      (EXIT
                       (LETT #3# (CONS (SPADCALL |w| |v| (QREFELT $ 112)) #3#)
                             . #8#)))
                     (LETT #1# (PROG1 (CDR #1#) (LETT #2# (CDR #2#) . #8#))
                           . #8#)
                     #10# G191 (EXIT (NREVERSE0 #3#))))
               . #8#)
         (EXIT
          (SPADCALL
           (SPADCALL (SPADCALL |u| (QREFELT $ 113)) |eList| (QREFELT $ 114))
           (QREFELT $ 107)))))))))) 

(DEFUN |FORTRAN;coerce;E$;20| (|u| $)
  (PROG (|l|)
    (RETURN
     (SEQ
      (|FORTRAN;checkVariables| (SPADCALL |u| (QREFELT $ 117)) (QREFELT $ 8) $)
      (LETT |l|
            (LIST (SPADCALL (QREFELT $ 6) |u| (QREFELT $ 118))
                  (SPADCALL (QREFELT $ 50)))
            |FORTRAN;coerce;E$;20|)
      (EXIT (|FORTRAN;makeRep| |l| $)))))) 

(DEFUN |FORTRAN;coerce;E$;21| (|u| $)
  (PROG (|eList| #1=#:G1975 |w| #2=#:G1976 |v| #3=#:G1974 |aeList| #4=#:G1973
         #5=#:G1972 |veList| #6=#:G1971 #7=#:G1970 |vList|)
    (RETURN
     (SEQ
      (COND
       ((QEQCAR (SPADCALL (SPADCALL |u| (QREFELT $ 121)) (QREFELT $ 122)) 1)
        (|error| "left hand side is not a kernel"))
       ('T
        (SEQ
         (LETT |vList|
               (SPADCALL (SPADCALL |u| (QREFELT $ 121)) (QREFELT $ 117))
               . #8=(|FORTRAN;coerce;E$;21|))
         (COND
          ((NULL (EQL (LENGTH |vList|) (LENGTH (QREFELT $ 8))))
           (EXIT (|error| "Incorrect number of arguments"))))
         (LETT |veList|
               (PROGN
                (LETT #7# NIL . #8#)
                (SEQ (LETT |w| NIL . #8#) (LETT #6# |vList| . #8#) G190
                     (COND
                      ((OR (ATOM #6#) (PROGN (LETT |w| (CAR #6#) . #8#) NIL))
                       #9=(GO G191)))
                     (SEQ
                      (EXIT
                       (LETT #7# (CONS (SPADCALL |w| (QREFELT $ 123)) #7#)
                             . #8#)))
                     (LETT #6# (CDR #6#) . #8#) #10=(GO G190) G191
                     (EXIT (NREVERSE0 #7#))))
               . #8#)
         (LETT |aeList|
               (PROGN
                (LETT #5# NIL . #8#)
                (SEQ (LETT |w| NIL . #8#) (LETT #4# (QREFELT $ 8) . #8#) G190
                     (COND
                      ((OR (ATOM #4#) (PROGN (LETT |w| (CAR #4#) . #8#) NIL))
                       #9#))
                     (SEQ
                      (EXIT
                       (LETT #5# (CONS (SPADCALL |w| (QREFELT $ 123)) #5#)
                             . #8#)))
                     (LETT #4# (CDR #4#) . #8#) #10# G191
                     (EXIT (NREVERSE0 #5#))))
               . #8#)
         (LETT |eList|
               (PROGN
                (LETT #3# NIL . #8#)
                (SEQ (LETT |v| NIL . #8#) (LETT #2# |aeList| . #8#)
                     (LETT |w| NIL . #8#) (LETT #1# |veList| . #8#) G190
                     (COND
                      ((OR (ATOM #1#) (PROGN (LETT |w| (CAR #1#) . #8#) NIL)
                           (ATOM #2#) (PROGN (LETT |v| (CAR #2#) . #8#) NIL))
                       #9#))
                     (SEQ
                      (EXIT
                       (LETT #3# (CONS (SPADCALL |w| |v| (QREFELT $ 124)) #3#)
                             . #8#)))
                     (LETT #1# (PROG1 (CDR #1#) (LETT #2# (CDR #2#) . #8#))
                           . #8#)
                     #10# G191 (EXIT (NREVERSE0 #3#))))
               . #8#)
         (EXIT
          (SPADCALL
           (SPADCALL (SPADCALL |u| (QREFELT $ 125)) |eList| (QREFELT $ 126))
           (QREFELT $ 119)))))))))) 

(DEFUN |FortranProgram| (&REST #1=#:G1977)
  (PROG ()
    (RETURN
     (PROG (#2=#:G1978)
       (RETURN
        (COND
         ((LETT #2#
                (|lassocShiftWithFunction| (|devaluateList| #1#)
                                           (HGET |$ConstructorCache|
                                                 '|FortranProgram|)
                                           '|domainEqualList|)
                . #3=(|FortranProgram|))
          (|CDRwithIncrement| #2#))
         ('T
          (UNWIND-PROTECT
              (PROG1 (APPLY (|function| |FortranProgram;|) #1#)
                (LETT #2# T . #3#))
            (COND
             ((NOT #2#) (HREM |$ConstructorCache| '|FortranProgram|))))))))))) 

(DEFUN |FortranProgram;| (|#1| |#2| |#3| |#4|)
  (PROG (|pv$| $ |dv$| DV$4 DV$3 DV$2 DV$1)
    (RETURN
     (PROGN
      (LETT DV$1 (|devaluate| |#1|) . #1=(|FortranProgram|))
      (LETT DV$2 (|devaluate| |#2|) . #1#)
      (LETT DV$3 (|devaluate| |#3|) . #1#)
      (LETT DV$4 (|devaluate| |#4|) . #1#)
      (LETT |dv$| (LIST '|FortranProgram| DV$1 DV$2 DV$3 DV$4) . #1#)
      (LETT $ (GETREFV 128) . #1#)
      (QSETREFV $ 0 |dv$|)
      (QSETREFV $ 3 (LETT |pv$| (|buildPredVector| 0 0 NIL) . #1#))
      (|haddProp| |$ConstructorCache| '|FortranProgram|
                  (LIST DV$1 DV$2 DV$3 DV$4) (CONS 1 $))
      (|stuffDomainSlots| $)
      (QSETREFV $ 6 |#1|)
      (QSETREFV $ 7 |#2|)
      (QSETREFV $ 8 |#3|)
      (QSETREFV $ 9 |#4|)
      (QSETREFV $ 10
                (|Record| (|:| |localSymbols| (|SymbolTable|))
                          (|:| |code| (|List| (|FortranCode|)))))
      $)))) 

(MAKEPROP '|FortranProgram| '|infovec|
          (LIST
           '#(NIL NIL NIL NIL NIL NIL (|local| |#1|) (|local| |#2|)
              (|local| |#3|) (|local| |#4|) '|Rep| (|SymbolTable|)
              (0 . |empty|) (|Integer|) (|SingleInteger|) (4 . |coerce|)
              (|FortranCode|) (9 . |setLabelValue|) (|Void|) (|Symbol|)
              (|TheSymbolTable|) (14 . |newSubProgram|) (|SExpression|)
              (19 . |getCode|) (24 . |endSubProgram|) (|OutputForm|)
              (|Union| (|:| |fst| (|FortranScalarType|)) (|:| |void| '"void"))
              (28 . |coerce|) (33 . |coerce|) (|List| 19) (38 . |coerce|)
              (43 . |printTypes|) (48 . |printTypes|)
              (53 . |clearTheSymbolTable|) (58 . |void|)
              |FORTRAN;outputAsFortran;$V;3| (|InputForm|) (62 . |convert|)
              (|String|) (67 . |unparse|) (72 . |name|) (|Mapping| 19 19)
              (77 . |map|) (83 . |setDifference|) (|Boolean|) (89 . =)
              (95 . |coerce|) (|Expression| (|MachineInteger|))
              (100 . |variables|) (105 . |assign|) (111 . |returns|)
              |FORTRAN;coerce;E$;6| (|Equation| 47) (115 . |lhs|)
              (|Union| (|Kernel| $) '"failed") (120 . |retractIfCan|)
              (125 . |coerce|) (130 . |equation|) (136 . |rhs|)
              (|List| (|Equation| $)) (141 . |subst|) |FORTRAN;coerce;E$;7|
              (|Expression| (|MachineFloat|)) (147 . |variables|)
              (152 . |assign|) |FORTRAN;coerce;E$;8| (|Equation| 62)
              (158 . |lhs|) (163 . |retractIfCan|) (168 . |coerce|)
              (173 . |equation|) (179 . |rhs|) (184 . |subst|)
              |FORTRAN;coerce;E$;9| (|Expression| (|MachineComplex|))
              (190 . |variables|) (195 . |assign|) |FORTRAN;coerce;E$;10|
              (|Equation| 74) (201 . |lhs|) (206 . |retractIfCan|)
              (211 . |coerce|) (216 . |equation|) (222 . |rhs|) (227 . |subst|)
              |FORTRAN;coerce;E$;11|
              (|Record| (|:| |localSymbols| 11) (|:| |code| 89))
              |FORTRAN;coerce;R$;12| |FORTRAN;coerce;$Of;13| (|List| 16)
              |FORTRAN;coerce;L$;14| |FORTRAN;coerce;Fc$;15| (|Expression| 13)
              (233 . |variables|) (238 . |assign|) |FORTRAN;coerce;E$;16|
              (|Equation| 92) (244 . |lhs|) (249 . |retractIfCan|)
              (254 . |coerce|) (259 . |equation|) (265 . |rhs|) (270 . |subst|)
              |FORTRAN;coerce;E$;17| (|Expression| (|Float|))
              (276 . |variables|) (281 . |assign|) |FORTRAN;coerce;E$;18|
              (|Equation| 104) (287 . |lhs|) (292 . |retractIfCan|)
              (297 . |coerce|) (302 . |equation|) (308 . |rhs|) (313 . |subst|)
              |FORTRAN;coerce;E$;19| (|Expression| (|Complex| (|Float|)))
              (319 . |variables|) (324 . |assign|) |FORTRAN;coerce;E$;20|
              (|Equation| 116) (330 . |lhs|) (335 . |retractIfCan|)
              (340 . |coerce|) (345 . |equation|) (351 . |rhs|) (356 . |subst|)
              |FORTRAN;coerce;E$;21|)
           '#(|outputAsFortran| 362 |coerce| 367) 'NIL
           (CONS (|makeByteWordVec2| 1 '(0 0 0))
                 (CONS '#(NIL NIL NIL)
                       (CONS
                        '#((|FortranProgramCategory|) (|Type|)
                           (|CoercibleTo| 25))
                        (|makeByteWordVec2| 127
                                            '(0 11 0 12 1 14 0 13 15 1 16 14 14
                                              17 1 20 18 19 21 1 16 22 0 23 0
                                              20 19 24 1 26 25 0 27 1 19 25 0
                                              28 1 29 25 0 30 1 11 18 0 31 1 20
                                              18 19 32 1 20 18 19 33 0 18 0 34
                                              1 36 0 25 37 1 36 38 0 39 1 19 0
                                              0 40 2 29 0 41 0 42 2 29 0 0 0 43
                                              2 29 44 0 0 45 1 38 25 0 46 1 47
                                              29 0 48 2 16 0 19 47 49 0 16 0 50
                                              1 52 47 0 53 1 47 54 0 55 1 47 0
                                              19 56 2 52 0 47 47 57 1 52 47 0
                                              58 2 47 0 0 59 60 1 62 29 0 63 2
                                              16 0 19 62 64 1 66 62 0 67 1 62
                                              54 0 68 1 62 0 19 69 2 66 0 62 62
                                              70 1 66 62 0 71 2 62 0 0 59 72 1
                                              74 29 0 75 2 16 0 19 74 76 1 78
                                              74 0 79 1 74 54 0 80 1 74 0 19 81
                                              2 78 0 74 74 82 1 78 74 0 83 2 74
                                              0 0 59 84 1 92 29 0 93 2 16 0 19
                                              92 94 1 96 92 0 97 1 92 54 0 98 1
                                              92 0 19 99 2 96 0 92 92 100 1 96
                                              92 0 101 2 92 0 0 59 102 1 104 29
                                              0 105 2 16 0 19 104 106 1 108 104
                                              0 109 1 104 54 0 110 1 104 0 19
                                              111 2 108 0 104 104 112 1 108 104
                                              0 113 2 104 0 0 59 114 1 116 29 0
                                              117 2 16 0 19 116 118 1 120 116 0
                                              121 1 116 54 0 122 1 116 0 19 123
                                              2 120 0 116 116 124 1 120 116 0
                                              125 2 116 0 0 59 126 1 0 18 0 35
                                              1 0 0 108 115 1 0 0 120 127 1 0 0
                                              116 119 1 0 0 96 103 1 0 0 92 95
                                              1 0 0 104 107 1 0 0 66 73 1 0 0
                                              78 85 1 0 0 74 77 1 0 0 52 61 1 0
                                              0 47 51 1 0 0 62 65 1 0 0 89 90 1
                                              0 0 86 87 1 0 0 16 91 1 0 25 0
                                              88)))))
           '|lookupComplete|)) 
