
(/VERSIONCHECK 2) 

(DEFUN |SYMTAB;coerce;$Of;1| (|t| $) (SPADCALL |t| (QREFELT $ 8))) 

(PUT '|SYMTAB;coerce;$T;2| '|SPADreplace| '(XLAM (|t|) |t|)) 

(DEFUN |SYMTAB;coerce;$T;2| (|t| $) |t|) 

(DEFUN |SYMTAB;symbolTable;L$;3| (|l| $)
  (SPADCALL |l| (QREFELT $ 14))) 

(DEFUN |SYMTAB;empty;$;4| ($) (SPADCALL (QREFELT $ 16))) 

(DEFUN |SYMTAB;parametersOf;$L;5| (|tab| $)
  (SPADCALL |tab| (QREFELT $ 19))) 

(DEFUN |SYMTAB;declare!;SFt$Ft;6| (|name| |type| |tab| $)
  (SEQ (SPADCALL |tab| |name| |type| (QREFELT $ 23)) (EXIT |type|))) 

(DEFUN |SYMTAB;declare!;LFt$Ft;7| (|names| |type| |tab| $)
  (PROG (|name| #0=#:G1837)
    (RETURN
      (SEQ (SEQ (LETT |name| NIL . #1=(|SYMTAB;declare!;LFt$Ft;7|))
                (LETT #0# |names| . #1#) G190
                (COND
                  ((OR (ATOM #0#)
                       (PROGN (LETT |name| (CAR #0#) . #1#) NIL))
                   (GO G191)))
                (SEQ (EXIT (SPADCALL |tab| |name| |type|
                               (QREFELT $ 23))))
                (LETT #0# (CDR #0#) . #1#) (GO G190) G191 (EXIT NIL))
           (EXIT |type|))))) 

(DEFUN |SYMTAB;fortranTypeOf;S$Ft;8| (|u| |tab| $)
  (SPADCALL |tab| |u| (QREFELT $ 26))) 

(DEFUN |SYMTAB;externalList;$L;9| (|tab| $)
  (PROG (#0=#:G1841 |u| #1=#:G1842)
    (RETURN
      (SEQ (PROGN
             (LETT #0# NIL . #2=(|SYMTAB;externalList;$L;9|))
             (SEQ (LETT |u| NIL . #2#)
                  (LETT #1# (SPADCALL |tab| (QREFELT $ 19)) . #2#) G190
                  (COND
                    ((OR (ATOM #1#)
                         (PROGN (LETT |u| (CAR #1#) . #2#) NIL))
                     (GO G191)))
                  (SEQ (EXIT (COND
                               ((SPADCALL
                                    (SPADCALL |u| |tab| (QREFELT $ 27))
                                    (QREFELT $ 29))
                                (LETT #0# (CONS |u| #0#) . #2#)))))
                  (LETT #1# (CDR #1#) . #2#) (GO G190) G191
                  (EXIT (NREVERSE0 #0#)))))))) 

(DEFUN |SYMTAB;typeList;Fst$L;10| (|type| |tab| $)
  (PROG (|u| #0=#:G1864 |uType| |sType| #1=#:G1865 |v| #2=#:G1866
             |uDim| |scalarList| |arrayList|)
    (RETURN
      (SEQ (LETT |scalarList| NIL . #3=(|SYMTAB;typeList;Fst$L;10|))
           (LETT |arrayList| NIL . #3#)
           (SEQ (LETT |u| NIL . #3#)
                (LETT #0# (SPADCALL |tab| (QREFELT $ 19)) . #3#) G190
                (COND
                  ((OR (ATOM #0#)
                       (PROGN (LETT |u| (CAR #0#) . #3#) NIL))
                   #4=(GO G191)))
                (SEQ (LETT |uType|
                           (SPADCALL |u| |tab| (QREFELT $ 27)) . #3#)
                     (LETT |sType|
                           (SPADCALL |uType| (QREFELT $ 32)) . #3#)
                     (EXIT (COND
                             ((QEQCAR |sType| 0)
                              (COND
                                ((SPADCALL (CDR |sType|) |type|
                                     (QREFELT $ 34))
                                 (SEQ (LETT |uDim|
                                       (PROGN
                                         (LETT #1# NIL . #3#)
                                         (SEQ (LETT |v| NIL . #3#)
                                          (LETT #2#
                                           (SPADCALL |uType|
                                            (QREFELT $ 36)) . #3#)
                                          G190
                                          (COND
                                            ((OR (ATOM #2#)
                                              (PROGN
                                                (LETT |v|
                                                 (CAR #2#) . #3#)
                                                NIL))
                                             #4#))
                                          (SEQ
                                           (EXIT
                                            (LETT #1#
                                             (CONS (CONS 1 |v|) #1#) . #3#)))
                                          (LETT #2# (CDR #2#) . #3#)
                                          #5=(GO G190) G191
                                          (EXIT (NREVERSE0 #1#)))) . #3#)
                                      (EXIT
                                       (COND
                                         ((NULL |uDim|)
                                          (LETT |scalarList|
                                           (CONS (CONS 0 |u|)
                                            |scalarList|) . #3#))
                                         ('T
                                          (LETT |arrayList|
                                           (CONS
                                            (CONS 1
                                             (CONS (CONS 0 |u|) |uDim|))
                                            |arrayList|) . #3#)))))))))))
                (LETT #0# (CDR #0#) . #3#) #5# G191 (EXIT NIL))
           (EXIT (APPEND |scalarList| |arrayList|)))))) 

(DEFUN |SYMTAB;typeList2| (|type| |tab| $)
  (PROG (|symbolType| |u| #0=#:G1881 |uType| |sType| #1=#:G1882 |v|
            #2=#:G1883 |uDim| |tl|)
    (RETURN
      (SEQ (LETT |tl| NIL . #3=(|SYMTAB;typeList2|))
           (LETT |symbolType| (SPADCALL |type| (QREFELT $ 41)) . #3#)
           (SEQ (LETT |u| NIL . #3#)
                (LETT #0# (SPADCALL |tab| (QREFELT $ 19)) . #3#) G190
                (COND
                  ((OR (ATOM #0#)
                       (PROGN (LETT |u| (CAR #0#) . #3#) NIL))
                   #4=(GO G191)))
                (SEQ (LETT |uType|
                           (SPADCALL |u| |tab| (QREFELT $ 27)) . #3#)
                     (LETT |sType|
                           (SPADCALL |uType| (QREFELT $ 32)) . #3#)
                     (EXIT (COND
                             ((QEQCAR |sType| 0)
                              (COND
                                ((SPADCALL (CDR |sType|) |type|
                                     (QREFELT $ 34))
                                 (SEQ (LETT |uDim|
                                       (PROGN
                                         (LETT #1# NIL . #3#)
                                         (SEQ (LETT |v| NIL . #3#)
                                          (LETT #2#
                                           (SPADCALL |uType|
                                            (QREFELT $ 36)) . #3#)
                                          G190
                                          (COND
                                            ((OR (ATOM #2#)
                                              (PROGN
                                                (LETT |v|
                                                 (CAR #2#) . #3#)
                                                NIL))
                                             #4#))
                                          (SEQ
                                           (EXIT
                                            (LETT #1#
                                             (CONS (CONS 1 |v|) #1#) . #3#)))
                                          (LETT #2# (CDR #2#) . #3#)
                                          #5=(GO G190) G191
                                          (EXIT (NREVERSE0 #1#)))) . #3#)
                                      (EXIT
                                       (LETT |tl|
                                        (COND
                                          ((NULL |uDim|)
                                           (CONS (CONS 0 |u|) |tl|))
                                          ('T
                                           (CONS
                                            (CONS 1
                                             (CONS (CONS 0 |u|) |uDim|))
                                            |tl|))) . #3#)))))))))
                (LETT #0# (CDR #0#) . #3#) #5# G191 (EXIT NIL))
           (EXIT (COND
                   ((NULL |tl|) |tl|)
                   ('T (CONS (CONS 0 |symbolType|) |tl|)))))))) 

(DEFUN |SYMTAB;updateList| (|sType| |name| |lDims| |tl| $)
  (PROG (|l| |entry|)
    (RETURN
      (SEQ (LETT |l| (ASSOC |sType| |tl|) . #0=(|SYMTAB;updateList|))
           (LETT |entry|
                 (COND
                   ((SPADCALL |lDims| (QREFELT $ 43)) |name|)
                   ('T (CONS |name| |lDims|))) . #0#)
           (EXIT (COND
                   ((SPADCALL |l| (QREFELT $ 43))
                    (CONS (|construct| |sType| |entry|) |tl|))
                   ('T
                    (SEQ (RPLACD |l|
                                 (CONS |entry|
                                       (SPADCALL |l| (QREFELT $ 44))))
                         (EXIT |tl|))))))))) 

(DEFUN |SYMTAB;newTypeLists;$Se;13| (|tab| $)
  (PROG (|u| #0=#:G1895 |uType| |sType| |dims| #1=#:G1896 |v|
             #2=#:G1897 |lDims| |lType| |tl|)
    (RETURN
      (SEQ (LETT |tl| (|construct|)
                 . #3=(|SYMTAB;newTypeLists;$Se;13|))
           (SEQ (LETT |u| NIL . #3#)
                (LETT #0# (SPADCALL |tab| (QREFELT $ 19)) . #3#) G190
                (COND
                  ((OR (ATOM #0#)
                       (PROGN (LETT |u| (CAR #0#) . #3#) NIL))
                   #4=(GO G191)))
                (SEQ (LETT |uType|
                           (SPADCALL |u| |tab| (QREFELT $ 27)) . #3#)
                     (LETT |sType|
                           (SPADCALL |uType| (QREFELT $ 32)) . #3#)
                     (LETT |dims|
                           (SPADCALL |uType| (QREFELT $ 36)) . #3#)
                     (LETT |lDims|
                           (PROGN
                             (LETT #1# NIL . #3#)
                             (SEQ (LETT |v| NIL . #3#)
                                  (LETT #2# |dims| . #3#) G190
                                  (COND
                                    ((OR (ATOM #2#)
                                      (PROGN
                                        (LETT |v| (CAR #2#) . #3#)
                                        NIL))
                                     #4#))
                                  (SEQ (EXIT
                                        (LETT #1#
                                         (CONS
                                          (SPADCALL
                                           (SPADCALL |v|
                                            (QREFELT $ 47))
                                           (QREFELT $ 48))
                                          #1#) . #3#)))
                                  (LETT #2# (CDR #2#) . #3#)
                                  #5=(GO G190) G191
                                  (EXIT (NREVERSE0 #1#)))) . #3#)
                     (LETT |lType|
                           (COND
                             ((QEQCAR |sType| 1)
                              (SPADCALL '|void| (QREFELT $ 49)))
                             ('T
                              (SPADCALL (CDR |sType|) (QREFELT $ 50)))) . #3#)
                     (EXIT (LETT |tl|
                                 (|SYMTAB;updateList| |lType|
                                     (SPADCALL |u| (QREFELT $ 49))
                                     (SPADCALL |lDims| (QREFELT $ 52))
                                     |tl| $) . #3#)))
                (LETT #0# (CDR #0#) . #3#) #5# G191 (EXIT NIL))
           (EXIT |tl|))))) 

(DEFUN |SYMTAB;typeLists;$L;14| (|tab| $)
  (PROG (|fortranTypes| |u| #0=#:G1904 |types| |tl|)
    (RETURN
      (SEQ (LETT |fortranTypes|
                 (LIST (SPADCALL "real" (QREFELT $ 55))
                       (SPADCALL "double precision" (QREFELT $ 55))
                       (SPADCALL "integer" (QREFELT $ 55))
                       (SPADCALL "complex" (QREFELT $ 55))
                       (SPADCALL "logical" (QREFELT $ 55))
                       (SPADCALL "character" (QREFELT $ 55)))
                 . #1=(|SYMTAB;typeLists;$L;14|))
           (LETT |tl| NIL . #1#)
           (SEQ (LETT |u| NIL . #1#) (LETT #0# |fortranTypes| . #1#)
                G190
                (COND
                  ((OR (ATOM #0#)
                       (PROGN (LETT |u| (CAR #0#) . #1#) NIL))
                   (GO G191)))
                (SEQ (LETT |types|
                           (|SYMTAB;typeList2| |u| |tab| $) . #1#)
                     (EXIT (COND
                             ((NULL (NULL |types|))
                              (LETT |tl| (CONS |types| |tl|) . #1#)))))
                (LETT #0# (CDR #0#) . #1#) (GO G190) G191 (EXIT NIL))
           (EXIT |tl|))))) 

(DEFUN |SYMTAB;oForm2| (|w| $)
  (PROG (#0=#:G1868)
    (RETURN
      (COND
        ((QEQCAR |w| 0) (SPADCALL (CDR |w|) (QREFELT $ 58)))
        ((QEQCAR |w| 1)
         (SPADCALL
             (PROG2 (LETT #0# |w| |SYMTAB;oForm2|) (QCDR #0#)
               (|check-union| (QEQCAR #0# 1) (|Polynomial| (|Integer|))
                   #0#))
             (QREFELT $ 59))))))) 

(DEFUN |SYMTAB;oForm| (|v| $)
  (PROG (#0=#:G1909 |uu| #1=#:G1870 #2=#:G1910 |ll|)
    (RETURN
      (SEQ (COND
             ((QEQCAR |v| 0) (SPADCALL (CDR |v|) (QREFELT $ 58)))
             ((QEQCAR |v| 1)
              (SEQ (LETT |ll|
                         (PROGN
                           (LETT #0# NIL . #3=(|SYMTAB;oForm|))
                           (SEQ (LETT |uu| NIL . #3#)
                                (LETT #2#
                                      (PROG2 (LETT #1# |v| . #3#)
                                       (QCDR #1#)
                                        (|check-union| (QEQCAR #1# 1)
                                         (|List|
                                          (|Union| (|:| S (|Symbol|))
                                           (|:| P
                                            (|Polynomial| (|Integer|)))))
                                         #1#)) . #3#)
                                G190
                                (COND
                                  ((OR (ATOM #2#)
                                    (PROGN
                                      (LETT |uu| (CAR #2#) . #3#)
                                      NIL))
                                   (GO G191)))
                                (SEQ (EXIT
                                      (LETT #0#
                                       (CONS (|SYMTAB;oForm2| |uu| $)
                                        #0#) . #3#)))
                                (LETT #2# (CDR #2#) . #3#) (GO G190)
                                G191 (EXIT (NREVERSE0 #0#)))) . #3#)
                   (EXIT (SPADCALL |ll| (QREFELT $ 61)))))))))) 

(DEFUN |SYMTAB;outForm| (|t| $)
  (PROG (#0=#:G1913 |u| #1=#:G1914)
    (RETURN
      (SEQ (PROGN
             (LETT #0# NIL . #2=(|SYMTAB;outForm|))
             (SEQ (LETT |u| NIL . #2#) (LETT #1# |t| . #2#) G190
                  (COND
                    ((OR (ATOM #1#)
                         (PROGN (LETT |u| (CAR #1#) . #2#) NIL))
                     (GO G191)))
                  (SEQ (EXIT (LETT #0#
                                   (CONS (|SYMTAB;oForm| |u| $) #0#) . #2#)))
                  (LETT #1# (CDR #1#) . #2#) (GO G190) G191
                  (EXIT (NREVERSE0 #0#)))))))) 

(DEFUN |SYMTAB;printTypes;$V;18| (|tab| $)
  (PROG (|ft| |ty| #0=#:G1920 |tl| |otl| #1=#:G1921 |u| #2=#:G1922
              |el|)
    (RETURN
      (SEQ (LETT |ft|
                 (LIST (SPADCALL "integer" (QREFELT $ 55))
                       (SPADCALL "real" (QREFELT $ 55))
                       (SPADCALL "double precision" (QREFELT $ 55))
                       (SPADCALL "complex" (QREFELT $ 55))
                       (SPADCALL "logical" (QREFELT $ 55))
                       (SPADCALL "character" (QREFELT $ 55)))
                 . #3=(|SYMTAB;printTypes;$V;18|))
           (SEQ (LETT |ty| NIL . #3#) (LETT #0# |ft| . #3#) G190
                (COND
                  ((OR (ATOM #0#)
                       (PROGN (LETT |ty| (CAR #0#) . #3#) NIL))
                   #4=(GO G191)))
                (SEQ (LETT |tl|
                           (SPADCALL |ty| |tab| (QREFELT $ 40)) . #3#)
                     (LETT |otl| (|SYMTAB;outForm| |tl| $) . #3#)
                     (EXIT (|fortFormatTypes|
                               (SPADCALL |ty| (QREFELT $ 62)) |otl|)))
                (LETT #0# (CDR #0#) . #3#) #5=(GO G190) G191
                (EXIT NIL))
           (LETT |el|
                 (PROGN
                   (LETT #1# NIL . #3#)
                   (SEQ (LETT |u| NIL . #3#)
                        (LETT #2#
                              (SPADCALL |tab| (QREFELT $ 30)) . #3#)
                        G190
                        (COND
                          ((OR (ATOM #2#)
                               (PROGN (LETT |u| (CAR #2#) . #3#) NIL))
                           #4#))
                        (SEQ (EXIT (LETT #1#
                                    (CONS (SPADCALL |u| (QREFELT $ 58))
                                     #1#) . #3#)))
                        (LETT #2# (CDR #2#) . #3#) #5# G191
                        (EXIT (NREVERSE0 #1#)))) . #3#)
           (|fortFormatTypes| "EXTERNAL" |el|)
           (EXIT (SPADCALL (QREFELT $ 64))))))) 

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

(DEFUN |SymbolTable;| ()
  (PROG (|dv$| $ |pv$|)
    (RETURN
      (PROGN
        (LETT |dv$| '(|SymbolTable|) . #0=(|SymbolTable|))
        (LETT $ (GETREFV 66) . #0#)
        (QSETREFV $ 0 |dv$|)
        (QSETREFV $ 3 (LETT |pv$| (|buildPredVector| 0 0 NIL) . #0#))
        (|haddProp| |$ConstructorCache| '|SymbolTable| NIL (CONS 1 $))
        (|stuffDomainSlots| $)
        (QSETREFV $ 6 (|Table| (|Symbol|) (|FortranType|)))
        $)))) 

(MAKEPROP '|SymbolTable| '|infovec|
    (LIST '#(NIL NIL NIL NIL NIL NIL '|Rep| (|OutputForm|)
             (0 . |coerce|) |SYMTAB;coerce;$Of;1| (|Table| 22 21)
             |SYMTAB;coerce;$T;2|
             (|Record| (|:| |key| 22) (|:| |entry| 21)) (|List| 12)
             (5 . |table|) |SYMTAB;symbolTable;L$;3| (10 . |empty|)
             |SYMTAB;empty;$;4| (|List| 22) (14 . |keys|)
             |SYMTAB;parametersOf;$L;5| (|FortranType|) (|Symbol|)
             (19 . |setelt|) |SYMTAB;declare!;SFt$Ft;6|
             |SYMTAB;declare!;LFt$Ft;7| (26 . |elt|)
             |SYMTAB;fortranTypeOf;S$Ft;8| (|Boolean|)
             (32 . |external?|) |SYMTAB;externalList;$L;9|
             (|Union| (|:| |fst| 33) (|:| |void| '"void"))
             (37 . |scalarTypeOf|) (|FortranScalarType|) (42 . =)
             (|List| 46) (48 . |dimensionsOf|)
             (|Union| (|:| S 22) (|:| P 46))
             (|Union| (|:| |name| 22) (|:| |bounds| (|List| 37)))
             (|List| 38) |SYMTAB;typeList;Fst$L;10| (53 . |coerce|)
             (|SExpression|) (58 . |null?|) (63 . |cdr|) (|InputForm|)
             (|Polynomial| (|Integer|)) (68 . |convert|)
             (73 . |convert|) (78 . |convert|) (83 . |coerce|)
             (|List| $) (88 . |convert|) |SYMTAB;newTypeLists;$Se;13|
             (|String|) (93 . |coerce|) (|List| 39)
             |SYMTAB;typeLists;$L;14| (98 . |coerce|) (103 . |coerce|)
             (|List| 7) (108 . |coerce|) (113 . |coerce|) (|Void|)
             (118 . |void|) |SYMTAB;printTypes;$V;18|)
          '#(|typeLists| 122 |typeList| 127 |symbolTable| 133
             |printTypes| 138 |parametersOf| 143 |newTypeLists| 148
             |fortranTypeOf| 153 |externalList| 159 |empty| 164
             |declare!| 168 |coerce| 182)
          'NIL
          (CONS (|makeByteWordVec2| 1 '(0))
                (CONS '#(NIL)
                      (CONS '#((|CoercibleTo| 7))
                            (|makeByteWordVec2| 65
                                '(1 6 7 0 8 1 6 0 13 14 0 6 0 16 1 6 18
                                  0 19 3 6 21 0 22 21 23 2 6 21 0 22 26
                                  1 21 28 0 29 1 21 31 0 32 2 33 28 0 0
                                  34 1 21 35 0 36 1 33 22 0 41 1 42 28
                                  0 43 1 42 0 0 44 1 46 45 0 47 1 45 42
                                  0 48 1 42 0 22 49 1 33 42 0 50 1 42 0
                                  51 52 1 33 0 54 55 1 22 7 0 58 1 46 7
                                  0 59 1 60 7 0 61 1 33 7 0 62 0 63 0
                                  64 1 0 56 0 57 2 0 39 33 0 40 1 0 0
                                  13 15 1 0 63 0 65 1 0 18 0 20 1 0 42
                                  0 53 2 0 21 22 0 27 1 0 18 0 30 0 0 0
                                  17 3 0 21 22 21 0 24 3 0 21 18 21 0
                                  25 1 0 7 0 9 1 0 10 0 11)))))
          '|lookupComplete|)) 

(MAKEPROP '|SymbolTable| 'NILADIC T) 
