
(/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=#:G679 #2=#:G678 #3=#:G680 #4=#:G682 |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 (SPADCALL "RETURN" (QREFELT $ 18)) (QREFELT $ 20))
             (QREFELT $ 22))
            . #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 $ 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 (|ll| #1=#:G694 |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=#:G698 |u|)
    (RETURN
     (SEQ (|indentFortLevel| (SPADCALL 1 (QREFELT $ 24)))
          (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 $ 25)))
                       . #2#)))
               (LETT #1# (CDR #1#) . #2#) (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 (|expr| |elseBranch| #1=#:G764 |rec|)
    (RETURN
     (SEQ (LETT |rec| (SPADCALL |f| (QREFELT $ 37)) . #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 $ 39)))
                . #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 $ 27)) 0))
            (EXIT
             (COND
              ((QEQCAR (SPADCALL |elseBranch| (QREFELT $ 27)) 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 $ 40)) . #1=(|FC;getContinue|))
      (COND ((< 6 (SPADCALL |lab| (QREFELT $ 42))) (|error| "Label too big")))
      (LETT |cnt| "CONTINUE" . #1#)
      (LETT |sp|
            (SPADCALL (- |$fortIndent| (SPADCALL |lab| (QREFELT $ 42)))
                      (QREFELT $ 43))
            . #1#)
      (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 (|bod| |lab| |sw|)
    (RETURN
     (SEQ
      (LETT |sw| (SPADCALL (QCAR |repRec|) (QREFELT $ 44))
            . #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 $ 39)) |lab|))))))) 

(DEFUN |FC;getWhile| (|whileRec| $)
  (PROG (|bod| |lab2| |lab1| |sw|)
    (RETURN
     (SEQ
      (LETT |sw| (SPADCALL (QCAR |whileRec|) (QREFELT $ 44))
            . #1=(|FC;getWhile|))
      (LETT |lab1| (|FC;newLabel| $) . #1#)
      (LETT |lab2| (|FC;newLabel| $) . #1#)
      (LETT |bod| (QCDR |whileRec|) . #1#)
      (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 (|lhs| |indices|)
    (RETURN
     (SEQ (LETT |indices| (QVELT |rec| 1) . #1=(|FC;getAssign|))
          (COND
           ((SPADCALL |indices| NIL (QREFELT $ 48))
            (LETT |lhs| (SPADCALL (QVELT |rec| 0) (QREFELT $ 20)) . #1#))
           (#2='T
            (SEQ
             (LETT |lhs|
                   (SPADCALL
                    (CONS (SPADCALL (QVELT |rec| 0) (QREFELT $ 49)) |indices|)
                    (QREFELT $ 50))
                   . #1#)
             (EXIT
              (LETT |lhs|
                    (SPADCALL
                     (SPADCALL
                      (SPADCALL
                       (SPADCALL (SPADCALL |lhs| (QREFELT $ 22))
                                 (QREFELT $ 51))
                       (QREFELT $ 52))
                      (QREFELT $ 51))
                     (QREFELT $ 53))
                    . #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 $ 39)))
                    (|FC;getBody| (QVELT |rec| 1) $))
            . #1=(|FC;getCond|))
      (LETT |elseBranch| (QVELT |rec| 2) . #1#)
      (COND
       ((NULL (QEQCAR (SPADCALL |elseBranch| (QREFELT $ 27)) 0))
        (COND
         ((QEQCAR (SPADCALL |elseBranch| (QREFELT $ 27)) 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=#:G837 |c| #2=#:G836)
    (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 $ 54))
                           #2#)
                     . #3#)))
             (LETT #1# (CDR #1#) . #3#) (GO G190) G191 (EXIT (NREVERSE0 #2#))))
       (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 (|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 $ 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|)
                . #1#)
          (EXIT
           (APPEND |expr| (|FC;getBody| (QVELT |rec| 2) $)
                   (|FC;getContinue| |lab| $))))))) 

(DEFUN |FC;getCode;$Se;22| (|f| $)
  (PROG (#1=#:G875 #2=#:G876 #3=#:G874 #4=#:G873 #5=#:G872 #6=#:G871 #7=#:G870
         #8=#:G869 #9=#:G868 #10=#:G867 #11=#:G866 #12=#:G865 |rec| |opp|)
    (RETURN
     (SEQ
      (LETT |opp| (SPADCALL |f| (QREFELT $ 27)) . #13=(|FC;getCode;$Se;22|))
      (LETT |rec| (SPADCALL |f| (QREFELT $ 37)) . #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 $ 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| #1=()
  (PROG #1#
    (RETURN
     (PROG (#2=#:G2851)
       (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 183) . #1#)
      (QSETREFV $ 0 |dv$|)
      (QSETREFV $ 3 (LETT |pv$| (|buildPredVector| 0 0 NIL) . #1#))
      (|haddProp| |$ConstructorCache| '|FortranCode| NIL (CONS 1 $))
      (|stuffDomainSlots| $)
      (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|)
              (|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) 
