
(/VERSIONCHECK 2) 

(DEFUN |FC;setLabelValue;2Si;1| (|u| $) (SETELT $ 10 |u|)) 

(DEFUN |FC;newLabel| ($)
  (SEQ (SETELT $ 10 (QSPLUS (QREFELT $ 10) 1)) (EXIT (QREFELT $ 10)))) 

(DEFUN |FC;commaSep| (|l| $)
  (PROG (#1=#:G1833 #2=#:G1832 #3=#:G1834 #4=#:G1836 |u|)
    (RETURN
     (SEQ
      (CONS (SPADCALL |l| 1 (QREFELT $ 16))
            (PROGN
             (LETT #1# NIL . #5=(|FC;commaSep|))
             (SEQ (LETT |u| NIL . #5#) (LETT #4# (CDR |l|) . #5#) G190
                  (COND
                   ((OR (ATOM #4#) (PROGN (LETT |u| (CAR #4#) . #5#) NIL))
                    (GO G191)))
                  (SEQ
                   (EXIT
                    (PROGN
                     (LETT #3# (LIST "," |u|) . #5#)
                     (COND (#1# (LETT #2# (APPEND #2# #3#) . #5#))
                           ('T
                            (PROGN
                             (LETT #2# #3# . #5#)
                             (LETT #1# 'T . #5#)))))))
                  (LETT #4# (CDR #4#) . #5#) (GO G190) G191 (EXIT NIL))
             (COND (#1# #2#) ('T NIL)))))))) 

(DEFUN |FC;getReturn| (|rec| $)
  (PROG (|rv| |rt| |returnToken|)
    (RETURN
     (SEQ
      (LETT |returnToken|
            (SPADCALL (SPADCALL 'RETURN (QREFELT $ 19)) (QREFELT $ 21))
            . #1=(|FC;getReturn|))
      (EXIT
       (COND ((QCAR |rec|) (|getStatement| |returnToken| NIL))
             ('T
              (SEQ (LETT |rt| (QCDR |rec|) . #1#) (LETT |rv| (QCDR |rt|) . #1#)
                   (EXIT
                    (|getStatement|
                     (|construct| |returnToken| (SPADCALL |rv| (QREFELT $ 21)))
                     (QCAR |rt|))))))))))) 

(DEFUN |FC;getStop| ($) (|fortran2Lines| (LIST "STOP"))) 

(DEFUN |FC;getSave| ($) (|fortran2Lines| (LIST "SAVE"))) 

(DEFUN |FC;getCommon| (|u| $)
  (|fortran2Lines|
   (APPEND (LIST "COMMON" " /" (SPADCALL (QCAR |u|) (QREFELT $ 22)) "/ ")
           (|addCommas| (QCDR |u|))))) 

(DEFUN |FC;getPrint| (|l| $)
  (PROG (|ll| #1=#:G1854 |i|)
    (RETURN
     (SEQ (LETT |ll| (LIST "PRINT*") . #2=(|FC;getPrint|))
          (SEQ (LETT |i| NIL . #2#) (LETT #1# |l| . #2#) G190
               (COND
                ((OR (ATOM #1#) (PROGN (LETT |i| (CAR #1#) . #2#) NIL))
                 (GO G191)))
               (SEQ
                (EXIT
                 (LETT |ll| (APPEND |ll| (CONS "," (|expression2Fortran| |i|)))
                       . #2#)))
               (LETT #1# (CDR #1#) . #2#) (GO G190) G191 (EXIT NIL))
          (EXIT (|fortran2Lines| |ll|)))))) 

(DEFUN |FC;getBlock| (|rec| $)
  (PROG (|expr| #1=#:G1860 |u|)
    (RETURN
     (SEQ (|indentFortLevel| (SPADCALL 1 (QREFELT $ 23)))
          (LETT |expr| (LIST) . #2=(|FC;getBlock|))
          (SEQ (LETT |u| NIL . #2#) (LETT #1# |rec| . #2#) G190
               (COND
                ((OR (ATOM #1#) (PROGN (LETT |u| (CAR #1#) . #2#) NIL))
                 (GO G191)))
               (SEQ
                (EXIT
                 (LETT |expr| (APPEND |expr| (SPADCALL |u| (QREFELT $ 24)))
                       . #2#)))
               (LETT #1# (CDR #1#) . #2#) (GO G190) G191 (EXIT NIL))
          (|indentFortLevel| (SPADCALL -1 (QREFELT $ 23))) (EXIT |expr|))))) 

(DEFUN |FC;getBody| (|f| $)
  (PROG (|expr|)
    (RETURN
     (SEQ
      (COND
       ((QEQCAR (SPADCALL |f| (QREFELT $ 26)) 4) (SPADCALL |f| (QREFELT $ 24)))
       ('T
        (SEQ (|indentFortLevel| (SPADCALL 1 (QREFELT $ 23)))
             (LETT |expr| (SPADCALL |f| (QREFELT $ 24)) |FC;getBody|)
             (|indentFortLevel| (SPADCALL -1 (QREFELT $ 23)))
             (EXIT |expr|)))))))) 

(DEFUN |FC;getElseIf| (|f| $)
  (PROG (|expr| |elseBranch| #1=#:G1926 |rec|)
    (RETURN
     (SEQ (LETT |rec| (SPADCALL |f| (QREFELT $ 36)) . #2=(|FC;getElseIf|))
          (LETT |expr|
                (|fortFormatElseIf|
                 (SPADCALL
                  (QVELT
                   (PROG2
                       (LETT #1# |rec| . #2#)
                       (QCDR #1#)
                     (|check-union| (QEQCAR #1# 3)
                                    (|Record| (|:| |switch| (|Switch|))
                                              (|:| |thenClause| $)
                                              (|:| |elseClause| $))
                                    #1#))
                   0)
                  (QREFELT $ 38)))
                . #2#)
          (LETT |expr|
                (APPEND |expr|
                        (|FC;getBody|
                         (QVELT
                          (PROG2
                              (LETT #1# |rec| . #2#)
                              (QCDR #1#)
                            (|check-union| (QEQCAR #1# 3)
                                           (|Record| (|:| |switch| (|Switch|))
                                                     (|:| |thenClause| $)
                                                     (|:| |elseClause| $))
                                           #1#))
                          1)
                         $))
                . #2#)
          (LETT |elseBranch|
                (QVELT
                 (PROG2
                     (LETT #1# |rec| . #2#)
                     (QCDR #1#)
                   (|check-union| (QEQCAR #1# 3)
                                  (|Record| (|:| |switch| (|Switch|))
                                            (|:| |thenClause| $)
                                            (|:| |elseClause| $))
                                  #1#))
                 2)
                . #2#)
          (COND
           ((NULL (QEQCAR (SPADCALL |elseBranch| (QREFELT $ 26)) 0))
            (EXIT
             (COND
              ((QEQCAR (SPADCALL |elseBranch| (QREFELT $ 26)) 2)
               (APPEND |expr| (|FC;getElseIf| |elseBranch| $)))
              ('T
               (SEQ
                (LETT |expr| (APPEND |expr| (|getStatement| 'ELSE NIL)) . #2#)
                (EXIT
                 (LETT |expr| (APPEND |expr| (|FC;getBody| |elseBranch| $))
                       . #2#))))))))
          (EXIT |expr|))))) 

(DEFUN |FC;getContinue| (|label| $)
  (PROG (|sp| |cnt| |lab|)
    (RETURN
     (SEQ
      (LETT |lab| (SPADCALL |label| (QREFELT $ 39)) . #1=(|FC;getContinue|))
      (COND ((< 6 (SPADCALL |lab| (QREFELT $ 41))) (|error| "Label too big")))
      (LETT |cnt| "CONTINUE" . #1#)
      (LETT |sp|
            (SPADCALL (- |$fortIndent| (SPADCALL |lab| (QREFELT $ 41)))
                      (QREFELT $ 42))
            . #1#)
      (EXIT (LIST (STRCONC (STRINGIMAGE |lab|) |sp| |cnt|))))))) 

(DEFUN |FC;getGoto| (|label| $)
  (|fortran2Lines|
   (LIST (STRCONC "GOTO " (STRINGIMAGE (SPADCALL |label| (QREFELT $ 39))))))) 

(DEFUN |FC;getRepeat| (|repRec| $)
  (PROG (|bod| |lab| |sw|)
    (RETURN
     (SEQ
      (LETT |sw| (SPADCALL (QCAR |repRec|) (QREFELT $ 43))
            . #1=(|FC;getRepeat|))
      (LETT |lab| (|FC;newLabel| $) . #1#) (LETT |bod| (QCDR |repRec|) . #1#)
      (EXIT
       (APPEND (|FC;getContinue| |lab| $) (|FC;getBody| |bod| $)
               (|fortFormatIfGoto| (SPADCALL |sw| (QREFELT $ 38)) |lab|))))))) 

(DEFUN |FC;getWhile| (|whileRec| $)
  (PROG (|bod| |lab2| |lab1| |sw|)
    (RETURN
     (SEQ
      (LETT |sw| (SPADCALL (QCAR |whileRec|) (QREFELT $ 43))
            . #1=(|FC;getWhile|))
      (LETT |lab1| (|FC;newLabel| $) . #1#)
      (LETT |lab2| (|FC;newLabel| $) . #1#)
      (LETT |bod| (QCDR |whileRec|) . #1#)
      (EXIT
       (APPEND
        (|fortFormatLabelledIfGoto| (SPADCALL |sw| (QREFELT $ 38)) |lab1|
                                    |lab2|)
        (|FC;getBody| |bod| $)
        (|FC;getBody| (SPADCALL |lab1| (QREFELT $ 44)) $)
        (|FC;getContinue| |lab2| $))))))) 

(DEFUN |FC;getArrayAssign| (|rec| $)
  (|getfortarrayexp| (SPADCALL (QVELT |rec| 0) (QREFELT $ 19)) (QVELT |rec| 1)
                     (QVELT |rec| 2))) 

(DEFUN |FC;getAssign| (|rec| $)
  (PROG (|lhs| |indices|)
    (RETURN
     (SEQ (LETT |indices| (QVELT |rec| 1) . #1=(|FC;getAssign|))
          (COND
           ((SPADCALL |indices| NIL (QREFELT $ 47))
            (LETT |lhs| (SPADCALL (QVELT |rec| 0) (QREFELT $ 19)) . #1#))
           (#2='T
            (SEQ
             (LETT |lhs|
                   (SPADCALL
                    (CONS (SPADCALL (QVELT |rec| 0) (QREFELT $ 48)) |indices|)
                    (QREFELT $ 49))
                   . #1#)
             (EXIT
              (LETT |lhs|
                    (SPADCALL
                     (SPADCALL
                      (SPADCALL
                       (SPADCALL (SPADCALL |lhs| (QREFELT $ 21))
                                 (QREFELT $ 50))
                       (QREFELT $ 51))
                      (QREFELT $ 50))
                     (QREFELT $ 52))
                    . #1#)))))
          (EXIT
           (COND
            ((QCAR (QVELT |rec| 2))
             (|assignment2Fortran1| |lhs| (QCDR (QVELT |rec| 2))))
            (#2#
             (|integerAssignment2Fortran1| |lhs| (QCDR (QVELT |rec| 2)))))))))) 

(DEFUN |FC;getCond| (|rec| $)
  (PROG (|expr| |elseBranch|)
    (RETURN
     (SEQ
      (LETT |expr|
            (APPEND (|fortFormatIf| (SPADCALL (QVELT |rec| 0) (QREFELT $ 38)))
                    (|FC;getBody| (QVELT |rec| 1) $))
            . #1=(|FC;getCond|))
      (LETT |elseBranch| (QVELT |rec| 2) . #1#)
      (COND
       ((NULL (QEQCAR (SPADCALL |elseBranch| (QREFELT $ 26)) 0))
        (COND
         ((QEQCAR (SPADCALL |elseBranch| (QREFELT $ 26)) 2)
          (LETT |expr| (APPEND |expr| (|FC;getElseIf| |elseBranch| $)) . #1#))
         ('T
          (LETT |expr|
                (APPEND |expr| (|getStatement| 'ELSE NIL)
                        (|FC;getBody| |elseBranch| $))
                . #1#)))))
      (EXIT (APPEND |expr| (|getStatement| 'ENDIF NIL))))))) 

(DEFUN |FC;getComment| (|rec| $)
  (PROG (#1=#:G1998 |c| #2=#:G1997)
    (RETURN
     (SEQ
      (SPADCALL
       (PROGN
        (LETT #2# NIL . #3=(|FC;getComment|))
        (SEQ (LETT |c| NIL . #3#) (LETT #1# |rec| . #3#) G190
             (COND
              ((OR (ATOM #1#) (PROGN (LETT |c| (CAR #1#) . #3#) NIL))
               (GO G191)))
             (SEQ
              (EXIT
               (LETT #2#
                     (CONS (SPADCALL (STRCONC "C     " |c|) (QREFELT $ 53))
                           #2#)
                     . #3#)))
             (LETT #1# (CDR #1#) . #3#) (GO G190) G191 (EXIT (NREVERSE0 #2#))))
       (QREFELT $ 55)))))) 

(DEFUN |FC;getCall| (|rec| $)
  (PROG (|expr|)
    (RETURN
     (SEQ (LETT |expr| (STRCONC "CALL " |rec|) |FC;getCall|)
          (EXIT
           (COND ((< 1320 (QCSIZE |expr|)) (|error| "Fortran CALL too large"))
                 ('T
                  (|fortran2Lines|
                   (SPADCALL (LIST (SPADCALL |expr| (QREFELT $ 53)))
                             (QREFELT $ 55)))))))))) 

(DEFUN |FC;getFor| (|rec| $)
  (PROG (|expr| |lab| |increment| |rnge|)
    (RETURN
     (SEQ (LETT |rnge| (QVELT |rec| 0) . #1=(|FC;getFor|))
          (LETT |increment| (QVELT |rec| 1) . #1#)
          (LETT |lab| (|FC;newLabel| $) . #1#)
          (SPADCALL (SPADCALL |rnge| (QREFELT $ 57)) (SPADCALL (QREFELT $ 59))
                    (QREFELT $ 61))
          (LETT |expr|
                (|fortFormatDo| (SPADCALL |rnge| (QREFELT $ 57))
                                (SPADCALL
                                 (SPADCALL (SPADCALL |rnge| (QREFELT $ 63))
                                           (QREFELT $ 64))
                                 (QREFELT $ 65))
                                (SPADCALL
                                 (SPADCALL (SPADCALL |rnge| (QREFELT $ 63))
                                           (QREFELT $ 66))
                                 (QREFELT $ 65))
                                (SPADCALL |increment| (QREFELT $ 65)) |lab|)
                . #1#)
          (EXIT
           (APPEND |expr| (|FC;getBody| (QVELT |rec| 2) $)
                   (|FC;getContinue| |lab| $))))))) 

(DEFUN |FC;getCode;$Se;22| (|f| $)
  (PROG (#1=#:G2036 #2=#:G2037 #3=#:G2035 #4=#:G2034 #5=#:G2033 #6=#:G2032
         #7=#:G2031 #8=#:G2030 #9=#:G2029 #10=#:G2028 #11=#:G2027 #12=#:G2026
         |rec| |opp|)
    (RETURN
     (SEQ
      (LETT |opp| (SPADCALL |f| (QREFELT $ 26)) . #13=(|FC;getCode;$Se;22|))
      (LETT |rec| (SPADCALL |f| (QREFELT $ 36)) . #13#)
      (EXIT
       (COND
        ((QEQCAR |opp| 1)
         (|FC;getAssign|
          (PROG2
              (LETT #12# |rec| . #13#)
              (QCDR #12#)
            (|check-union| (QEQCAR #12# 1)
                           (|Record| (|:| |var| (|Symbol|))
                                     (|:| |arrayIndex|
                                          (|List| (|Polynomial| (|Integer|))))
                                     (|:| |rand|
                                          (|Record|
                                           (|:| |ints2Floats?| (|Boolean|))
                                           (|:| |expr| (|OutputForm|)))))
                           #12#))
          $))
        ((QEQCAR |opp| 12)
         (|FC;getArrayAssign|
          (PROG2
              (LETT #11# |rec| . #13#)
              (QCDR #11#)
            (|check-union| (QEQCAR #11# 2)
                           (|Record| (|:| |var| (|Symbol|))
                                     (|:| |rand| (|OutputForm|))
                                     (|:| |ints2Floats?| (|Boolean|)))
                           #11#))
          $))
        ((QEQCAR |opp| 2)
         (|FC;getCond|
          (PROG2
              (LETT #10# |rec| . #13#)
              (QCDR #10#)
            (|check-union| (QEQCAR #10# 3)
                           (|Record| (|:| |switch| (|Switch|))
                                     (|:| |thenClause| $) (|:| |elseClause| $))
                           #10#))
          $))
        ((QEQCAR |opp| 3)
         (|FC;getReturn|
          (PROG2
              (LETT #9# |rec| . #13#)
              (QCDR #9#)
            (|check-union| (QEQCAR #9# 4)
                           (|Record| (|:| |empty?| (|Boolean|))
                                     (|:| |value|
                                          (|Record|
                                           (|:| |ints2Floats?| (|Boolean|))
                                           (|:| |expr| (|OutputForm|)))))
                           #9#))
          $))
        ((QEQCAR |opp| 4)
         (|FC;getBlock|
          (PROG2
              (LETT #8# |rec| . #13#)
              (QCDR #8#)
            (|check-union| (QEQCAR #8# 5) (|List| $) #8#))
          $))
        ((QEQCAR |opp| 5)
         (|FC;getComment|
          (PROG2
              (LETT #7# |rec| . #13#)
              (QCDR #7#)
            (|check-union| (QEQCAR #7# 6) (|List| (|String|)) #7#))
          $))
        ((QEQCAR |opp| 6)
         (|FC;getCall|
          (PROG2
              (LETT #6# |rec| . #13#)
              (QCDR #6#)
            (|check-union| (QEQCAR #6# 7) (|String|) #6#))
          $))
        ((QEQCAR |opp| 7)
         (|FC;getFor|
          (PROG2
              (LETT #5# |rec| . #13#)
              (QCDR #5#)
            (|check-union| (QEQCAR #5# 8)
                           (|Record|
                            (|:| |range|
                                 (|SegmentBinding| (|Polynomial| (|Integer|))))
                            (|:| |span| (|Polynomial| (|Integer|)))
                            (|:| |body| $))
                           #5#))
          $))
        ((QEQCAR |opp| 11)
         (|FC;getContinue|
          (PROG2
              (LETT #4# |rec| . #13#)
              (QCDR #4#)
            (|check-union| (QEQCAR #4# 9) (|SingleInteger|) #4#))
          $))
        ((QEQCAR |opp| 10)
         (|FC;getGoto|
          (PROG2
              (LETT #4# |rec| . #13#)
              (QCDR #4#)
            (|check-union| (QEQCAR #4# 9) (|SingleInteger|) #4#))
          $))
        ((QEQCAR |opp| 9)
         (|FC;getRepeat|
          (PROG2
              (LETT #3# |rec| . #13#)
              (QCDR #3#)
            (|check-union| (QEQCAR #3# 10)
                           (|Record| (|:| |switch| (|Switch|)) (|:| |body| $))
                           #3#))
          $))
        ((QEQCAR |opp| 8)
         (|FC;getWhile|
          (PROG2
              (LETT #3# |rec| . #13#)
              (QCDR #3#)
            (|check-union| (QEQCAR #3# 10)
                           (|Record| (|:| |switch| (|Switch|)) (|:| |body| $))
                           #3#))
          $))
        ((QEQCAR |opp| 13) (|FC;getSave| $))
        ((QEQCAR |opp| 14) (|FC;getStop| $))
        ((QEQCAR |opp| 16)
         (|FC;getPrint|
          (PROG2
              (LETT #2# |rec| . #13#)
              (QCDR #2#)
            (|check-union| (QEQCAR #2# 12) (|List| (|OutputForm|)) #2#))
          $))
        ((QEQCAR |opp| 15)
         (|FC;getCommon|
          (PROG2
              (LETT #1# |rec| . #13#)
              (QCDR #1#)
            (|check-union| (QEQCAR #1# 11)
                           (|Record| (|:| |name| (|Symbol|))
                                     (|:| |contents| (|List| (|Symbol|))))
                           #1#))
          $))
        ('T
         (SEQ (|error| "Unsupported program construct.")
              (EXIT (SPADCALL 0.0 (QREFELT $ 69))))))))))) 

(DEFUN |FC;printCode;$V;23| (|f| $)
  (SEQ (|displayLines1| (SPADCALL |f| (QREFELT $ 24)))
       (EXIT (SPADCALL (QREFELT $ 71))))) 

(PUT '|FC;code;$U;24| '|SPADreplace| 'QCDR) 

(DEFUN |FC;code;$U;24| (|f| $) (QCDR |f|)) 

(PUT '|FC;operation;$U;25| '|SPADreplace| 'QCAR) 

(DEFUN |FC;operation;$U;25| (|f| $) (QCAR |f|)) 

(DEFUN |FC;common;SL$;26| (|name| |contents| $)
  (CONS (CONS 15 "common") (CONS 11 (CONS |name| |contents|)))) 

(DEFUN |FC;stop;$;27| ($) (CONS (CONS 14 "stop") (CONS 0 "null"))) 

(DEFUN |FC;save;$;28| ($) (CONS (CONS 13 "save") (CONS 0 "null"))) 

(DEFUN |FC;printStatement;L$;29| (|l| $) (CONS (CONS 16 "print") (CONS 12 |l|))) 

(DEFUN |FC;comment;L$;30| (|s| $) (CONS (CONS 5 "comment") (CONS 6 |s|))) 

(DEFUN |FC;comment;S$;31| (|s| $)
  (CONS (CONS 5 "comment") (CONS 6 (SPADCALL |s| (QREFELT $ 80))))) 

(DEFUN |FC;forLoop;Sb2$;32| (|r| |body| $)
  (CONS (CONS 7 "for")
        (CONS 8
              (VECTOR |r|
                      (SPADCALL
                       (SPADCALL (SPADCALL |r| (QREFELT $ 63)) (QREFELT $ 82))
                       (QREFELT $ 83))
                      |body|)))) 

(DEFUN |FC;forLoop;SbP2$;33| (|r| |increment| |body| $)
  (CONS (CONS 7 "for") (CONS 8 (VECTOR |r| |increment| |body|)))) 

(DEFUN |FC;goto;Si$;34| (|l| $) (CONS (CONS 10 "goto") (CONS 9 |l|))) 

(DEFUN |FC;continue;Si$;35| (|l| $) (CONS (CONS 11 "continue") (CONS 9 |l|))) 

(DEFUN |FC;whileLoop;S2$;36| (|sw| |b| $)
  (CONS (CONS 8 "while") (CONS 10 (CONS |sw| |b|)))) 

(DEFUN |FC;repeatUntilLoop;S2$;37| (|sw| |b| $)
  (CONS (CONS 9 "repeat") (CONS 10 (CONS |sw| |b|)))) 

(DEFUN |FC;returns;$;38| ($)
  (PROG (|v|)
    (RETURN
     (SEQ
      (LETT |v| (CONS 'NIL (SPADCALL (|spadConstant| $ 67) (QREFELT $ 65)))
            |FC;returns;$;38|)
      (EXIT (CONS (CONS 3 "return") (CONS 4 (CONS 'T |v|)))))))) 

(DEFUN |FC;returns;E$;39| (|v| $)
  (CONS (CONS 3 "return")
        (CONS 4 (CONS 'NIL (CONS 'NIL (SPADCALL |v| (QREFELT $ 91))))))) 

(DEFUN |FC;returns;E$;40| (|v| $)
  (CONS (CONS 3 "return")
        (CONS 4 (CONS 'NIL (CONS 'NIL (SPADCALL |v| (QREFELT $ 94))))))) 

(DEFUN |FC;returns;E$;41| (|v| $)
  (CONS (CONS 3 "return")
        (CONS 4 (CONS 'NIL (CONS 'NIL (SPADCALL |v| (QREFELT $ 97))))))) 

(DEFUN |FC;returns;E$;42| (|v| $)
  (CONS (CONS 3 "return")
        (CONS 4 (CONS 'NIL (CONS 'NIL (SPADCALL |v| (QREFELT $ 100))))))) 

(DEFUN |FC;returns;E$;43| (|v| $)
  (CONS (CONS 3 "return")
        (CONS 4 (CONS 'NIL (CONS 'NIL (SPADCALL |v| (QREFELT $ 103))))))) 

(DEFUN |FC;returns;E$;44| (|v| $)
  (CONS (CONS 3 "return")
        (CONS 4 (CONS 'NIL (CONS 'NIL (SPADCALL |v| (QREFELT $ 106))))))) 

(DEFUN |FC;block;L$;45| (|l| $) (CONS (CONS 4 "block") (CONS 5 |l|))) 

(DEFUN |FC;cond;S2$;46| (|sw| |thenC| $)
  (CONS (CONS 2 "conditional")
        (CONS 3 (VECTOR |sw| |thenC| (CONS (CONS 0 "null") (CONS 0 "null")))))) 

(DEFUN |FC;cond;S3$;47| (|sw| |thenC| |elseC| $)
  (CONS (CONS 2 "conditional") (CONS 3 (VECTOR |sw| |thenC| |elseC|)))) 

(DEFUN |FC;coerce;$Of;48| (|f| $) (SPADCALL (QCAR |f|) (QREFELT $ 111))) 

(DEFUN |FC;assign;SS$;49| (|v| |rhs| $)
  (CONS (CONS 1 "assignment")
        (CONS 1 (VECTOR |v| NIL (CONS 'NIL (SPADCALL |rhs| (QREFELT $ 113))))))) 

(DEFUN |FC;assign;SM$;50| (|v| |rhs| $)
  (CONS (CONS 12 "arrayAssignment")
        (CONS 2 (VECTOR |v| (SPADCALL |rhs| (QREFELT $ 116)) 'NIL)))) 

(DEFUN |FC;assign;SM$;51| (|v| |rhs| $)
  (CONS (CONS 12 "arrayAssignment")
        (CONS 2 (VECTOR |v| (SPADCALL |rhs| (QREFELT $ 119)) 'T)))) 

(DEFUN |FC;assign;SM$;52| (|v| |rhs| $)
  (CONS (CONS 12 "arrayAssignment")
        (CONS 2 (VECTOR |v| (SPADCALL |rhs| (QREFELT $ 122)) 'T)))) 

(DEFUN |FC;assign;SV$;53| (|v| |rhs| $)
  (CONS (CONS 12 "arrayAssignment")
        (CONS 2 (VECTOR |v| (SPADCALL |rhs| (QREFELT $ 125)) 'NIL)))) 

(DEFUN |FC;assign;SV$;54| (|v| |rhs| $)
  (CONS (CONS 12 "arrayAssignment")
        (CONS 2 (VECTOR |v| (SPADCALL |rhs| (QREFELT $ 128)) 'T)))) 

(DEFUN |FC;assign;SV$;55| (|v| |rhs| $)
  (CONS (CONS 12 "arrayAssignment")
        (CONS 2 (VECTOR |v| (SPADCALL |rhs| (QREFELT $ 131)) 'T)))) 

(DEFUN |FC;assign;SM$;56| (|v| |rhs| $)
  (CONS (CONS 12 "arrayAssignment")
        (CONS 2 (VECTOR |v| (SPADCALL |rhs| (QREFELT $ 134)) 'NIL)))) 

(DEFUN |FC;assign;SM$;57| (|v| |rhs| $)
  (CONS (CONS 12 "arrayAssignment")
        (CONS 2 (VECTOR |v| (SPADCALL |rhs| (QREFELT $ 137)) 'T)))) 

(DEFUN |FC;assign;SM$;58| (|v| |rhs| $)
  (CONS (CONS 12 "arrayAssignment")
        (CONS 2 (VECTOR |v| (SPADCALL |rhs| (QREFELT $ 140)) 'T)))) 

(DEFUN |FC;assign;SV$;59| (|v| |rhs| $)
  (CONS (CONS 12 "arrayAssignment")
        (CONS 2 (VECTOR |v| (SPADCALL |rhs| (QREFELT $ 143)) 'NIL)))) 

(DEFUN |FC;assign;SV$;60| (|v| |rhs| $)
  (CONS (CONS 12 "arrayAssignment")
        (CONS 2 (VECTOR |v| (SPADCALL |rhs| (QREFELT $ 146)) 'T)))) 

(DEFUN |FC;assign;SV$;61| (|v| |rhs| $)
  (CONS (CONS 12 "arrayAssignment")
        (CONS 2 (VECTOR |v| (SPADCALL |rhs| (QREFELT $ 149)) 'T)))) 

(DEFUN |FC;assign;SLE$;62| (|v| |index| |rhs| $)
  (CONS (CONS 1 "assignment")
        (CONS 1
              (VECTOR |v| |index|
                      (CONS 'NIL (SPADCALL |rhs| (QREFELT $ 91))))))) 

(DEFUN |FC;assign;SLE$;63| (|v| |index| |rhs| $)
  (CONS (CONS 1 "assignment")
        (CONS 1
              (VECTOR |v| |index| (CONS 'T (SPADCALL |rhs| (QREFELT $ 94))))))) 

(DEFUN |FC;assign;SLE$;64| (|v| |index| |rhs| $)
  (CONS (CONS 1 "assignment")
        (CONS 1
              (VECTOR |v| |index| (CONS 'T (SPADCALL |rhs| (QREFELT $ 97))))))) 

(DEFUN |FC;assign;SE$;65| (|v| |rhs| $)
  (CONS (CONS 1 "assignment")
        (CONS 1 (VECTOR |v| NIL (CONS 'NIL (SPADCALL |rhs| (QREFELT $ 91))))))) 

(DEFUN |FC;assign;SE$;66| (|v| |rhs| $)
  (CONS (CONS 1 "assignment")
        (CONS 1 (VECTOR |v| NIL (CONS 'T (SPADCALL |rhs| (QREFELT $ 94))))))) 

(DEFUN |FC;assign;SE$;67| (|v| |rhs| $)
  (CONS (CONS 1 "assignment")
        (CONS 1 (VECTOR |v| NIL (CONS 'T (SPADCALL |rhs| (QREFELT $ 97))))))) 

(DEFUN |FC;assign;SM$;68| (|v| |rhs| $)
  (CONS (CONS 12 "arrayAssignment")
        (CONS 2 (VECTOR |v| (SPADCALL |rhs| (QREFELT $ 158)) 'NIL)))) 

(DEFUN |FC;assign;SM$;69| (|v| |rhs| $)
  (CONS (CONS 12 "arrayAssignment")
        (CONS 2 (VECTOR |v| (SPADCALL |rhs| (QREFELT $ 161)) 'T)))) 

(DEFUN |FC;assign;SM$;70| (|v| |rhs| $)
  (CONS (CONS 12 "arrayAssignment")
        (CONS 2 (VECTOR |v| (SPADCALL |rhs| (QREFELT $ 164)) 'T)))) 

(DEFUN |FC;assign;SV$;71| (|v| |rhs| $)
  (CONS (CONS 12 "arrayAssignment")
        (CONS 2 (VECTOR |v| (SPADCALL |rhs| (QREFELT $ 167)) 'NIL)))) 

(DEFUN |FC;assign;SV$;72| (|v| |rhs| $)
  (CONS (CONS 12 "arrayAssignment")
        (CONS 2 (VECTOR |v| (SPADCALL |rhs| (QREFELT $ 170)) 'T)))) 

(DEFUN |FC;assign;SV$;73| (|v| |rhs| $)
  (CONS (CONS 12 "arrayAssignment")
        (CONS 2 (VECTOR |v| (SPADCALL |rhs| (QREFELT $ 173)) 'T)))) 

(DEFUN |FC;assign;SLE$;74| (|v| |index| |rhs| $)
  (CONS (CONS 1 "assignment")
        (CONS 1
              (VECTOR |v| |index|
                      (CONS 'NIL (SPADCALL |rhs| (QREFELT $ 100))))))) 

(DEFUN |FC;assign;SLE$;75| (|v| |index| |rhs| $)
  (CONS (CONS 1 "assignment")
        (CONS 1
              (VECTOR |v| |index| (CONS 'T (SPADCALL |rhs| (QREFELT $ 103))))))) 

(DEFUN |FC;assign;SLE$;76| (|v| |index| |rhs| $)
  (CONS (CONS 1 "assignment")
        (CONS 1
              (VECTOR |v| |index| (CONS 'T (SPADCALL |rhs| (QREFELT $ 106))))))) 

(DEFUN |FC;assign;SE$;77| (|v| |rhs| $)
  (CONS (CONS 1 "assignment")
        (CONS 1 (VECTOR |v| NIL (CONS 'NIL (SPADCALL |rhs| (QREFELT $ 100))))))) 

(DEFUN |FC;assign;SE$;78| (|v| |rhs| $)
  (CONS (CONS 1 "assignment")
        (CONS 1 (VECTOR |v| NIL (CONS 'T (SPADCALL |rhs| (QREFELT $ 103))))))) 

(DEFUN |FC;assign;SE$;79| (|v| |rhs| $)
  (CONS (CONS 1 "assignment")
        (CONS 1 (VECTOR |v| NIL (CONS 'T (SPADCALL |rhs| (QREFELT $ 106))))))) 

(DEFUN |FC;call;S$;80| (|s| $) (CONS (CONS 6 "call") (CONS 7 |s|))) 

(DEFUN |FortranCode| #1=()
  (PROG #1#
    (RETURN
     (PROG (#2=#:G4029)
       (RETURN
        (COND
         ((LETT #2# (HGET |$ConstructorCache| '|FortranCode|)
                . #3=(|FortranCode|))
          (|CDRwithIncrement| (CDAR #2#)))
         ('T
          (UNWIND-PROTECT
              (PROG1
                  (CDDAR
                   (HPUT |$ConstructorCache| '|FortranCode|
                         (LIST (CONS NIL (CONS 1 (|FortranCode;|))))))
                (LETT #2# T . #3#))
            (COND ((NOT #2#) (HREM |$ConstructorCache| '|FortranCode|))))))))))) 

(DEFUN |FortranCode;| ()
  (PROG (|dv$| $ |pv$|)
    (RETURN
     (PROGN
      (LETT |dv$| '(|FortranCode|) . #1=(|FortranCode|))
      (LETT $ (GETREFV 182) . #1#)
      (QSETREFV $ 0 |dv$|)
      (QSETREFV $ 3 (LETT |pv$| (|buildPredVector| 0 0 NIL) . #1#))
      (|haddProp| |$ConstructorCache| '|FortranCode| NIL (CONS 1 $))
      (|stuffDomainSlots| $)
      (SETF |pv$| (QREFELT $ 3))
      (QSETREFV $ 6
                (|Record|
                 (|:| |op|
                      (|Union| (|:| |Null| #2="null")
                               (|:| |Assignment| "assignment")
                               (|:| |Conditional| "conditional")
                               (|:| |Return| "return") (|:| |Block| "block")
                               (|:| |Comment| "comment") (|:| |Call| "call")
                               (|:| |For| "for") (|:| |While| "while")
                               (|:| |Repeat| "repeat") (|:| |Goto| "goto")
                               (|:| |Continue| "continue")
                               (|:| |ArrayAssignment| "arrayAssignment")
                               (|:| |Save| "save") (|:| |Stop| "stop")
                               (|:| |Common| "common") (|:| |Print| "print")))
                 (|:| |data|
                      (|Union| (|:| |nullBranch| #2#)
                               (|:| |assignmentBranch|
                                    (|Record| (|:| |var| (|Symbol|))
                                              (|:| |arrayIndex|
                                                   (|List|
                                                    (|Polynomial|
                                                     (|Integer|))))
                                              (|:| |rand|
                                                   (|Record|
                                                    (|:| |ints2Floats?|
                                                         (|Boolean|))
                                                    (|:| |expr|
                                                         (|OutputForm|))))))
                               (|:| |arrayAssignmentBranch|
                                    (|Record| (|:| |var| (|Symbol|))
                                              (|:| |rand| (|OutputForm|))
                                              (|:| |ints2Floats?|
                                                   (|Boolean|))))
                               (|:| |conditionalBranch|
                                    (|Record| (|:| |switch| (|Switch|))
                                              (|:| |thenClause| $)
                                              (|:| |elseClause| $)))
                               (|:| |returnBranch|
                                    (|Record| (|:| |empty?| (|Boolean|))
                                              (|:| |value|
                                                   (|Record|
                                                    (|:| |ints2Floats?|
                                                         (|Boolean|))
                                                    (|:| |expr|
                                                         (|OutputForm|))))))
                               (|:| |blockBranch| (|List| $))
                               (|:| |commentBranch| (|List| (|String|)))
                               (|:| |callBranch| (|String|))
                               (|:| |forBranch|
                                    (|Record|
                                     (|:| |range|
                                          (|SegmentBinding|
                                           (|Polynomial| (|Integer|))))
                                     (|:| |span| (|Polynomial| (|Integer|)))
                                     (|:| |body| $)))
                               (|:| |labelBranch| (|SingleInteger|))
                               (|:| |loopBranch|
                                    (|Record| (|:| |switch| (|Switch|))
                                              (|:| |body| $)))
                               (|:| |commonBranch|
                                    (|Record| (|:| |name| (|Symbol|))
                                              (|:| |contents|
                                                   (|List| (|Symbol|)))))
                               (|:| |printBranch| (|List| (|OutputForm|)))))))
      (QSETREFV $ 10 (SPADCALL 25000 (QREFELT $ 9)))
      $)))) 

(MAKEPROP '|FortranCode| '|infovec|
          (LIST
           '#(NIL NIL NIL NIL NIL NIL '|Rep| (|Integer|) (|SingleInteger|)
              (0 . |coerce|) '|labelValue| |FC;setLabelValue;2Si;1|
              (|Polynomial| 7) (5 . |One|) (|String|) (|List| 14) (9 . |elt|)
              (|OutputForm|) (|Symbol|) (15 . |coerce|) (|SExpression|)
              (20 . |convert|) (25 . |string|) (30 . |convert|)
              |FC;getCode;$Se;22|
              (|Union| (|:| |Null| '"null") (|:| |Assignment| '"assignment")
                       (|:| |Conditional| '"conditional")
                       (|:| |Return| '"return") (|:| |Block| '"block")
                       (|:| |Comment| '"comment") (|:| |Call| '"call")
                       (|:| |For| '"for") (|:| |While| '"while")
                       (|:| |Repeat| '"repeat") (|:| |Goto| '"goto")
                       (|:| |Continue| '"continue")
                       (|:| |ArrayAssignment| '"arrayAssignment")
                       (|:| |Save| '"save") (|:| |Stop| '"stop")
                       (|:| |Common| '"common") (|:| |Print| '"print"))
              |FC;operation;$U;25|
              (|Record| (|:| |ints2Floats?| 45) (|:| |expr| 17))
              (|Record| (|:| |var| 18) (|:| |arrayIndex| 46) (|:| |rand| 27))
              (|Record| (|:| |var| 18) (|:| |rand| 17) (|:| |ints2Floats?| 45))
              (|Record| (|:| |switch| 37) (|:| |thenClause| $)
                        (|:| |elseClause| $))
              (|Record| (|:| |empty?| 45) (|:| |value| 27))
              (|Record| (|:| |range| 56) (|:| |span| 12) (|:| |body| $))
              (|Record| (|:| |switch| 37) (|:| |body| $))
              (|Record| (|:| |name| 18) (|:| |contents| 73))
              (|Union| (|:| |nullBranch| '"null") (|:| |assignmentBranch| 28)
                       (|:| |arrayAssignmentBranch| 29)
                       (|:| |conditionalBranch| 30) (|:| |returnBranch| 31)
                       (|:| |blockBranch| 54) (|:| |commentBranch| 15)
                       (|:| |callBranch| 14) (|:| |forBranch| 32)
                       (|:| |labelBranch| 8) (|:| |loopBranch| 33)
                       (|:| |commonBranch| 34) (|:| |printBranch| 77))
              |FC;code;$U;24| (|Switch|) (35 . |coerce|) (40 . |coerce|)
              (45 . |width|) (49 . |width|) (54 . |hspace|) (59 . NOT)
              |FC;goto;Si$;34| (|Boolean|) (|List| 12) (64 . =) (70 . |coerce|)
              (75 . |coerce|) (80 . |cdr|) (85 . |car|) (90 . |coerce|)
              (95 . |convert|) (|List| $) (100 . |convert|)
              (|SegmentBinding| 12) (105 . |variable|) (|FortranType|)
              (110 . |fortranInteger|) (|TheSymbolTable|) (114 . |declare!|)
              (|Segment| 12) (120 . |segment|) (125 . |lo|) (130 . |coerce|)
              (135 . |hi|) (140 . |Zero|) (|DoubleFloat|) (144 . |convert|)
              (|Void|) (149 . |void|) |FC;printCode;$V;23| (|List| 18)
              |FC;common;SL$;26| |FC;stop;$;27| |FC;save;$;28| (|List| 17)
              |FC;printStatement;L$;29| |FC;comment;L$;30| (153 . |list|)
              |FC;comment;S$;31| (158 . |incr|) (163 . |coerce|)
              |FC;forLoop;Sb2$;32| |FC;forLoop;SbP2$;33| |FC;continue;Si$;35|
              |FC;whileLoop;S2$;36| |FC;repeatUntilLoop;S2$;37|
              |FC;returns;$;38| (|Expression| (|MachineInteger|))
              (168 . |coerce|) |FC;returns;E$;39|
              (|Expression| (|MachineFloat|)) (173 . |coerce|)
              |FC;returns;E$;40| (|Expression| (|MachineComplex|))
              (178 . |coerce|) |FC;returns;E$;41| (|Expression| 7)
              (183 . |coerce|) |FC;returns;E$;42| (|Expression| (|Float|))
              (188 . |coerce|) |FC;returns;E$;43|
              (|Expression| (|Complex| (|Float|))) (193 . |coerce|)
              |FC;returns;E$;44| |FC;block;L$;45| |FC;cond;S2$;46|
              |FC;cond;S3$;47| (198 . |coerce|) |FC;coerce;$Of;48|
              (203 . |coerce|) |FC;assign;SS$;49| (|Matrix| (|MachineInteger|))
              (208 . |coerce|) |FC;assign;SM$;50| (|Matrix| (|MachineFloat|))
              (213 . |coerce|) |FC;assign;SM$;51| (|Matrix| (|MachineComplex|))
              (218 . |coerce|) |FC;assign;SM$;52| (|Vector| (|MachineInteger|))
              (223 . |coerce|) |FC;assign;SV$;53| (|Vector| (|MachineFloat|))
              (228 . |coerce|) |FC;assign;SV$;54| (|Vector| (|MachineComplex|))
              (233 . |coerce|) |FC;assign;SV$;55| (|Matrix| 90)
              (238 . |coerce|) |FC;assign;SM$;56| (|Matrix| 93)
              (243 . |coerce|) |FC;assign;SM$;57| (|Matrix| 96)
              (248 . |coerce|) |FC;assign;SM$;58| (|Vector| 90)
              (253 . |coerce|) |FC;assign;SV$;59| (|Vector| 93)
              (258 . |coerce|) |FC;assign;SV$;60| (|Vector| 96)
              (263 . |coerce|) |FC;assign;SV$;61| |FC;assign;SLE$;62|
              |FC;assign;SLE$;63| |FC;assign;SLE$;64| |FC;assign;SE$;65|
              |FC;assign;SE$;66| |FC;assign;SE$;67| (|Matrix| 99)
              (268 . |coerce|) |FC;assign;SM$;68| (|Matrix| 102)
              (273 . |coerce|) |FC;assign;SM$;69| (|Matrix| 105)
              (278 . |coerce|) |FC;assign;SM$;70| (|Vector| 99)
              (283 . |coerce|) |FC;assign;SV$;71| (|Vector| 102)
              (288 . |coerce|) |FC;assign;SV$;72| (|Vector| 105)
              (293 . |coerce|) |FC;assign;SV$;73| |FC;assign;SLE$;74|
              |FC;assign;SLE$;75| |FC;assign;SLE$;76| |FC;assign;SE$;77|
              |FC;assign;SE$;78| |FC;assign;SE$;79| |FC;call;S$;80|)
           '#(~= 298 |whileLoop| 304 |stop| 310 |setLabelValue| 314 |save| 319
              |returns| 323 |repeatUntilLoop| 357 |printStatement| 363
              |printCode| 368 |operation| 373 |latex| 378 |hash| 383 |goto| 388
              |getCode| 393 |forLoop| 398 |continue| 411 |cond| 416 |common|
              429 |comment| 435 |coerce| 445 |code| 450 |call| 455 |block| 460
              |assign| 465 = 657)
           'NIL
           (CONS (|makeByteWordVec2| 1 '(0 0 0))
                 (CONS '#(|SetCategory&| |BasicType&| NIL)
                       (CONS
                        '#((|SetCategory|) (|BasicType|) (|CoercibleTo| 17))
                        (|makeByteWordVec2| 181
                                            '(1 8 0 7 9 0 12 0 13 2 15 14 0 7
                                              16 1 18 17 0 19 1 20 0 17 21 1 18
                                              14 0 22 1 20 0 7 23 1 37 17 0 38
                                              1 8 17 0 39 0 17 7 40 1 17 7 0 41
                                              1 17 0 7 42 1 37 0 0 43 2 46 45 0
                                              0 47 1 12 0 18 48 1 46 17 0 49 1
                                              20 0 0 50 1 20 0 0 51 1 20 17 0
                                              52 1 20 0 14 53 1 20 0 54 55 1 56
                                              18 0 57 0 58 0 59 2 60 58 18 58
                                              61 1 56 62 0 63 1 62 12 0 64 1 12
                                              17 0 65 1 62 12 0 66 0 12 0 67 1
                                              20 0 68 69 0 70 0 71 1 15 0 14 80
                                              1 62 7 0 82 1 12 0 7 83 1 90 17 0
                                              91 1 93 17 0 94 1 96 17 0 97 1 99
                                              17 0 100 1 102 17 0 103 1 105 17
                                              0 106 1 25 17 0 111 1 14 17 0 113
                                              1 115 17 0 116 1 118 17 0 119 1
                                              121 17 0 122 1 124 17 0 125 1 127
                                              17 0 128 1 130 17 0 131 1 133 17
                                              0 134 1 136 17 0 137 1 139 17 0
                                              140 1 142 17 0 143 1 145 17 0 146
                                              1 148 17 0 149 1 157 17 0 158 1
                                              160 17 0 161 1 163 17 0 164 1 166
                                              17 0 167 1 169 17 0 170 1 172 17
                                              0 173 2 0 45 0 0 1 2 0 0 37 0 87
                                              0 0 0 75 1 0 8 8 11 0 0 0 76 1 0
                                              0 105 107 1 0 0 102 104 1 0 0 99
                                              101 1 0 0 90 92 1 0 0 96 98 0 0 0
                                              89 1 0 0 93 95 2 0 0 37 0 88 1 0
                                              0 77 78 1 0 70 0 72 1 0 25 0 26 1
                                              0 14 0 1 1 0 8 0 1 1 0 0 8 44 1 0
                                              20 0 24 3 0 0 56 12 0 85 2 0 0 56
                                              0 84 1 0 0 8 86 3 0 0 37 0 0 110
                                              2 0 0 37 0 109 2 0 0 18 73 74 1 0
                                              0 15 79 1 0 0 14 81 1 0 17 0 112
                                              1 0 35 0 36 1 0 0 14 181 1 0 0 54
                                              108 3 0 0 18 46 102 176 3 0 0 18
                                              46 105 177 2 0 0 18 172 174 3 0 0
                                              18 46 99 175 2 0 0 18 166 168 2 0
                                              0 18 169 171 2 0 0 18 160 162 2 0
                                              0 18 163 165 2 0 0 18 105 180 2 0
                                              0 18 157 159 2 0 0 18 99 178 2 0
                                              0 18 102 179 3 0 0 18 46 93 152 3
                                              0 0 18 46 96 153 2 0 0 18 148 150
                                              3 0 0 18 46 90 151 2 0 0 18 142
                                              144 2 0 0 18 145 147 2 0 0 18 136
                                              138 2 0 0 18 139 141 2 0 0 18 130
                                              132 2 0 0 18 133 135 2 0 0 18 124
                                              126 2 0 0 18 127 129 2 0 0 18 118
                                              120 2 0 0 18 121 123 2 0 0 18 96
                                              156 2 0 0 18 115 117 2 0 0 18 90
                                              154 2 0 0 18 93 155 2 0 0 18 14
                                              114 2 0 45 0 0 1)))))
           '|lookupComplete|)) 

(MAKEPROP '|FortranCode| 'NILADIC T) 
