
(/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 (|u| #0=#:G1836 #1=#:G1834 #2=#:G1832 #3=#:G1833)
    (RETURN
      (SEQ (CONS (SPADCALL |l| 1 (QREFELT $ 16))
                 (PROGN
                   (LETT #3# NIL . #4=(|FC;commaSep|))
                   (SEQ (LETT |u| NIL . #4#) (LETT #0# (CDR |l|) . #4#)
                        G190
                        (COND
                          ((OR (ATOM #0#)
                               (PROGN (LETT |u| (CAR #0#) . #4#) NIL))
                           (GO G191)))
                        (SEQ (EXIT (PROGN
                                     (LETT #1# (LIST "," |u|) . #4#)
                                     (COND
                                       (#3#
                                        (LETT #2#
                                         (APPEND #2# #1#) . #4#))
                                       ('T
                                        (PROGN
                                          (LETT #2# #1# . #4#)
                                          (LETT #3# 'T . #4#)))))))
                        (LETT #0# (CDR #0#) . #4#) (GO G190) G191
                        (EXIT NIL))
                   (COND (#3# #2#) ('T NIL)))))))) 

(DEFUN |FC;getReturn| (|rec| $)
  (PROG (|returnToken| |rt| |rv|)
    (RETURN
      (SEQ (LETT |returnToken|
                 (SPADCALL
                     (SPADCALL (SPADCALL "RETURN" (QREFELT $ 18))
                         (QREFELT $ 20))
                     (QREFELT $ 22))
                 . #0=(|FC;getReturn|))
           (EXIT (COND
                   ((QCAR |rec|) (|getStatement| |returnToken| NIL))
                   ('T
                    (SEQ (LETT |rt| (QCDR |rec|) . #0#)
                         (LETT |rv| (QCDR |rt|) . #0#)
                         (EXIT (|getStatement|
                                   (|construct| |returnToken|
                                    (SPADCALL |rv| (QREFELT $ 22)))
                                   (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 $ 23))
                    "/ ")
              (|addCommas| (QCDR |u|))))) 

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

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

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

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

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

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

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

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

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

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

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

(DEFUN |FC;getComment| (|rec| $)
  (PROG (#0=#:G1990 |c| #1=#:G1991)
    (RETURN
      (SEQ (SPADCALL
               (PROGN
                 (LETT #0# NIL . #2=(|FC;getComment|))
                 (SEQ (LETT |c| NIL . #2#) (LETT #1# |rec| . #2#) G190
                      (COND
                        ((OR (ATOM #1#)
                             (PROGN (LETT |c| (CAR #1#) . #2#) NIL))
                         (GO G191)))
                      (SEQ (EXIT (LETT #0#
                                       (CONS
                                        (SPADCALL
                                         (STRCONC "C     " |c|)
                                         (QREFELT $ 54))
                                        #0#) . #2#)))
                      (LETT #1# (CDR #1#) . #2#) (GO G190) G191
                      (EXIT (NREVERSE0 #0#))))
               (QREFELT $ 56)))))) 

(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 $ 54)))
                            (QREFELT $ 56)))))))))) 

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

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

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

(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 $ 81))))) 

(DEFUN |FC;forLoop;Sb2$;32| (|r| |body| $)
  (CONS (CONS 7 "for")
        (CONS 8
              (VECTOR |r|
                      (SPADCALL
                          (SPADCALL (SPADCALL |r| (QREFELT $ 64))
                              (QREFELT $ 83))
                          (QREFELT $ 84))
                      |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| $ 68) (QREFELT $ 66)))
                 |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 $ 92))))))) 

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

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

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

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

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

(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 $ 112))) 

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

(DEFUN |FortranCode;| ()
  (PROG (|dv$| $ |pv$|)
    (RETURN
      (PROGN
        (LETT |dv$| '(|FortranCode|) . #0=(|FortranCode|))
        (LETT $ (GETREFV 183) . #0#)
        (QSETREFV $ 0 |dv$|)
        (QSETREFV $ 3 (LETT |pv$| (|buildPredVector| 0 0 NIL) . #0#))
        (|haddProp| |$ConstructorCache| '|FortranCode| NIL (CONS 1 $))
        (|stuffDomainSlots| $)
        (QSETREFV $ 6
            (|Record|
                (|:| |op|
                     (|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")))
                (|:| |data|
                     (|Union| (|:| |nullBranch| "null")
                              (|:| |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|) (|Symbol|)
             (15 . |coerce|) (|OutputForm|) (20 . |coerce|)
             (|SExpression|) (25 . |convert|) (30 . |string|)
             (35 . |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?| 46) (|:| |expr| 19))
             (|Record| (|:| |var| 17) (|:| |arrayIndex| 47)
                 (|:| |rand| 28))
             (|Record| (|:| |var| 17) (|:| |rand| 19)
                 (|:| |ints2Floats?| 46))
             (|Record| (|:| |switch| 38) (|:| |thenClause| $)
                 (|:| |elseClause| $))
             (|Record| (|:| |empty?| 46) (|:| |value| 28))
             (|Record| (|:| |range| 57) (|:| |span| 12) (|:| |body| $))
             (|Record| (|:| |switch| 38) (|:| |body| $))
             (|Record| (|:| |name| 17) (|:| |contents| 74))
             (|Union| (|:| |nullBranch| '"null")
                      (|:| |assignmentBranch| 29)
                      (|:| |arrayAssignmentBranch| 30)
                      (|:| |conditionalBranch| 31)
                      (|:| |returnBranch| 32) (|:| |blockBranch| 55)
                      (|:| |commentBranch| 15) (|:| |callBranch| 14)
                      (|:| |forBranch| 33) (|:| |labelBranch| 8)
                      (|:| |loopBranch| 34) (|:| |commonBranch| 35)
                      (|:| |printBranch| 78))
             |FC;code;$U;24| (|Switch|) (40 . |coerce|) (45 . |coerce|)
             (50 . |width|) (54 . |width|) (59 . |hspace|) (64 . NOT)
             |FC;goto;Si$;34| (|Boolean|) (|List| 12) (69 . =)
             (75 . |coerce|) (80 . |coerce|) (85 . |cdr|) (90 . |car|)
             (95 . |coerce|) (100 . |convert|) (|List| $)
             (105 . |convert|) (|SegmentBinding| 12) (110 . |variable|)
             (|FortranType|) (115 . |fortranInteger|)
             (|TheSymbolTable|) (119 . |declare!|) (|Segment| 12)
             (125 . |segment|) (130 . |lo|) (135 . |coerce|)
             (140 . |hi|) (145 . |Zero|) (|DoubleFloat|)
             (149 . |convert|) (|Void|) (154 . |void|)
             |FC;printCode;$V;23| (|List| 17) |FC;common;SL$;26|
             |FC;stop;$;27| |FC;save;$;28| (|List| 19)
             |FC;printStatement;L$;29| |FC;comment;L$;30|
             (158 . |list|) |FC;comment;S$;31| (163 . |incr|)
             (168 . |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|))
             (173 . |coerce|) |FC;returns;E$;39|
             (|Expression| (|MachineFloat|)) (178 . |coerce|)
             |FC;returns;E$;40| (|Expression| (|MachineComplex|))
             (183 . |coerce|) |FC;returns;E$;41| (|Expression| 7)
             (188 . |coerce|) |FC;returns;E$;42|
             (|Expression| (|Float|)) (193 . |coerce|)
             |FC;returns;E$;43| (|Expression| (|Complex| (|Float|)))
             (198 . |coerce|) |FC;returns;E$;44| |FC;block;L$;45|
             |FC;cond;S2$;46| |FC;cond;S3$;47| (203 . |coerce|)
             |FC;coerce;$Of;48| (208 . |coerce|) |FC;assign;SS$;49|
             (|Matrix| (|MachineInteger|)) (213 . |coerce|)
             |FC;assign;SM$;50| (|Matrix| (|MachineFloat|))
             (218 . |coerce|) |FC;assign;SM$;51|
             (|Matrix| (|MachineComplex|)) (223 . |coerce|)
             |FC;assign;SM$;52| (|Vector| (|MachineInteger|))
             (228 . |coerce|) |FC;assign;SV$;53|
             (|Vector| (|MachineFloat|)) (233 . |coerce|)
             |FC;assign;SV$;54| (|Vector| (|MachineComplex|))
             (238 . |coerce|) |FC;assign;SV$;55| (|Matrix| 91)
             (243 . |coerce|) |FC;assign;SM$;56| (|Matrix| 94)
             (248 . |coerce|) |FC;assign;SM$;57| (|Matrix| 97)
             (253 . |coerce|) |FC;assign;SM$;58| (|Vector| 91)
             (258 . |coerce|) |FC;assign;SV$;59| (|Vector| 94)
             (263 . |coerce|) |FC;assign;SV$;60| (|Vector| 97)
             (268 . |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| 100)
             (273 . |coerce|) |FC;assign;SM$;68| (|Matrix| 103)
             (278 . |coerce|) |FC;assign;SM$;69| (|Matrix| 106)
             (283 . |coerce|) |FC;assign;SM$;70| (|Vector| 100)
             (288 . |coerce|) |FC;assign;SV$;71| (|Vector| 103)
             (293 . |coerce|) |FC;assign;SV$;72| (|Vector| 106)
             (298 . |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|)
          '#(~= 303 |whileLoop| 309 |stop| 315 |setLabelValue| 319
             |save| 324 |returns| 328 |repeatUntilLoop| 362
             |printStatement| 368 |printCode| 373 |operation| 378
             |latex| 383 |hash| 388 |goto| 393 |getCode| 398 |forLoop|
             403 |continue| 416 |cond| 421 |common| 434 |comment| 440
             |coerce| 450 |code| 455 |call| 460 |block| 465 |assign|
             470 = 662)
          'NIL
          (CONS (|makeByteWordVec2| 1 '(0 0 0))
                (CONS '#(|SetCategory&| |BasicType&| NIL)
                      (CONS '#((|SetCategory|) (|BasicType|)
                               (|CoercibleTo| 19))
                            (|makeByteWordVec2| 182
                                '(1 8 0 7 9 0 12 0 13 2 15 14 0 7 16 1
                                  17 0 14 18 1 17 19 0 20 1 21 0 19 22
                                  1 17 14 0 23 1 21 0 7 24 1 38 19 0 39
                                  1 8 19 0 40 0 19 7 41 1 19 7 0 42 1
                                  19 0 7 43 1 38 0 0 44 2 47 46 0 0 48
                                  1 12 0 17 49 1 47 19 0 50 1 21 0 0 51
                                  1 21 0 0 52 1 21 19 0 53 1 21 0 14 54
                                  1 21 0 55 56 1 57 17 0 58 0 59 0 60 2
                                  61 59 17 59 62 1 57 63 0 64 1 63 12 0
                                  65 1 12 19 0 66 1 63 12 0 67 0 12 0
                                  68 1 21 0 69 70 0 71 0 72 1 15 0 14
                                  81 1 63 7 0 83 1 12 0 7 84 1 91 19 0
                                  92 1 94 19 0 95 1 97 19 0 98 1 100 19
                                  0 101 1 103 19 0 104 1 106 19 0 107 1
                                  26 19 0 112 1 14 19 0 114 1 116 19 0
                                  117 1 119 19 0 120 1 122 19 0 123 1
                                  125 19 0 126 1 128 19 0 129 1 131 19
                                  0 132 1 134 19 0 135 1 137 19 0 138 1
                                  140 19 0 141 1 143 19 0 144 1 146 19
                                  0 147 1 149 19 0 150 1 158 19 0 159 1
                                  161 19 0 162 1 164 19 0 165 1 167 19
                                  0 168 1 170 19 0 171 1 173 19 0 174 2
                                  0 46 0 0 1 2 0 0 38 0 88 0 0 0 76 1 0
                                  8 8 11 0 0 0 77 1 0 0 106 108 1 0 0
                                  103 105 1 0 0 100 102 1 0 0 91 93 1 0
                                  0 97 99 0 0 0 90 1 0 0 94 96 2 0 0 38
                                  0 89 1 0 0 78 79 1 0 71 0 73 1 0 26 0
                                  27 1 0 14 0 1 1 0 8 0 1 1 0 0 8 45 1
                                  0 21 0 25 3 0 0 57 12 0 86 2 0 0 57 0
                                  85 1 0 0 8 87 3 0 0 38 0 0 111 2 0 0
                                  38 0 110 2 0 0 17 74 75 1 0 0 15 80 1
                                  0 0 14 82 1 0 19 0 113 1 0 36 0 37 1
                                  0 0 14 182 1 0 0 55 109 3 0 0 17 47
                                  103 177 3 0 0 17 47 106 178 2 0 0 17
                                  173 175 3 0 0 17 47 100 176 2 0 0 17
                                  167 169 2 0 0 17 170 172 2 0 0 17 161
                                  163 2 0 0 17 164 166 2 0 0 17 106 181
                                  2 0 0 17 158 160 2 0 0 17 100 179 2 0
                                  0 17 103 180 3 0 0 17 47 94 153 3 0 0
                                  17 47 97 154 2 0 0 17 149 151 3 0 0
                                  17 47 91 152 2 0 0 17 143 145 2 0 0
                                  17 146 148 2 0 0 17 137 139 2 0 0 17
                                  140 142 2 0 0 17 131 133 2 0 0 17 134
                                  136 2 0 0 17 125 127 2 0 0 17 128 130
                                  2 0 0 17 119 121 2 0 0 17 122 124 2 0
                                  0 17 97 157 2 0 0 17 116 118 2 0 0 17
                                  91 155 2 0 0 17 94 156 2 0 0 17 14
                                  115 2 0 46 0 0 1)))))
          '|lookupComplete|)) 

(MAKEPROP '|FortranCode| 'NILADIC T) 
