
(/VERSIONCHECK 2) 

(DEFUN |FS-;ground?;SB;1| (|x| $) (QEQCAR (SPADCALL |x| (QREFELT $ 18)) 0)) 

(DEFUN |FS-;ground;SR;2| (|x| $) (SPADCALL |x| (QREFELT $ 21))) 

(DEFUN |FS-;coerce;SS;3| (|x| $)
  (SPADCALL (SPADCALL |x| (QREFELT $ 24)) (QREFELT $ 26))) 

(DEFUN |FS-;retract;SS;4| (|x| $)
  (PROG (#1=#:G1857)
    (RETURN
     (PROG2
         (LETT #1# (SPADCALL (SPADCALL |x| (QREFELT $ 28)) (QREFELT $ 30))
               |FS-;retract;SS;4|)
         (QCDR #1#)
       (|check-union| (QEQCAR #1# 0) (|Symbol|) #1#))))) 

(DEFUN |FS-;applyQuote;S2S;5| (|s| |x| $)
  (SPADCALL |s| (LIST |x|) (QREFELT $ 33))) 

(DEFUN |FS-;applyQuote;S3S;6| (|s| |x| |y| $)
  (SPADCALL |s| (LIST |x| |y|) (QREFELT $ 33))) 

(DEFUN |FS-;applyQuote;S4S;7| (|s| |x| |y| |z| $)
  (SPADCALL |s| (LIST |x| |y| |z|) (QREFELT $ 33))) 

(DEFUN |FS-;applyQuote;S5S;8| (|s| |x| |y| |z| |t| $)
  (SPADCALL |s| (LIST |x| |y| |z| |t|) (QREFELT $ 33))) 

(DEFUN |FS-;applyQuote;SLS;9| (|s| |l| $)
  (SPADCALL (QREFELT $ 16) (CONS (SPADCALL |s| (QREFELT $ 38)) |l|)
            (QREFELT $ 39))) 

(DEFUN |FS-;belong?;BoB;10| (|op| $)
  (COND ((SPADCALL |op| (QREFELT $ 15) (QREFELT $ 41)) 'T)
        ('T (SPADCALL |op| (QREFELT $ 16) (QREFELT $ 41))))) 

(DEFUN |FS-;subs| (|fn| |k| $)
  (PROG (#1=#:G1878 |x| #2=#:G1877)
    (RETURN
     (SEQ
      (SPADCALL (SPADCALL |k| (QREFELT $ 43))
                (PROGN
                 (LETT #2# NIL . #3=(|FS-;subs|))
                 (SEQ (LETT |x| NIL . #3#)
                      (LETT #1# (SPADCALL |k| (QREFELT $ 45)) . #3#) G190
                      (COND
                       ((OR (ATOM #1#) (PROGN (LETT |x| (CAR #1#) . #3#) NIL))
                        (GO G191)))
                      (SEQ
                       (EXIT (LETT #2# (CONS (SPADCALL |x| |fn|) #2#) . #3#)))
                      (LETT #1# (CDR #1#) . #3#) (GO G190) G191
                      (EXIT (NREVERSE0 #2#))))
                (QREFELT $ 46)))))) 

(DEFUN |FS-;operator;2Bo;12| (|op| $)
  (COND ((SPADCALL |op| '|%diff| (QREFELT $ 47)) (QREFELT $ 15))
        ((SPADCALL |op| '|%quote| (QREFELT $ 47)) (QREFELT $ 16))
        ('T
         (|error|
          (SPADCALL
           (STRCONC "Unknown operator 4: "
                    (SPADCALL (SPADCALL |op| (QREFELT $ 48)) (QREFELT $ 50)))
           (QREFELT $ 52)))))) 

(DEFUN |FS-;differentiand| (|l| $)
  (SPADCALL (|SPADfirst| |l|)
            (SPADCALL (SPADCALL |l| (QREFELT $ 54)) (QREFELT $ 28))
            (SPADCALL |l| (QREFELT $ 55)) (QREFELT $ 56))) 

(DEFUN |FS-;pint| (|l| $)
  (SPADCALL (CONS (SPADCALL 'D (QREFELT $ 58)) |l|) (QREFELT $ 59))) 

(DEFUN |FS-;indiff| (|l| $)
  (PROG (|r2|)
    (RETURN
     (SEQ
      (LETT |r2|
            (SPADCALL
             (LIST (SPADCALL (SPADCALL "::" (QREFELT $ 60)) (QREFELT $ 58))
                   (SPADCALL (SPADCALL |l| (QREFELT $ 55)) (QREFELT $ 61))
                   (SPADCALL '|Symbol| (QREFELT $ 58)))
             (QREFELT $ 59))
            |FS-;indiff|)
      (EXIT
       (|FS-;pint|
        (LIST (SPADCALL (|FS-;differentiand| |l| $) (QREFELT $ 61)) |r2|)
        $)))))) 

(DEFUN |FS-;eval;SSS;16| (|f| |s| $) (SPADCALL |f| (LIST |s|) (QREFELT $ 63))) 

(DEFUN |FS-;eval;SBoSSS;17| (|f| |s| |g| |x| $)
  (SPADCALL |f| (LIST |s|) (LIST |g|) |x| (QREFELT $ 66))) 

(DEFUN |FS-;eval;SLLSS;18| (|f| |ls| |lg| |x| $)
  (PROG (#1=#:G1906 |g| #2=#:G1905)
    (RETURN
     (SEQ
      (SPADCALL |f| |ls|
                (PROGN
                 (LETT #2# NIL . #3=(|FS-;eval;SLLSS;18|))
                 (SEQ (LETT |g| NIL . #3#) (LETT #1# |lg| . #3#) G190
                      (COND
                       ((OR (ATOM #1#) (PROGN (LETT |g| (CAR #1#) . #3#) NIL))
                        (GO G191)))
                      (SEQ
                       (EXIT
                        (LETT #2# (CONS (SPADCALL |g| |x| (QREFELT $ 70)) #2#)
                              . #3#)))
                      (LETT #1# (CDR #1#) . #3#) (GO G190) G191
                      (EXIT (NREVERSE0 #2#))))
                (QREFELT $ 73)))))) 

(DEFUN |FS-;variables;SL;19| (|x| $)
  (PROG (|l| |s| #1=#:G1916 |k|)
    (RETURN
     (SEQ (LETT |l| NIL . #2=(|FS-;variables;SL;19|))
          (SEQ (LETT |k| NIL . #2#)
               (LETT #1# (SPADCALL |x| (QREFELT $ 78)) . #2#) G190
               (COND
                ((OR (ATOM #1#) (PROGN (LETT |k| (CAR #1#) . #2#) NIL))
                 (GO G191)))
               (SEQ (LETT |s| (SPADCALL |k| (QREFELT $ 30)) . #2#)
                    (EXIT
                     (COND
                      ((QEQCAR |s| 0)
                       (LETT |l| (CONS (QCDR |s|) |l|) . #2#)))))
               (LETT #1# (CDR #1#) . #2#) (GO G190) G191 (EXIT NIL))
          (EXIT (NREVERSE |l|)))))) 

(DEFUN |FS-;retractIfCan;SU;20| (|x| $)
  (PROG (|k|)
    (RETURN
     (SEQ (LETT |k| (SPADCALL |x| (QREFELT $ 81)) |FS-;retractIfCan;SU;20|)
          (EXIT
           (COND ((QEQCAR |k| 1) (CONS 1 "failed"))
                 ('T (SPADCALL (QCDR |k|) (QREFELT $ 30))))))))) 

(DEFUN |FS-;characteristic;Nni;21| ($) (SPADCALL (QREFELT $ 85))) 

(DEFUN |FS-;coerce;KS;22| (|k| $)
  (SPADCALL (SPADCALL |k| (QREFELT $ 88)) (QREFELT $ 90))) 

(DEFUN |FS-;symsub| (|sy| |i| $)
  (SPADCALL (STRCONC (SPADCALL |sy| (QREFELT $ 50)) (STRINGIMAGE |i|))
            (QREFELT $ 60))) 

(DEFUN |FS-;numerator;2S;24| (|x| $)
  (SPADCALL (SPADCALL |x| (QREFELT $ 92)) (QREFELT $ 90))) 

(DEFUN |FS-;eval;SSNniMS;25| (|x| |s| |n| |f| $)
  (PROG ()
    (RETURN
     (SPADCALL |x| (LIST |s|) (LIST |n|)
               (LIST (CONS #'|FS-;eval;SSNniMS;25!0| (VECTOR |f| $)))
               (QREFELT $ 98))))) 

(DEFUN |FS-;eval;SSNniMS;25!0| (|y| $$)
  (PROG ($ |f|)
    (LETT $ (QREFELT $$ 1) . #1=(|FS-;eval;SSNniMS;25|))
    (LETT |f| (QREFELT $$ 0) . #1#)
    (RETURN (PROGN (SPADCALL (SPADCALL |y| (QREFELT $ 94)) |f|))))) 

(DEFUN |FS-;eval;SSNniMS;26| (|x| |s| |n| |f| $)
  (SPADCALL |x| (LIST |s|) (LIST |n|) (LIST |f|) (QREFELT $ 98))) 

(DEFUN |FS-;eval;SLLS;27| (|x| |l| |f| $)
  (SPADCALL |x| |l| (SPADCALL (LENGTH |l|) 1 (QREFELT $ 101)) |f|
            (QREFELT $ 98))) 

(DEFUN |FS-;elt;BoLS;28| (|op| |args| $)
  (PROG (#1=#:G1956 |x| |od?|)
    (RETURN
     (SEQ
      (EXIT
       (SEQ
        (COND
         ((SPADCALL |op| (QREFELT $ 103))
          (SEQ
           (LETT |od?| (SPADCALL |op| (QREFELT $ 8) (QREFELT $ 104))
                 . #2=(|FS-;elt;BoLS;28|))
           (EXIT
            (COND
             ((OR |od?| (SPADCALL |op| (QREFELT $ 9) (QREFELT $ 104)))
              (COND
               ((SPADCALL
                 (SPADCALL (SPADCALL (|SPADfirst| |args|) (QREFELT $ 92))
                           (QREFELT $ 105))
                 (|spadConstant| $ 106) (QREFELT $ 107))
                (PROGN
                 (LETT #1#
                       (SEQ
                        (LETT |x|
                              (SPADCALL |op|
                                        (SPADCALL (|SPADfirst| |args|)
                                                  (QREFELT $ 108))
                                        (QREFELT $ 109))
                              . #2#)
                        (EXIT
                         (COND (|od?| (SPADCALL |x| (QREFELT $ 108)))
                               ('T |x|))))
                       . #2#)
                 (GO #1#))))))))))
        (EXIT (SPADCALL |op| |args| (QREFELT $ 111)))))
      #1# (EXIT #1#))))) 

(DEFUN |FS-;eval;SLLLS;29| (|x| |s| |n| |l| $)
  (PROG (#1=#:G1962 |f| #2=#:G1961)
    (RETURN
     (SEQ
      (SPADCALL |x| |s| |n|
                (PROGN
                 (LETT #2# NIL . #3=(|FS-;eval;SLLLS;29|))
                 (SEQ (LETT |f| NIL . #3#) (LETT #1# |l| . #3#) G190
                      (COND
                       ((OR (ATOM #1#) (PROGN (LETT |f| (CAR #1#) . #3#) NIL))
                        (GO G191)))
                      (SEQ
                       (EXIT
                        (LETT #2#
                              (CONS
                               (CONS #'|FS-;eval;SLLLS;29!0| (VECTOR |f| $))
                               #2#)
                              . #3#)))
                      (LETT #1# (CDR #1#) . #3#) (GO G190) G191
                      (EXIT (NREVERSE0 #2#))))
                (QREFELT $ 98)))))) 

(DEFUN |FS-;eval;SLLLS;29!0| (|y| $$)
  (PROG ($ |f|)
    (LETT $ (QREFELT $$ 1) . #1=(|FS-;eval;SLLLS;29|))
    (LETT |f| (QREFELT $$ 0) . #1#)
    (RETURN (PROGN (SPADCALL (SPADCALL |y| (QREFELT $ 94)) |f|))))) 

(DEFUN |FS-;smprep| (|lop| |lexp| |lfunc| |p| $)
  (PROG (|q| |a| |t2| |t1| |qr| |m| |e| |f| |n| |g| |arg| #1=#:G2006 #2=#:G2005
         |op| |k| |v|)
    (RETURN
     (SEQ (LETT |v| (SPADCALL |p| (QREFELT $ 115)) . #3=(|FS-;smprep|))
          (EXIT
           (COND ((QEQCAR |v| 1) (SPADCALL |p| (QREFELT $ 90)))
                 (#4='T
                  (SEQ (LETT |k| (QCDR |v|) . #3#)
                       (LETT |g|
                             (SPADCALL
                              (LETT |op| (SPADCALL |k| (QREFELT $ 43)) . #3#)
                              (LETT |arg|
                                    (PROGN
                                     (LETT #2# NIL . #3#)
                                     (SEQ (LETT |a| NIL . #3#)
                                          (LETT #1#
                                                (SPADCALL |k| (QREFELT $ 45))
                                                . #3#)
                                          G190
                                          (COND
                                           ((OR (ATOM #1#)
                                                (PROGN
                                                 (LETT |a| (CAR #1#) . #3#)
                                                 NIL))
                                            #5=(GO G191)))
                                          (SEQ
                                           (EXIT
                                            (LETT #2#
                                                  (CONS
                                                   (SPADCALL |a| |lop| |lexp|
                                                             |lfunc|
                                                             (QREFELT $ 98))
                                                   #2#)
                                                  . #3#)))
                                          (LETT #1# (CDR #1#) . #3#)
                                          #6=(GO G190) G191
                                          (EXIT (NREVERSE0 #2#))))
                                    . #3#)
                              (QREFELT $ 39))
                             . #3#)
                       (LETT |q|
                             (SPADCALL
                              (CONS #'|FS-;smprep!0|
                                    (VECTOR |lfunc| |lexp| |lop| $))
                              (SPADCALL |p| |k| (QREFELT $ 117))
                              (QREFELT $ 122))
                             . #3#)
                       (EXIT
                        (COND
                         ((<
                           (LETT |n|
                                 (SPADCALL (SPADCALL |op| (QREFELT $ 48)) |lop|
                                           (QREFELT $ 124))
                                 . #3#)
                           (SPADCALL |lop| (QREFELT $ 125)))
                          (SPADCALL |q| |g| (QREFELT $ 126)))
                         (#4#
                          (SEQ (LETT |a| (|spadConstant| $ 127) . #3#)
                               (LETT |f|
                                     (SPADCALL
                                      (SPADCALL |arg|
                                                (SPADCALL |lfunc| |n|
                                                          (QREFELT $ 130)))
                                      |lop| |lexp| |lfunc| (QREFELT $ 98))
                                     . #3#)
                               (LETT |e| (SPADCALL |lexp| |n| (QREFELT $ 131))
                                     . #3#)
                               (SEQ G190
                                    (COND
                                     ((NULL
                                       (COND
                                        ((SPADCALL |q| (|spadConstant| $ 132)
                                                   (QREFELT $ 133))
                                         'NIL)
                                        ('T 'T)))
                                      #5#))
                                    (SEQ
                                     (LETT |m| (SPADCALL |q| (QREFELT $ 134))
                                           . #3#)
                                     (LETT |qr| (DIVIDE2 |m| |e|) . #3#)
                                     (LETT |t1|
                                           (SPADCALL |f| (QCAR |qr|)
                                                     (QREFELT $ 135))
                                           . #3#)
                                     (LETT |t2|
                                           (SPADCALL |g| (QCDR |qr|)
                                                     (QREFELT $ 135))
                                           . #3#)
                                     (LETT |a|
                                           (SPADCALL |a|
                                                     (SPADCALL
                                                      (SPADCALL
                                                       (SPADCALL |q|
                                                                 (QREFELT $
                                                                          136))
                                                       |t1| (QREFELT $ 137))
                                                      |t2| (QREFELT $ 137))
                                                     (QREFELT $ 138))
                                           . #3#)
                                     (EXIT
                                      (LETT |q| (SPADCALL |q| (QREFELT $ 139))
                                            . #3#)))
                                    NIL #6# G191 (EXIT NIL))
                               (EXIT |a|))))))))))))) 

(DEFUN |FS-;smprep!0| (|y| $$)
  (PROG ($ |lop| |lexp| |lfunc|)
    (LETT $ (QREFELT $$ 3) . #1=(|FS-;smprep|))
    (LETT |lop| (QREFELT $$ 2) . #1#)
    (LETT |lexp| (QREFELT $$ 1) . #1#)
    (LETT |lfunc| (QREFELT $$ 0) . #1#)
    (RETURN
     (PROGN
      (SPADCALL (SPADCALL |y| (QREFELT $ 90)) |lop| |lexp| |lfunc|
                (QREFELT $ 98)))))) 

(DEFUN |FS-;dispdiff| (|l| $)
  (PROG (|m| #1=#:G2018 |x| #2=#:G2017 |i| |rec| |a| |k| |t| |s|)
    (RETURN
     (SEQ
      (LETT |s| (SPADCALL (SPADCALL |l| (QREFELT $ 54)) (QREFELT $ 140))
            . #3=(|FS-;dispdiff|))
      (LETT |t| (SPADCALL (SPADCALL |l| (QREFELT $ 55)) (QREFELT $ 140)) . #3#)
      (LETT |a|
            (SPADCALL
             (LETT |k| (SPADCALL (|SPADfirst| |l|) (QREFELT $ 28)) . #3#)
             (QREFELT $ 45))
            . #3#)
      (EXIT
       (COND
        ((SPADCALL |k| (QREFELT $ 15) (QREFELT $ 141))
         (SEQ (LETT |rec| (|FS-;dispdiff| |a| $) . #3#)
              (LETT |i| (SPADCALL |s| (QVELT |rec| 2) (QREFELT $ 143)) . #3#)
              (SPADCALL (QVELT |rec| 2) |i| |t| (QREFELT $ 144))
              (EXIT
               (VECTOR (QVELT |rec| 0)
                       (SPADCALL (QVELT |rec| 1)
                                 (SPADCALL
                                  (SPADCALL (SPADCALL "," (QREFELT $ 60))
                                            (QREFELT $ 145))
                                  (SPADCALL
                                   (- (+ |i| 1) (SPADCALL |a| (QREFELT $ 148)))
                                   (QREFELT $ 149))
                                  (QREFELT $ 150))
                                 (QREFELT $ 150))
                       (QVELT |rec| 2)
                       (COND ((ZEROP (QVELT |rec| 3)) 0)
                             (#4='T (+ (QVELT |rec| 3) 1)))))))
        (#4#
         (SEQ
          (LETT |i|
                (SPADCALL (SPADCALL |l| (QREFELT $ 54)) |a| (QREFELT $ 151))
                . #3#)
          (LETT |m|
                (PROGN
                 (LETT #2# NIL . #3#)
                 (SEQ (LETT |x| NIL . #3#) (LETT #1# |a| . #3#) G190
                      (COND
                       ((OR (ATOM #1#) (PROGN (LETT |x| (CAR #1#) . #3#) NIL))
                        (GO G191)))
                      (SEQ
                       (EXIT
                        (LETT #2# (CONS (SPADCALL |x| (QREFELT $ 140)) #2#)
                              . #3#)))
                      (LETT #1# (CDR #1#) . #3#) (GO G190) G191
                      (EXIT (NREVERSE0 #2#))))
                . #3#)
          (SPADCALL |m| |i| |t| (QREFELT $ 144))
          (EXIT
           (VECTOR
            (SPADCALL (SPADCALL (SPADCALL |k| (QREFELT $ 43)) (QREFELT $ 48))
                      (QREFELT $ 145))
            (SPADCALL (SPADCALL (SPADCALL "," (QREFELT $ 60)) (QREFELT $ 145))
                      (SPADCALL (- (+ |i| 1) (SPADCALL |a| (QREFELT $ 148)))
                                (QREFELT $ 149))
                      (QREFELT $ 150))
            |m| (COND ((NULL (CDR |a|)) 1) (#4# 0)))))))))))) 

(DEFUN |FS-;ddiff| (|l| $)
  (PROG (|opname| |rec|)
    (RETURN
     (SEQ (LETT |rec| (|FS-;dispdiff| |l| $) . #1=(|FS-;ddiff|))
          (LETT |opname|
                (COND
                 ((ZEROP (QVELT |rec| 3))
                  (SPADCALL (QVELT |rec| 0) (QVELT |rec| 1) (QREFELT $ 152)))
                 ('T
                  (SPADCALL (QVELT |rec| 0) (QVELT |rec| 3) (QREFELT $ 153))))
                . #1#)
          (EXIT (SPADCALL |opname| (QVELT |rec| 2) (QREFELT $ 154))))))) 

(DEFUN |FS-;substArg| (|op| |l| |i| |g| $)
  (PROG (|z|)
    (RETURN
     (SEQ (LETT |z| (SPADCALL |l| (QREFELT $ 155)) |FS-;substArg|)
          (SPADCALL |z| |i| |g| (QREFELT $ 156))
          (EXIT (SPADCALL |op| |z| (QREFELT $ 46))))))) 

(DEFUN |FS-;diffdiff| (|l| |x| $)
  (PROG (|f|)
    (RETURN
     (SEQ
      (LETT |f| (SPADCALL (QREFELT $ 15) |l| (QREFELT $ 46)) |FS-;diffdiff|)
      (EXIT
       (|FS-;diffdiff0| |l| |x| |f| (SPADCALL |f| (QREFELT $ 28)) NIL $)))))) 

(DEFUN |FS-;diffdiff0| (|l| |x| |expr| |kd| |done| $)
  (PROG (|ans| |g| |bp| #1=#:G2036 |i| #2=#:G2037 |b| |arg| |u| |gg| |op| |k|)
    (RETURN
     (SEQ
      (LETT |op|
            (SPADCALL
             (LETT |k| (SPADCALL (|SPADfirst| |l|) (QREFELT $ 28))
                   . #3=(|FS-;diffdiff0|))
             (QREFELT $ 43))
            . #3#)
      (LETT |gg| (SPADCALL |l| (QREFELT $ 54)) . #3#)
      (LETT |u| (SPADCALL |l| (QREFELT $ 55)) . #3#)
      (LETT |arg| (SPADCALL |k| (QREFELT $ 45)) . #3#)
      (LETT |ans| (|spadConstant| $ 127) . #3#)
      (COND
       ((NULL (SPADCALL |u| |done| (QREFELT $ 157)))
        (SEQ (LETT |ans| (SPADCALL |u| |x| (QREFELT $ 158)) . #3#)
             (EXIT
              (COND
               ((NULL (SPADCALL |ans| (|spadConstant| $ 127) (QREFELT $ 159)))
                (LETT |ans|
                      (SPADCALL |ans|
                                (SPADCALL (QREFELT $ 15)
                                          (LIST
                                           (SPADCALL |expr| (LIST |kd|)
                                                     (LIST
                                                      (SPADCALL (QREFELT $ 15)
                                                                (LIST
                                                                 (|SPADfirst|
                                                                  |l|)
                                                                 |gg| |gg|)
                                                                (QREFELT $
                                                                         46)))
                                                     (QREFELT $ 160))
                                           |gg| |u|)
                                          (QREFELT $ 46))
                                (QREFELT $ 137))
                      . #3#)))))))
      (LETT |done| (CONS |gg| |done|) . #3#)
      (EXIT
       (COND
        ((SPADCALL |k| (QREFELT $ 15) (QREFELT $ 141))
         (SPADCALL |ans| (|FS-;diffdiff0| |arg| |x| |expr| |k| |done| $)
                   (QREFELT $ 138)))
        ('T
         (SEQ
          (SEQ (LETT |b| NIL . #3#) (LETT #2# |arg| . #3#)
               (LETT |i| (SPADCALL |arg| (QREFELT $ 148)) . #3#)
               (LETT #1# (SPADCALL |arg| (QREFELT $ 161)) . #3#) G190
               (COND
                ((OR (> |i| #1#) (ATOM #2#)
                     (PROGN (LETT |b| (CAR #2#) . #3#) NIL))
                 (GO G191)))
               (SEQ
                (EXIT
                 (COND
                  ((NULL (SPADCALL |b| |done| (QREFELT $ 157)))
                   (SEQ (LETT |bp| (SPADCALL |b| |x| (QREFELT $ 158)) . #3#)
                        (EXIT
                         (COND
                          ((NULL
                            (SPADCALL |bp| (|spadConstant| $ 127)
                                      (QREFELT $ 159)))
                           (SEQ
                            (LETT |g|
                                  (SPADCALL (|FS-;symsub| (QREFELT $ 83) |i| $)
                                            (QREFELT $ 38))
                                  . #3#)
                            (EXIT
                             (LETT |ans|
                                   (SPADCALL |ans|
                                             (SPADCALL |bp|
                                                       (SPADCALL (QREFELT $ 15)
                                                                 (LIST
                                                                  (SPADCALL
                                                                   |expr|
                                                                   (LIST |kd|)
                                                                   (LIST
                                                                    (SPADCALL
                                                                     (QREFELT $
                                                                              15)
                                                                     (LIST
                                                                      (|FS-;substArg|
                                                                       |op|
                                                                       |arg|
                                                                       |i| |g|
                                                                       $)
                                                                      |gg| |u|)
                                                                     (QREFELT $
                                                                              46)))
                                                                   (QREFELT $
                                                                            160))
                                                                  |g| |b|)
                                                                 (QREFELT $
                                                                          46))
                                                       (QREFELT $ 137))
                                             (QREFELT $ 138))
                                   . #3#)))))))))))
               (LETT |i| (PROG1 (+ |i| 1) (LETT #2# (CDR #2#) . #3#)) . #3#)
               (GO G190) G191 (EXIT NIL))
          (EXIT |ans|))))))))) 

(DEFUN |FS-;dfeval| (|l| |g| $)
  (PROG (#1=#:G2039)
    (RETURN
     (SPADCALL
      (SPADCALL (|SPADfirst| |l|)
                (PROG2
                    (LETT #1# (SPADCALL |g| (QREFELT $ 30)) |FS-;dfeval|)
                    (QCDR #1#)
                  (|check-union| (QEQCAR #1# 0) (|Symbol|) #1#))
                (QREFELT $ 158))
      |g| (SPADCALL |l| (QREFELT $ 55)) (QREFELT $ 56))))) 

(DEFUN |FS-;diffEval| (|l| $)
  (PROG (|d| |n| |nl| |ss| |dumm| |ud| |op| #1=#:G2070 |k| |u| |g|)
    (RETURN
     (SEQ
      (EXIT
       (SEQ
        (LETT |g| (SPADCALL (SPADCALL |l| (QREFELT $ 54)) (QREFELT $ 28))
              . #2=(|FS-;diffEval|))
        (SEQ (LETT |u| (SPADCALL (|SPADfirst| |l|) (QREFELT $ 81)) . #2#)
             (EXIT
              (COND
               ((QEQCAR |u| 1)
                (PROGN (LETT #1# (|FS-;dfeval| |l| |g| $) . #2#) (GO #1#)))
               ((QEQCAR |u| 0)
                (COND
                 ((QEQCAR (SPADCALL (LETT |k| (QCDR |u|) . #2#) (QREFELT $ 30))
                          0)
                  (PROGN
                   (LETT #1# (|FS-;dfeval| |l| |g| $) . #2#)
                   (GO #1#))))))))
        (LETT |op| (SPADCALL |k| (QREFELT $ 43)) . #2#)
        (LETT |ud| (SPADCALL |op| (QREFELT $ 164)) . #2#)
        (EXIT
         (COND
          ((QEQCAR |ud| 1)
           (SEQ
            (LETT |dumm|
                  (SPADCALL (|FS-;symsub| (QREFELT $ 83) 1 $) (QREFELT $ 38))
                  . #2#)
            (LETT |ss|
                  (SPADCALL (SPADCALL |l| 1 (QREFELT $ 165))
                            (SPADCALL (SPADCALL |l| 2 (QREFELT $ 165)) |dumm|
                                      (QREFELT $ 167))
                            (QREFELT $ 169))
                  . #2#)
            (LETT |nl| (LIST |ss| |dumm| (SPADCALL |l| 3 (QREFELT $ 165)))
                  . #2#)
            (EXIT (SPADCALL (QREFELT $ 15) |nl| (QREFELT $ 46)))))
          ((<
            (LETT |n|
                  (SPADCALL (SPADCALL |l| (QREFELT $ 54))
                            (SPADCALL |k| (QREFELT $ 45)) (QREFELT $ 151))
                  . #2#)
            (SPADCALL |l| (QREFELT $ 148)))
           (|FS-;dfeval| |l| |g| $))
          ('T
           (SEQ (LETT |d| (QCDR |ud|) . #2#)
                (EXIT
                 (SPADCALL
                  (SPADCALL (SPADCALL |k| (QREFELT $ 45))
                            (SPADCALL |d| |n| (QREFELT $ 130)))
                  |g| (SPADCALL |l| (QREFELT $ 55)) (QREFELT $ 56)))))))))
      #1# (EXIT #1#))))) 

(DEFUN |FS-;diffArg| (|l| |op| |i| $)
  (PROG (|g| |z| |n|)
    (RETURN
     (SEQ
      (LETT |n| (+ (- |i| 1) (SPADCALL |l| (QREFELT $ 148)))
            . #1=(|FS-;diffArg|))
      (LETT |z| (SPADCALL |l| (QREFELT $ 155)) . #1#)
      (SPADCALL |z| |n|
                (LETT |g|
                      (SPADCALL (|FS-;symsub| (QREFELT $ 83) |n| $)
                                (QREFELT $ 38))
                      . #1#)
                (QREFELT $ 156))
      (EXIT
       (LIST (SPADCALL |op| |z| (QREFELT $ 46)) |g|
             (SPADCALL |l| |n| (QREFELT $ 165)))))))) 

(DEFUN |FS-;opderiv| (|op| |n| $)
  (PROG (|i| #1=#:G2081 |g|)
    (RETURN
     (SEQ
      (COND
       ((EQL |n| 1)
        (SEQ
         (LETT |g|
               (SPADCALL (|FS-;symsub| (QREFELT $ 83) |n| $) (QREFELT $ 38))
               . #2=(|FS-;opderiv|))
         (EXIT
          (LIST (CONS #'|FS-;opderiv!0| (VECTOR $ |g| |op| (QREFELT $ 15)))))))
       ('T
        (PROGN
         (LETT #1# NIL . #2#)
         (SEQ (LETT |i| 1 . #2#) G190 (COND ((QSGREATERP |i| |n|) (GO G191)))
              (SEQ
               (EXIT
                (LETT #1#
                      (CONS
                       (CONS #'|FS-;opderiv!1|
                             (VECTOR $ |i| |op| (QREFELT $ 15)))
                       #1#)
                      . #2#)))
              (LETT |i| (QSADD1 |i|) . #2#) (GO G190) G191
              (EXIT (NREVERSE0 #1#)))))))))) 

(DEFUN |FS-;opderiv!1| (|x| $$)
  (PROG (|opdiff| |op| |i| $)
    (LETT |opdiff| (QREFELT $$ 3) . #1=(|FS-;opderiv|))
    (LETT |op| (QREFELT $$ 2) . #1#)
    (LETT |i| (QREFELT $$ 1) . #1#)
    (LETT $ (QREFELT $$ 0) . #1#)
    (RETURN
     (PROGN
      (SPADCALL |opdiff| (|FS-;diffArg| |x| |op| |i| $) (QREFELT $ 46)))))) 

(DEFUN |FS-;opderiv!0| (|x| $$)
  (PROG (|opdiff| |op| |g| $)
    (LETT |opdiff| (QREFELT $$ 3) . #1=(|FS-;opderiv|))
    (LETT |op| (QREFELT $$ 2) . #1#)
    (LETT |g| (QREFELT $$ 1) . #1#)
    (LETT $ (QREFELT $$ 0) . #1#)
    (RETURN
     (PROGN
      (SPADCALL |opdiff|
                (LIST (SPADCALL |op| |g| (QREFELT $ 170)) |g|
                      (SPADCALL |x| (QREFELT $ 94)))
                (QREFELT $ 46)))))) 

(DEFUN |FS-;kderiv| (|k| $)
  (PROG (#1=#:G2093 |g| #2=#:G2092 |grad| |u| |op| |n| |args|)
    (RETURN
     (SEQ
      (COND
       ((ZEROP
         (LETT |n|
               (LENGTH
                (LETT |args| (SPADCALL |k| (QREFELT $ 45))
                      . #3=(|FS-;kderiv|)))
               . #3#))
        NIL)
       (#4='T
        (SEQ (LETT |op| (SPADCALL |k| (QREFELT $ 43)) . #3#)
             (LETT |grad|
                   (SEQ (LETT |u| (SPADCALL |op| (QREFELT $ 164)) . #3#)
                        (EXIT
                         (COND ((QEQCAR |u| 1) (|FS-;opderiv| |op| |n| $))
                               (#4# (QCDR |u|)))))
                   . #3#)
             (COND
              ((NULL (EQL (LENGTH |grad|) |n|))
               (LETT |grad| (|FS-;opderiv| |op| |n| $) . #3#)))
             (EXIT
              (PROGN
               (LETT #2# NIL . #3#)
               (SEQ (LETT |g| NIL . #3#) (LETT #1# |grad| . #3#) G190
                    (COND
                     ((OR (ATOM #1#) (PROGN (LETT |g| (CAR #1#) . #3#) NIL))
                      (GO G191)))
                    (SEQ
                     (EXIT (LETT #2# (CONS (SPADCALL |args| |g|) #2#) . #3#)))
                    (LETT #1# (CDR #1#) . #3#) (GO G190) G191
                    (EXIT (NREVERSE0 #2#)))))))))))) 

(DEFUN |FS-;kerderiv| (|k| |x| $)
  (PROG (#1=#:G2106 #2=#:G2105 #3=#:G2107 #4=#:G2111 |g| #5=#:G2112 |y| |fn|
         |v|)
    (RETURN
     (SEQ (LETT |v| (SPADCALL |k| (QREFELT $ 30)) . #6=(|FS-;kerderiv|))
          (EXIT
           (COND
            ((QEQCAR |v| 0)
             (COND ((EQUAL (QCDR |v|) |x|) (|spadConstant| $ 146))
                   (#7='T (|spadConstant| $ 127))))
            (#7#
             (SEQ
              (LETT |fn|
                    (SPADCALL (SPADCALL |k| (QREFELT $ 43)) (QREFELT $ 10)
                              (QREFELT $ 172))
                    . #6#)
              (EXIT
               (COND
                ((QEQCAR |fn| 0)
                 (SPADCALL (SPADCALL |k| (QREFELT $ 45)) |x| (QCDR |fn|)))
                (#7#
                 (PROGN
                  (LETT #1# NIL . #6#)
                  (SEQ (LETT |y| NIL . #6#)
                       (LETT #5# (SPADCALL |k| (QREFELT $ 45)) . #6#)
                       (LETT |g| NIL . #6#)
                       (LETT #4# (|FS-;kderiv| |k| $) . #6#) G190
                       (COND
                        ((OR (ATOM #4#) (PROGN (LETT |g| (CAR #4#) . #6#) NIL)
                             (ATOM #5#) (PROGN (LETT |y| (CAR #5#) . #6#) NIL))
                         (GO G191)))
                       (SEQ
                        (EXIT
                         (PROGN
                          (LETT #3#
                                (SPADCALL |g|
                                          (SPADCALL |y| |x| (QREFELT $ 158))
                                          (QREFELT $ 137))
                                . #6#)
                          (COND
                           (#1#
                            (LETT #2# (SPADCALL #2# #3# (QREFELT $ 138))
                                  . #6#))
                           ('T
                            (PROGN
                             (LETT #2# #3# . #6#)
                             (LETT #1# 'T . #6#)))))))
                       (LETT #4# (PROG1 (CDR #4#) (LETT #5# (CDR #5#) . #6#))
                             . #6#)
                       (GO G190) G191 (EXIT NIL))
                  (COND (#1# #2#) (#7# (|spadConstant| $ 127))))))))))))))) 

(DEFUN |FS-;smpderiv| (|p| |x| $)
  (PROG (#1=#:G2136 #2=#:G2135 #3=#:G2137 #4=#:G2139 |k|)
    (RETURN
     (SEQ
      (SPADCALL
       (SPADCALL
        (SPADCALL (CONS #'|FS-;smpderiv!0| (VECTOR |x| $)) |p| (QREFELT $ 178))
        (QREFELT $ 90))
       (PROGN
        (LETT #1# NIL . #5=(|FS-;smpderiv|))
        (SEQ (LETT |k| NIL . #5#)
             (LETT #4# (SPADCALL |p| (QREFELT $ 180)) . #5#) G190
             (COND
              ((OR (ATOM #4#) (PROGN (LETT |k| (CAR #4#) . #5#) NIL))
               (GO G191)))
             (SEQ
              (EXIT
               (PROGN
                (LETT #3#
                      (SPADCALL
                       (SPADCALL (SPADCALL |p| |k| (QREFELT $ 181))
                                 (QREFELT $ 90))
                       (|FS-;kerderiv| |k| |x| $) (QREFELT $ 137))
                      . #5#)
                (COND (#1# (LETT #2# (SPADCALL #2# #3# (QREFELT $ 138)) . #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 (|spadConstant| $ 127))))
       (QREFELT $ 138)))))) 

(DEFUN |FS-;smpderiv!0| (|s| $$)
  (PROG ($ |x|)
    (LETT $ (QREFELT $$ 1) . #1=(|FS-;smpderiv|))
    (LETT |x| (QREFELT $$ 0) . #1#)
    (RETURN
     (PROGN
      (SPADCALL (SPADCALL (SPADCALL |s| (QREFELT $ 174)) |x| (QREFELT $ 175))
                (QREFELT $ 176)))))) 

(DEFUN |FS-;coerce;PS;43| (|p| $)
  (SPADCALL (ELT $ 38) (ELT $ 182) |p| (QREFELT $ 186))) 

(DEFUN |FS-;worse?| (|k1| |k2| $)
  (PROG (|u|)
    (RETURN
     (SEQ
      (LETT |u|
            (SPADCALL (SPADCALL (SPADCALL |k1| (QREFELT $ 43)) (QREFELT $ 48))
                      (SPADCALL (SPADCALL |k2| (QREFELT $ 43)) (QREFELT $ 48))
                      (QREFELT $ 190))
            |FS-;worse?|)
      (EXIT
       (COND ((QEQCAR |u| 1) (SPADCALL |k1| |k2| (QREFELT $ 191)))
             ('T (QCDR |u|)))))))) 

(DEFUN |FS-;bestKernel| (|l| $)
  (PROG (|a|)
    (RETURN
     (SEQ
      (COND ((NULL (CDR |l|)) (|SPADfirst| |l|))
            (#1='T
             (SEQ (LETT |a| (|FS-;bestKernel| (CDR |l|) $) |FS-;bestKernel|)
                  (EXIT
                   (COND ((|FS-;worse?| (|SPADfirst| |l|) |a| $) |a|)
                         (#1# (|SPADfirst| |l|))))))))))) 

(DEFUN |FS-;smp2O| (|p| $)
  (PROG (|a| #1=#:G2158 |r|)
    (RETURN
     (SEQ (LETT |r| (SPADCALL |p| (QREFELT $ 192)) . #2=(|FS-;smp2O|))
          (EXIT
           (COND ((QEQCAR |r| 0) (SPADCALL (QCDR |r|) (QREFELT $ 193)))
                 (#3='T
                  (SEQ
                   (LETT |a|
                         (COND
                          ((SPADCALL (QREFELT $ 194))
                           (|FS-;bestKernel| (SPADCALL |p| (QREFELT $ 180)) $))
                          (#3#
                           (PROG2
                               (LETT #1# (SPADCALL |p| (QREFELT $ 115)) . #2#)
                               (QCDR #1#)
                             (|check-union| (QEQCAR #1# 0)
                                            (|Kernel| (QREFELT $ 6)) #1#))))
                         . #2#)
                   (EXIT
                    (SPADCALL
                     (SPADCALL (ELT $ 90) (SPADCALL |p| |a| (QREFELT $ 117))
                               (QREFELT $ 122))
                     (SPADCALL |a| (QREFELT $ 195)) (QREFELT $ 196))))))))))) 

(DEFUN |FS-;smpsubst| (|p| |lk| |lv| $)
  (PROG ()
    (RETURN
     (SPADCALL (CONS #'|FS-;smpsubst!2| (VECTOR $ |lv| |lk|)) (ELT $ 182) |p|
               (QREFELT $ 201))))) 

(DEFUN |FS-;smpsubst!2| (|x| $$)
  (PROG (|lk| |lv| $)
    (LETT |lk| (QREFELT $$ 2) . #1=(|FS-;smpsubst|))
    (LETT |lv| (QREFELT $$ 1) . #1#)
    (LETT $ (QREFELT $$ 0) . #1#)
    (RETURN
     (PROGN
      (PROG ()
        (RETURN
         (SPADCALL |lk| |lv| |x|
                   (|FS-;notfound|
                    (CONS #'|FS-;smpsubst!1| (VECTOR |lk| |lv| $)) |lk| |x| $)
                   (QREFELT $ 198)))))))) 

(DEFUN |FS-;smpsubst!1| (|z| $$)
  (PROG ($ |lv| |lk|)
    (LETT $ (QREFELT $$ 2) NIL)
    (LETT |lv| (QREFELT $$ 1) NIL)
    (LETT |lk| (QREFELT $$ 0) NIL)
    (RETURN
     (PROGN
      (PROG ()
        (RETURN
         (|FS-;subs| (CONS #'|FS-;smpsubst!0| (VECTOR $ |lv| |lk|)) |z| $))))))) 

(DEFUN |FS-;smpsubst!0| (|s| $$)
  (PROG (|lk| |lv| $)
    (LETT |lk| (QREFELT $$ 2) NIL)
    (LETT |lv| (QREFELT $$ 1) NIL)
    (LETT $ (QREFELT $$ 0) NIL)
    (RETURN (PROGN (SPADCALL |s| |lk| |lv| (QREFELT $ 160)))))) 

(DEFUN |FS-;smpeval| (|p| |lk| |lv| $)
  (PROG ()
    (RETURN
     (SPADCALL (CONS #'|FS-;smpeval!2| (VECTOR $ |lv| |lk|)) (ELT $ 182) |p|
               (QREFELT $ 201))))) 

(DEFUN |FS-;smpeval!2| (|x| $$)
  (PROG (|lk| |lv| $)
    (LETT |lk| (QREFELT $$ 2) . #1=(|FS-;smpeval|))
    (LETT |lv| (QREFELT $$ 1) . #1#)
    (LETT $ (QREFELT $$ 0) . #1#)
    (RETURN
     (PROGN
      (PROG ()
        (RETURN
         (SPADCALL |lk| |lv| |x|
                   (|FS-;notfound|
                    (CONS #'|FS-;smpeval!1| (VECTOR |lk| |lv| $)) |lk| |x| $)
                   (QREFELT $ 198)))))))) 

(DEFUN |FS-;smpeval!1| (|z| $$)
  (PROG ($ |lv| |lk|)
    (LETT $ (QREFELT $$ 2) NIL)
    (LETT |lv| (QREFELT $$ 1) NIL)
    (LETT |lk| (QREFELT $$ 0) NIL)
    (RETURN
     (PROGN
      (PROG ()
        (RETURN
         (SPADCALL (CONS #'|FS-;smpeval!0| (VECTOR $ |lv| |lk|)) |z|
                   (QREFELT $ 203)))))))) 

(DEFUN |FS-;smpeval!0| (|s| $$)
  (PROG (|lk| |lv| $)
    (LETT |lk| (QREFELT $$ 2) NIL)
    (LETT |lv| (QREFELT $$ 1) NIL)
    (LETT $ (QREFELT $$ 0) NIL)
    (RETURN (PROGN (SPADCALL |s| |lk| |lv| (QREFELT $ 202)))))) 

(DEFUN |FS-;notfound| (|fn| |lk| |k| $)
  (PROG (|f|)
    (RETURN
     (COND
      ((NULL
        (SPADCALL
         (SPADCALL (LETT |f| (SPADCALL |k| (QREFELT $ 26)) |FS-;notfound|)
                   (QREFELT $ 78))
         |lk| (QREFELT $ 204)))
       |f|)
      ('T (SPADCALL |k| |fn|)))))) 

(DEFUN |FS-;pushunq| (|l| |arg| $)
  (PROG (#1=#:G2181 |a| #2=#:G2180 #3=#:G2179 #4=#:G2178)
    (RETURN
     (SEQ
      (COND
       ((NULL |l|)
        (PROGN
         (LETT #4# NIL . #5=(|FS-;pushunq|))
         (SEQ (LETT |a| NIL . #5#) (LETT #3# |arg| . #5#) G190
              (COND
               ((OR (ATOM #3#) (PROGN (LETT |a| (CAR #3#) . #5#) NIL))
                #6=(GO G191)))
              (SEQ
               (EXIT
                (LETT #4# (CONS (SPADCALL |a| (QREFELT $ 205)) #4#) . #5#)))
              (LETT #3# (CDR #3#) . #5#) #7=(GO G190) G191
              (EXIT (NREVERSE0 #4#)))))
       ('T
        (PROGN
         (LETT #2# NIL . #5#)
         (SEQ (LETT |a| NIL . #5#) (LETT #1# |arg| . #5#) G190
              (COND
               ((OR (ATOM #1#) (PROGN (LETT |a| (CAR #1#) . #5#) NIL)) #6#))
              (SEQ
               (EXIT
                (LETT #2# (CONS (SPADCALL |a| |l| (QREFELT $ 63)) #2#) . #5#)))
              (LETT #1# (CDR #1#) . #5#) #7# G191 (EXIT (NREVERSE0 #2#)))))))))) 

(DEFUN |FS-;kunq| (|k| |l| |givenlist?| $)
  (PROG (#1=#:G2221 |a| #2=#:G2220 |s|)
    (RETURN
     (SEQ
      (COND
       (|givenlist?| (COND ((NULL |l|) (EXIT (SPADCALL |k| (QREFELT $ 26)))))))
      (COND
       ((SPADCALL |k| (QREFELT $ 16) (QREFELT $ 141))
        (COND
         ((OR
           (SPADCALL
            (LETT |s|
                  (SPADCALL (|SPADfirst| (SPADCALL |k| (QREFELT $ 45)))
                            (QREFELT $ 206))
                  . #3=(|FS-;kunq|))
            |l| (QREFELT $ 207))
           (NULL |l|))
          (EXIT
           (SPADCALL
            (SPADCALL
             (CONS (SPADCALL |s| (QREFELT $ 58))
                   (PROGN
                    (LETT #2# NIL . #3#)
                    (SEQ (LETT |a| NIL . #3#)
                         (LETT #1#
                               (|FS-;pushunq| |l|
                                (CDR (SPADCALL |k| (QREFELT $ 45))) $)
                               . #3#)
                         G190
                         (COND
                          ((OR (ATOM #1#)
                               (PROGN (LETT |a| (CAR #1#) . #3#) NIL))
                           (GO G191)))
                         (SEQ
                          (EXIT
                           (LETT #2# (CONS (SPADCALL |a| (QREFELT $ 61)) #2#)
                                 . #3#)))
                         (LETT #1# (CDR #1#) . #3#) (GO G190) G191
                         (EXIT (NREVERSE0 #2#)))))
             (QREFELT $ 59))
            (QREFELT $ 209)))))))
      (EXIT
       (SPADCALL (SPADCALL |k| (QREFELT $ 43))
                 (|FS-;pushunq| |l| (SPADCALL |k| (QREFELT $ 45)) $)
                 (QREFELT $ 39))))))) 

(DEFUN |FS-;smpunq| (|p| |l| |givenlist?| $)
  (PROG ()
    (RETURN
     (SEQ
      (COND
       (|givenlist?| (COND ((NULL |l|) (EXIT (SPADCALL |p| (QREFELT $ 90)))))))
      (EXIT
       (SPADCALL (CONS #'|FS-;smpunq!0| (VECTOR $ |givenlist?| |l|))
                 (ELT $ 182) |p| (QREFELT $ 201))))))) 

(DEFUN |FS-;smpunq!0| (|x| $$)
  (PROG (|l| |givenlist?| $)
    (LETT |l| (QREFELT $$ 2) . #1=(|FS-;smpunq|))
    (LETT |givenlist?| (QREFELT $$ 1) . #1#)
    (LETT $ (QREFELT $$ 0) . #1#)
    (RETURN (PROGN (|FS-;kunq| |x| |l| |givenlist?| $))))) 

(DEFUN |FS-;smpret| (|p| $)
  (PROG (#1=#:G2230 #2=#:G2229 #3=#:G2231 #4=#:G2240 |k|)
    (RETURN
     (SEQ
      (COND
       ((PROGN
         (LETT #1# NIL . #5=(|FS-;smpret|))
         (SEQ (LETT |k| NIL . #5#)
              (LETT #4# (SPADCALL |p| (QREFELT $ 180)) . #5#) G190
              (COND
               ((OR (ATOM #4#) (PROGN (LETT |k| (CAR #4#) . #5#) NIL))
                (GO G191)))
              (SEQ
               (EXIT
                (PROGN
                 (LETT #3# (QEQCAR (SPADCALL |k| (QREFELT $ 30)) 1) . #5#)
                 (COND (#1# (LETT #2# (COND (#2# 'T) ('T #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#) (#6='T 'NIL)))
        (CONS 1 "failed"))
       (#6#
        (CONS 0
              (SPADCALL (CONS #'|FS-;smpret!0| $) (ELT $ 174) |p|
                        (QREFELT $ 214))))))))) 

(DEFUN |FS-;smpret!0| (|x| $)
  (PROG (#1=#:G2233)
    (RETURN
     (SPADCALL
      (PROG2
          (LETT #1# (SPADCALL |x| (QREFELT $ 30)) NIL)
          (QCDR #1#)
        (|check-union| (QEQCAR #1# 0) (|Symbol|) #1#))
      (QREFELT $ 210))))) 

(DEFUN |FS-;isExpt;SBoU;54| (|x| |op| $)
  (PROG (|v| |u|)
    (RETURN
     (SEQ (LETT |u| (SPADCALL |x| (QREFELT $ 217)) . #1=(|FS-;isExpt;SBoU;54|))
          (EXIT
           (COND ((QEQCAR |u| 1) (CONS 1 "failed"))
                 ('T
                  (SEQ (LETT |v| (QCAR (QCDR |u|)) . #1#)
                       (COND
                        ((SPADCALL |v| |op| (QREFELT $ 141))
                         (COND
                          ((EQL (LENGTH (SPADCALL |v| (QREFELT $ 45))) 1)
                           (EXIT |u|)))))
                       (EXIT (CONS 1 "failed")))))))))) 

(DEFUN |FS-;isExpt;SSU;55| (|x| |sy| $)
  (PROG (|v| |u|)
    (RETURN
     (SEQ (LETT |u| (SPADCALL |x| (QREFELT $ 217)) . #1=(|FS-;isExpt;SSU;55|))
          (EXIT
           (COND ((QEQCAR |u| 1) (CONS 1 "failed"))
                 ('T
                  (SEQ (LETT |v| (QCAR (QCDR |u|)) . #1#)
                       (COND
                        ((SPADCALL |v| |sy| (QREFELT $ 219))
                         (COND
                          ((EQL (LENGTH (SPADCALL |v| (QREFELT $ 45))) 1)
                           (EXIT |u|)))))
                       (EXIT (CONS 1 "failed")))))))))) 

(DEFUN |FS-;smpIsMult| (|p| $)
  (PROG (#1=#:G2284 |n| |r| |q| |u|)
    (RETURN
     (SEQ
      (EXIT
       (SEQ
        (SEQ (LETT |u| (SPADCALL |p| (QREFELT $ 115)) . #2=(|FS-;smpIsMult|))
             (EXIT
              (COND
               ((QEQCAR |u| 0)
                (COND
                 ((EQL
                   (SPADCALL
                    (LETT |q| (SPADCALL |p| (QCDR |u|) (QREFELT $ 117)) . #2#)
                    (QREFELT $ 221))
                   1)
                  (COND
                   ((SPADCALL
                     (SPADCALL (SPADCALL |q| (QREFELT $ 222)) (QREFELT $ 223))
                     (QREFELT $ 224))
                    (SEQ
                     (LETT |r|
                           (SPADCALL (SPADCALL |q| (QREFELT $ 223))
                                     (QREFELT $ 192))
                           . #2#)
                     (EXIT
                      (COND
                       ((QEQCAR |r| 0)
                        (SEQ
                         (LETT |n| (SPADCALL (QCDR |r|) (QREFELT $ 226)) . #2#)
                         (EXIT
                          (COND
                           ((QEQCAR |n| 0)
                            (PROGN
                             (LETT #1# (CONS 0 (CONS (QCDR |n|) (QCDR |u|)))
                                   . #2#)
                             (GO #1#))))))))))))))))))
        (EXIT (CONS 1 "failed"))))
      #1# (EXIT #1#))))) 

(PUT '|FS-;debugA| '|SPADreplace| '(XLAM (|a1| |a2| |t|) |t|)) 

(DEFUN |FS-;debugA| (|a1| |a2| |t| $) |t|) 

(DEFUN |FS-;equaldiff| (|k1| |k2| $)
  (PROG (|res| |a2| |a1|)
    (RETURN
     (SEQ (LETT |a1| (SPADCALL |k1| (QREFELT $ 45)) . #1=(|FS-;equaldiff|))
          (LETT |a2| (SPADCALL |k2| (QREFELT $ 45)) . #1#)
          (LETT |res|
                (SPADCALL (SPADCALL |k1| (QREFELT $ 43))
                          (SPADCALL |k2| (QREFELT $ 43)) (QREFELT $ 41))
                . #1#)
          (EXIT
           (COND
            (|res|
             (SEQ
              (LETT |res|
                    (SPADCALL (SPADCALL |a1| 3 (QREFELT $ 165))
                              (SPADCALL |a2| 3 (QREFELT $ 165))
                              (QREFELT $ 159))
                    . #1#)
              (EXIT
               (COND
                (|res|
                 (SEQ
                  (LETT |res|
                        (COND
                         ((SPADCALL (SPADCALL |a1| 1 (QREFELT $ 165))
                                    (SPADCALL |a2| 1 (QREFELT $ 165))
                                    (QREFELT $ 159))
                          (SPADCALL (SPADCALL |a1| 2 (QREFELT $ 165))
                                    (SPADCALL |a2| 2 (QREFELT $ 165))
                                    (QREFELT $ 159)))
                         (#2='T 'NIL))
                        . #1#)
                  (EXIT
                   (COND (|res| (|FS-;debugA| |a1| |a2| |res| $))
                         ((SPADCALL
                           (SPADCALL (SPADCALL |a1| 1 (QREFELT $ 165))
                                     (LIST
                                      (SPADCALL
                                       (SPADCALL |a1| 2 (QREFELT $ 165))
                                       (QREFELT $ 28)))
                                     (LIST (SPADCALL |a2| 2 (QREFELT $ 165)))
                                     (QREFELT $ 160))
                           (SPADCALL |a2| 1 (QREFELT $ 165)) (QREFELT $ 159))
                          (|FS-;debugA| |a1| |a2| 'T $))
                         (#2# (|FS-;debugA| |a1| |a2| 'NIL $))))))
                (#2# (|FS-;debugA| |a1| |a2| |res| $))))))
            (#2# (|FS-;debugA| |a1| |a2| |res| $)))))))) 

(DEFUN |FS-;mainKernel;SU;59| (|x| $)
  (SPADCALL (SPADCALL |x| (QREFELT $ 92)) (QREFELT $ 115))) 

(DEFUN |FS-;kernels;SL;60| (|x| $)
  (SPADCALL (SPADCALL |x| (QREFELT $ 92)) (QREFELT $ 180))) 

(DEFUN |FS-;retract;SR;61| (|x| $)
  (SPADCALL (SPADCALL |x| (QREFELT $ 92)) (QREFELT $ 230))) 

(DEFUN |FS-;retract;SP;62| (|x| $)
  (PROG (#1=#:G2311)
    (RETURN
     (PROG2
         (LETT #1# (|FS-;smpret| (SPADCALL |x| (QREFELT $ 92)) $)
               |FS-;retract;SP;62|)
         (QCDR #1#)
       (|check-union| (QEQCAR #1# 0) (|Polynomial| (QREFELT $ 7)) #1#))))) 

(DEFUN |FS-;retractIfCan;SU;63| (|x| $)
  (CONS 0 (SPADCALL (SPADCALL |x| (QREFELT $ 92)) (QREFELT $ 230)))) 

(DEFUN |FS-;retractIfCan;SU;64| (|x| $)
  (|FS-;smpret| (SPADCALL |x| (QREFELT $ 92)) $)) 

(DEFUN |FS-;eval;SLLS;65| (|x| |lk| |lv| $)
  (|FS-;smpeval| (SPADCALL |x| (QREFELT $ 92)) |lk| |lv| $)) 

(DEFUN |FS-;subst;SLLS;66| (|x| |lk| |lv| $)
  (|FS-;smpsubst| (SPADCALL |x| (QREFELT $ 92)) |lk| |lv| $)) 

(DEFUN |FS-;differentiate;SSS;67| (|x| |s| $)
  (|FS-;smpderiv| (SPADCALL |x| (QREFELT $ 92)) |s| $)) 

(DEFUN |FS-;coerce;SOf;68| (|x| $)
  (|FS-;smp2O| (SPADCALL |x| (QREFELT $ 92)) $)) 

(DEFUN |FS-;eval;SLS;69| (|f| |l| $)
  (|FS-;smpunq| (SPADCALL |f| (QREFELT $ 92)) |l| 'T $)) 

(DEFUN |FS-;eval;2S;70| (|f| $)
  (|FS-;smpunq| (SPADCALL |f| (QREFELT $ 92)) NIL 'NIL $)) 

(DEFUN |FS-;eval;SLLLS;71| (|x| |s| |n| |f| $)
  (|FS-;smprep| |s| |n| |f| (SPADCALL |x| (QREFELT $ 92)) $)) 

(DEFUN |FS-;isPlus;SU;72| (|x| $)
  (PROG (#1=#:G2345 |p| #2=#:G2344 |u|)
    (RETURN
     (SEQ
      (LETT |u| (SPADCALL (SPADCALL |x| (QREFELT $ 92)) (QREFELT $ 244))
            . #3=(|FS-;isPlus;SU;72|))
      (EXIT
       (COND ((QEQCAR |u| 1) (CONS 1 "failed"))
             ('T
              (CONS 0
                    (PROGN
                     (LETT #2# NIL . #3#)
                     (SEQ (LETT |p| NIL . #3#) (LETT #1# (QCDR |u|) . #3#) G190
                          (COND
                           ((OR (ATOM #1#)
                                (PROGN (LETT |p| (CAR #1#) . #3#) NIL))
                            (GO G191)))
                          (SEQ
                           (EXIT
                            (LETT #2# (CONS (SPADCALL |p| (QREFELT $ 90)) #2#)
                                  . #3#)))
                          (LETT #1# (CDR #1#) . #3#) (GO G190) G191
                          (EXIT (NREVERSE0 #2#)))))))))))) 

(DEFUN |FS-;isTimes;SU;73| (|x| $)
  (PROG (#1=#:G2356 |p| #2=#:G2355 |u|)
    (RETURN
     (SEQ
      (LETT |u| (SPADCALL (SPADCALL |x| (QREFELT $ 92)) (QREFELT $ 246))
            . #3=(|FS-;isTimes;SU;73|))
      (EXIT
       (COND ((QEQCAR |u| 1) (CONS 1 "failed"))
             ('T
              (CONS 0
                    (PROGN
                     (LETT #2# NIL . #3#)
                     (SEQ (LETT |p| NIL . #3#) (LETT #1# (QCDR |u|) . #3#) G190
                          (COND
                           ((OR (ATOM #1#)
                                (PROGN (LETT |p| (CAR #1#) . #3#) NIL))
                            (GO G191)))
                          (SEQ
                           (EXIT
                            (LETT #2# (CONS (SPADCALL |p| (QREFELT $ 90)) #2#)
                                  . #3#)))
                          (LETT #1# (CDR #1#) . #3#) (GO G190) G191
                          (EXIT (NREVERSE0 #2#)))))))))))) 

(DEFUN |FS-;isExpt;SU;74| (|x| $)
  (PROG (|r| |u|)
    (RETURN
     (SEQ
      (LETT |u| (SPADCALL (SPADCALL |x| (QREFELT $ 92)) (QREFELT $ 250))
            . #1=(|FS-;isExpt;SU;74|))
      (EXIT
       (COND ((QEQCAR |u| 1) (CONS 1 "failed"))
             ('T
              (SEQ (LETT |r| (QCDR |u|) . #1#)
                   (EXIT (CONS 0 (CONS (QCAR |r|) (QCDR |r|)))))))))))) 

(DEFUN |FS-;isPower;SU;75| (|x| $)
  (PROG (|r| |u|)
    (RETURN
     (SEQ
      (LETT |u| (SPADCALL (SPADCALL |x| (QREFELT $ 92)) (QREFELT $ 250))
            . #1=(|FS-;isPower;SU;75|))
      (EXIT
       (COND ((QEQCAR |u| 1) (CONS 1 "failed"))
             ('T
              (SEQ (LETT |r| (QCDR |u|) . #1#)
                   (EXIT
                    (CONS 0
                          (CONS (SPADCALL (QCAR |r|) (QREFELT $ 26))
                                (QCDR |r|)))))))))))) 

(DEFUN |FS-;convert;SP;76| (|x| $)
  (SPADCALL (SPADCALL |x| (QREFELT $ 92)) (QREFELT $ 256))) 

(DEFUN |FS-;convert;SP;77| (|x| $)
  (SPADCALL (SPADCALL |x| (QREFELT $ 92)) (QREFELT $ 259))) 

(DEFUN |FS-;isMult;SU;78| (|x| $)
  (|FS-;smpIsMult| (SPADCALL |x| (QREFELT $ 92)) $)) 

(DEFUN |FS-;*;R2S;79| (|r| |x| $)
  (SPADCALL (SPADCALL (SPADCALL |r| (QREFELT $ 264)) (QREFELT $ 90)) |x|
            (QREFELT $ 137))) 

(DEFUN |FS-;mainKernel;SU;80| (|x| $) (SPADCALL |x| (QREFELT $ 267))) 

(DEFUN |FS-;kernels;SL;81| (|x| $) (SPADCALL |x| (QREFELT $ 268))) 

(DEFUN |FS-;univariate;SKF;82| (|x| |k| $) (SPADCALL |x| |k| (QREFELT $ 270))) 

(DEFUN |FS-;isPlus;SU;83| (|x| $) (SPADCALL |x| (QREFELT $ 274))) 

(DEFUN |FS-;isTimes;SU;84| (|x| $) (SPADCALL |x| (QREFELT $ 275))) 

(DEFUN |FS-;isExpt;SU;85| (|x| $) (SPADCALL |x| (QREFELT $ 278))) 

(DEFUN |FS-;isPower;SU;86| (|x| $) (SPADCALL |x| (QREFELT $ 281))) 

(DEFUN |FS-;denominator;2S;87| (|x| $)
  (SPADCALL (SPADCALL |x| (QREFELT $ 282)) (QREFELT $ 90))) 

(DEFUN |FS-;coerce;FS;88| (|q| $)
  (SPADCALL (SPADCALL (SPADCALL |q| (QREFELT $ 285)) (QREFELT $ 264))
            (SPADCALL (SPADCALL |q| (QREFELT $ 286)) (QREFELT $ 264))
            (QREFELT $ 287))) 

(DEFUN |FS-;coerce;FS;89| (|q| $)
  (SPADCALL (SPADCALL (SPADCALL |q| (QREFELT $ 290)) (QREFELT $ 291))
            (SPADCALL (SPADCALL |q| (QREFELT $ 292)) (QREFELT $ 291))
            (QREFELT $ 293))) 

(DEFUN |FS-;coerce;FS;90| (|q| $)
  (SPADCALL (SPADCALL (SPADCALL |q| (QREFELT $ 297)) (QREFELT $ 298))
            (SPADCALL (SPADCALL |q| (QREFELT $ 299)) (QREFELT $ 298))
            (QREFELT $ 293))) 

(DEFUN |FS-;retract;SP;91| (|x| $)
  (SPADCALL (SPADCALL |x| (QREFELT $ 301)) (QREFELT $ 302))) 

(DEFUN |FS-;retract;SF;92| (|x| $)
  (PROG (#1=#:G2443)
    (RETURN
     (SPADCALL
      (PROG2
          (LETT #1# (|FS-;smpret| (SPADCALL |x| (QREFELT $ 92)) $)
                . #2=(|FS-;retract;SF;92|))
          (QCDR #1#)
        (|check-union| (QEQCAR #1# 0) (|Polynomial| (QREFELT $ 7)) #1#))
      (PROG2
          (LETT #1# (|FS-;smpret| (SPADCALL |x| (QREFELT $ 282)) $) . #2#)
          (QCDR #1#)
        (|check-union| (QEQCAR #1# 0) (|Polynomial| (QREFELT $ 7)) #1#))
      (QREFELT $ 303))))) 

(DEFUN |FS-;retract;SR;93| (|x| $)
  (PROG (#1=#:G2450)
    (RETURN
     (PROG2
         (LETT #1#
               (SPADCALL
                (SPADCALL (SPADCALL |x| (QREFELT $ 92)) (QREFELT $ 230))
                (SPADCALL (SPADCALL |x| (QREFELT $ 282)) (QREFELT $ 230))
                (QREFELT $ 306))
               |FS-;retract;SR;93|)
         (QCDR #1#)
       (|check-union| (QEQCAR #1# 0) (QREFELT $ 7) #1#))))) 

(DEFUN |FS-;coerce;SOf;94| (|x| $)
  (COND
   ((SPADCALL (SPADCALL |x| (QREFELT $ 282)) (|spadConstant| $ 307)
              (QREFELT $ 308))
    (|FS-;smp2O| (SPADCALL |x| (QREFELT $ 92)) $))
   ('T
    (SPADCALL (|FS-;smp2O| (SPADCALL |x| (QREFELT $ 92)) $)
              (|FS-;smp2O| (SPADCALL |x| (QREFELT $ 282)) $) (QREFELT $ 309))))) 

(DEFUN |FS-;retractIfCan;SU;95| (|x| $)
  (PROG (#1=#:G2461 |r| |d| |n|)
    (RETURN
     (SEQ
      (EXIT
       (SEQ
        (SEQ
         (LETT |n| (SPADCALL (SPADCALL |x| (QREFELT $ 92)) (QREFELT $ 192))
               . #2=(|FS-;retractIfCan;SU;95|))
         (EXIT
          (COND
           ((QEQCAR |n| 1)
            (PROGN (LETT #1# (CONS 1 #3="failed") . #2#) (GO #1#)))
           (#4='T
            (SEQ
             (LETT |d|
                   (SPADCALL (SPADCALL |x| (QREFELT $ 282)) (QREFELT $ 192))
                   . #2#)
             (EXIT
              (COND
               ((QEQCAR |d| 1) (PROGN (LETT #1# (CONS 1 #3#) . #2#) (GO #1#)))
               (#4#
                (SEQ
                 (LETT |r| (SPADCALL (QCDR |n|) (QCDR |d|) (QREFELT $ 306))
                       . #2#)
                 (EXIT
                  (COND
                   ((QEQCAR |r| 1)
                    (PROGN (LETT #1# (CONS 1 #3#) . #2#) (GO #1#))))))))))))))
        (EXIT (CONS 0 (QCDR |r|)))))
      #1# (EXIT #1#))))) 

(DEFUN |FS-;eval;SLS;96| (|f| |l| $)
  (SPADCALL (|FS-;smpunq| (SPADCALL |f| (QREFELT $ 92)) |l| 'T $)
            (|FS-;smpunq| (SPADCALL |f| (QREFELT $ 282)) |l| 'T $)
            (QREFELT $ 293))) 

(DEFUN |FS-;eval;2S;97| (|f| $)
  (SPADCALL (|FS-;smpunq| (SPADCALL |f| (QREFELT $ 92)) NIL 'NIL $)
            (|FS-;smpunq| (SPADCALL |f| (QREFELT $ 282)) NIL 'NIL $)
            (QREFELT $ 293))) 

(DEFUN |FS-;eval;SLLLS;98| (|x| |s| |n| |f| $)
  (SPADCALL (|FS-;smprep| |s| |n| |f| (SPADCALL |x| (QREFELT $ 92)) $)
            (|FS-;smprep| |s| |n| |f| (SPADCALL |x| (QREFELT $ 282)) $)
            (QREFELT $ 293))) 

(DEFUN |FS-;differentiate;SSS;99| (|f| |x| $)
  (SPADCALL
   (SPADCALL
    (SPADCALL (|FS-;smpderiv| (SPADCALL |f| (QREFELT $ 92)) |x| $)
              (SPADCALL (SPADCALL |f| (QREFELT $ 282)) (QREFELT $ 90))
              (QREFELT $ 137))
    (SPADCALL (SPADCALL (SPADCALL |f| (QREFELT $ 92)) (QREFELT $ 90))
              (|FS-;smpderiv| (SPADCALL |f| (QREFELT $ 282)) |x| $)
              (QREFELT $ 137))
    (QREFELT $ 310))
   (SPADCALL (SPADCALL (SPADCALL |f| (QREFELT $ 282)) (QREFELT $ 90)) 2
             (QREFELT $ 311))
   (QREFELT $ 293))) 

(DEFUN |FS-;eval;SLLS;100| (|x| |lk| |lv| $)
  (SPADCALL (|FS-;smpeval| (SPADCALL |x| (QREFELT $ 92)) |lk| |lv| $)
            (|FS-;smpeval| (SPADCALL |x| (QREFELT $ 282)) |lk| |lv| $)
            (QREFELT $ 293))) 

(DEFUN |FS-;subst;SLLS;101| (|x| |lk| |lv| $)
  (SPADCALL (|FS-;smpsubst| (SPADCALL |x| (QREFELT $ 92)) |lk| |lv| $)
            (|FS-;smpsubst| (SPADCALL |x| (QREFELT $ 282)) |lk| |lv| $)
            (QREFELT $ 293))) 

(DEFUN |FS-;par| (|x| $)
  (PROG (|r|)
    (RETURN
     (SEQ (LETT |r| (SPADCALL |x| (QREFELT $ 18)) |FS-;par|)
          (EXIT
           (COND ((QEQCAR |r| 0) |x|) ('T (SPADCALL |x| (QREFELT $ 312))))))))) 

(DEFUN |FS-;convert;FS;103| (|x| $)
  (PROG (#1=#:G2496 #2=#:G2495 #3=#:G2497 #4=#:G2499 |f|)
    (RETURN
     (SEQ
      (SPADCALL (|FS-;par| (SPADCALL |x| (QREFELT $ 314)) $)
                (PROGN
                 (LETT #1# NIL . #5=(|FS-;convert;FS;103|))
                 (SEQ (LETT |f| NIL . #5#)
                      (LETT #4# (SPADCALL |x| (QREFELT $ 317)) . #5#) G190
                      (COND
                       ((OR (ATOM #4#) (PROGN (LETT |f| (CAR #4#) . #5#) NIL))
                        (GO G191)))
                      (SEQ
                       (EXIT
                        (PROGN
                         (LETT #3#
                               (SPADCALL (|FS-;par| (QCAR |f|) $) (QCDR |f|)
                                         (QREFELT $ 311))
                               . #5#)
                         (COND
                          (#1#
                           (LETT #2# (SPADCALL #2# #3# (QREFELT $ 137)) . #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 (|spadConstant| $ 146))))
                (QREFELT $ 137)))))) 

(DEFUN |FS-;retractIfCan;SU;104| (|x| $)
  (PROG (|u|)
    (RETURN
     (SEQ (LETT |u| (SPADCALL |x| (QREFELT $ 321)) |FS-;retractIfCan;SU;104|)
          (EXIT
           (COND ((QEQCAR |u| 1) (CONS 1 "failed"))
                 ('T (SPADCALL (QCDR |u|) (QREFELT $ 322))))))))) 

(DEFUN |FS-;retractIfCan;SU;105| (|x| $)
  (PROG (|d| |n|)
    (RETURN
     (SEQ
      (LETT |n| (|FS-;smpret| (SPADCALL |x| (QREFELT $ 92)) $)
            . #1=(|FS-;retractIfCan;SU;105|))
      (EXIT
       (COND ((QEQCAR |n| 1) (CONS 1 "failed"))
             (#2='T
              (SEQ
               (LETT |d| (|FS-;smpret| (SPADCALL |x| (QREFELT $ 282)) $) . #1#)
               (EXIT
                (COND ((QEQCAR |d| 1) (CONS 1 "failed"))
                      (#2#
                       (CONS 0
                             (SPADCALL (QCDR |n|) (QCDR |d|)
                                       (QREFELT $ 303)))))))))))))) 

(DEFUN |FS-;coerce;PS;106| (|p| $)
  (SPADCALL (ELT $ 38) (ELT $ 324) |p| (QREFELT $ 327))) 

(DEFUN |FS-;coerce;FS;107| (|x| $)
  (SPADCALL (SPADCALL (SPADCALL |x| (QREFELT $ 330)) (QREFELT $ 331))
            (SPADCALL (SPADCALL |x| (QREFELT $ 332)) (QREFELT $ 331))
            (QREFELT $ 287))) 

(DEFUN |FS-;isMult;SU;108| (|x| $)
  (PROG (|q| |r| #1=#:G2536 |w| |v| |u|)
    (RETURN
     (SEQ
      (EXIT
       (SEQ
        (SEQ
         (LETT |u| (|FS-;smpIsMult| (SPADCALL |x| (QREFELT $ 92)) $)
               . #2=(|FS-;isMult;SU;108|))
         (EXIT
          (COND
           ((QEQCAR |u| 1)
            (PROGN (LETT #1# (CONS 1 #3="failed") . #2#) (GO #1#)))
           (#4='T
            (SEQ
             (LETT |v|
                   (SPADCALL (SPADCALL |x| (QREFELT $ 282)) (QREFELT $ 192))
                   . #2#)
             (EXIT
              (COND
               ((QEQCAR |v| 1) (PROGN (LETT #1# (CONS 1 #3#) . #2#) (GO #1#)))
               (#4#
                (SEQ (LETT |w| (SPADCALL (QCDR |v|) (QREFELT $ 226)) . #2#)
                     (EXIT
                      (COND
                       ((QEQCAR |w| 1)
                        (PROGN
                         (LETT #1# (CONS 1 #3#) . #2#)
                         (GO #1#))))))))))))))
        (LETT |r| (QCDR |u|) . #2#)
        (LETT |q| (SPADCALL (QCAR |r|) (QCDR |w|) (QREFELT $ 334)) . #2#)
        (EXIT
         (COND ((QEQCAR |q| 1) (CONS 1 "failed"))
               (#4# (CONS 0 (CONS (QCDR |q|) (QCDR |r|))))))))
      #1# (EXIT #1#))))) 

(DEFUN |FS-;convert;SP;109| (|x| $)
  (SPADCALL (SPADCALL (SPADCALL |x| (QREFELT $ 92)) (QREFELT $ 256))
            (SPADCALL (SPADCALL |x| (QREFELT $ 282)) (QREFELT $ 256))
            (QREFELT $ 335))) 

(DEFUN |FS-;convert;SP;110| (|x| $)
  (SPADCALL (SPADCALL (SPADCALL |x| (QREFELT $ 92)) (QREFELT $ 259))
            (SPADCALL (SPADCALL |x| (QREFELT $ 282)) (QREFELT $ 259))
            (QREFELT $ 336))) 

(DEFUN |FunctionSpace&| (|#1| |#2|)
  (PROG (|pv$| $ |dv$| DV$2 DV$1)
    (RETURN
     (PROGN
      (LETT DV$1 (|devaluate| |#1|) . #1=(|FunctionSpace&|))
      (LETT DV$2 (|devaluate| |#2|) . #1#)
      (LETT |dv$| (LIST '|FunctionSpace&| DV$1 DV$2) . #1#)
      (LETT $ (GETREFV 340) . #1#)
      (QSETREFV $ 0 |dv$|)
      (QSETREFV $ 3
                (LETT |pv$|
                      (|buildPredVector| 0 0
                                         (LIST
                                          (|HasCategory| |#2|
                                                         '(|RetractableTo|
                                                           (|Integer|)))
                                          (|HasCategory| |#2|
                                                         '(|IntegralDomain|))
                                          (|HasCategory| |#2|
                                                         '(|CommutativeRing|))
                                          (|HasCategory| |#2|
                                                         '(|CharacteristicNonZero|))
                                          (|HasCategory| |#2|
                                                         '(|CharacteristicZero|))
                                          (|HasCategory| |#2| '(|Ring|))
                                          (|HasCategory| |#2|
                                                         '(|AbelianGroup|))
                                          (|HasCategory| |#2|
                                                         '(|AbelianSemiGroup|))
                                          (|HasCategory| |#2| '(|Group|))
                                          (|HasCategory| |#2| '(|SemiGroup|))
                                          (|HasCategory| |#2|
                                                         '(|ConvertibleTo|
                                                           (|InputForm|)))))
                      . #1#))
      (|stuffDomainSlots| $)
      (QSETREFV $ 6 |#1|)
      (QSETREFV $ 7 |#2|)
      (QSETREFV $ 8 '|odd|)
      (QSETREFV $ 9 '|even|)
      (QSETREFV $ 10 '|%specialDiff|)
      (QSETREFV $ 15 (SPADCALL '|%diff| (QREFELT $ 14)))
      (QSETREFV $ 16 (SPADCALL '|%quote| (QREFELT $ 14)))
      (COND
       ((|testBitVector| |pv$| 11)
        (PROGN
         (QSETREFV $ 64 (CONS (|dispatchFunction| |FS-;eval;SSS;16|) $))
         (QSETREFV $ 67 (CONS (|dispatchFunction| |FS-;eval;SBoSSS;17|) $))
         (QSETREFV $ 74 (CONS (|dispatchFunction| |FS-;eval;SLLSS;18|) $))
         (SPADCALL (QREFELT $ 15) '|%specialInput|
                   (CONS (|function| |FS-;indiff|) $) (QREFELT $ 76)))))
      (COND
       ((|testBitVector| |pv$| 6)
        (PROGN
         (QSETREFV $ 83 '%%0)
         (QSETREFV $ 86
                   (CONS (|dispatchFunction| |FS-;characteristic;Nni;21|) $))
         (QSETREFV $ 91 (CONS (|dispatchFunction| |FS-;coerce;KS;22|) $))
         (QSETREFV $ 93 (CONS (|dispatchFunction| |FS-;numerator;2S;24|) $))
         (QSETREFV $ 99 (CONS (|dispatchFunction| |FS-;eval;SSNniMS;25|) $))
         (QSETREFV $ 100 (CONS (|dispatchFunction| |FS-;eval;SSNniMS;26|) $))
         (QSETREFV $ 102 (CONS (|dispatchFunction| |FS-;eval;SLLS;27|) $))
         (QSETREFV $ 112 (CONS (|dispatchFunction| |FS-;elt;BoLS;28|) $))
         (QSETREFV $ 113 (CONS (|dispatchFunction| |FS-;eval;SLLLS;29|) $))
         (QSETREFV $ 187 (CONS (|dispatchFunction| |FS-;coerce;PS;43|) $))
         (COND ((|testBitVector| |pv$| 11)))
         (QSETREFV $ 218 (CONS (|dispatchFunction| |FS-;isExpt;SBoU;54|) $))
         (QSETREFV $ 220 (CONS (|dispatchFunction| |FS-;isExpt;SSU;55|) $))
         (COND ((|testBitVector| |pv$| 1)))
         (SPADCALL (QREFELT $ 15) (CONS (|function| |FS-;diffEval|) $)
                   (QREFELT $ 227))
         (SPADCALL (QREFELT $ 15) '|%specialEqual|
                   (CONS (|function| |FS-;equaldiff|) $) (QREFELT $ 76))
         (SPADCALL (QREFELT $ 15) (QREFELT $ 10)
                   (CONS (|function| |FS-;diffdiff|) $) (QREFELT $ 76))
         (SPADCALL (QREFELT $ 15) '|%specialDisp|
                   (CONS (|function| |FS-;ddiff|) $) (QREFELT $ 76))
         (COND ((|testBitVector| |pv$| 2))
               ('T
                (PROGN
                 (QSETREFV $ 228
                           (CONS (|dispatchFunction| |FS-;mainKernel;SU;59|)
                                 $))
                 (QSETREFV $ 229
                           (CONS (|dispatchFunction| |FS-;kernels;SL;60|) $))
                 (QSETREFV $ 231
                           (CONS (|dispatchFunction| |FS-;retract;SR;61|) $))
                 (QSETREFV $ 232
                           (CONS (|dispatchFunction| |FS-;retract;SP;62|) $))
                 (QSETREFV $ 233
                           (CONS (|dispatchFunction| |FS-;retractIfCan;SU;63|)
                                 $))
                 (QSETREFV $ 235
                           (CONS (|dispatchFunction| |FS-;retractIfCan;SU;64|)
                                 $))
                 (QSETREFV $ 236
                           (CONS (|dispatchFunction| |FS-;eval;SLLS;65|) $))
                 (QSETREFV $ 237
                           (CONS (|dispatchFunction| |FS-;subst;SLLS;66|) $))
                 (QSETREFV $ 238
                           (CONS
                            (|dispatchFunction| |FS-;differentiate;SSS;67|) $))
                 (QSETREFV $ 239
                           (CONS (|dispatchFunction| |FS-;coerce;SOf;68|) $))
                 (COND
                  ((|testBitVector| |pv$| 11)
                   (PROGN
                    (QSETREFV $ 240
                              (CONS (|dispatchFunction| |FS-;eval;SLS;69|) $))
                    (QSETREFV $ 241
                              (CONS (|dispatchFunction| |FS-;eval;2S;70|)
                                    $)))))
                 (QSETREFV $ 242
                           (CONS (|dispatchFunction| |FS-;eval;SLLLS;71|) $))
                 (QSETREFV $ 245
                           (CONS (|dispatchFunction| |FS-;isPlus;SU;72|) $))
                 (QSETREFV $ 247
                           (CONS (|dispatchFunction| |FS-;isTimes;SU;73|) $))
                 (QSETREFV $ 251
                           (CONS (|dispatchFunction| |FS-;isExpt;SU;74|) $))
                 (QSETREFV $ 254
                           (CONS (|dispatchFunction| |FS-;isPower;SU;75|) $))
                 (COND
                  ((|HasCategory| |#2|
                                  '(|ConvertibleTo| (|Pattern| (|Integer|))))
                   (QSETREFV $ 257
                             (CONS (|dispatchFunction| |FS-;convert;SP;76|)
                                   $))))
                 (COND
                  ((|HasCategory| |#2|
                                  '(|ConvertibleTo| (|Pattern| (|Float|))))
                   (QSETREFV $ 260
                             (CONS (|dispatchFunction| |FS-;convert;SP;77|)
                                   $))))
                 (COND
                  ((|testBitVector| |pv$| 1)
                   (QSETREFV $ 263
                             (CONS (|dispatchFunction| |FS-;isMult;SU;78|)
                                   $))))))))))
      (COND
       ((|testBitVector| |pv$| 3)
        (QSETREFV $ 265 (CONS (|dispatchFunction| |FS-;*;R2S;79|) $))))
      (COND
       ((|testBitVector| |pv$| 2)
        (PROGN
         (QSETREFV $ 228 (CONS (|dispatchFunction| |FS-;mainKernel;SU;80|) $))
         (QSETREFV $ 229 (CONS (|dispatchFunction| |FS-;kernels;SL;81|) $))
         (QSETREFV $ 272 (CONS (|dispatchFunction| |FS-;univariate;SKF;82|) $))
         (QSETREFV $ 245 (CONS (|dispatchFunction| |FS-;isPlus;SU;83|) $))
         (QSETREFV $ 247 (CONS (|dispatchFunction| |FS-;isTimes;SU;84|) $))
         (QSETREFV $ 251 (CONS (|dispatchFunction| |FS-;isExpt;SU;85|) $))
         (QSETREFV $ 254 (CONS (|dispatchFunction| |FS-;isPower;SU;86|) $))
         (QSETREFV $ 283 (CONS (|dispatchFunction| |FS-;denominator;2S;87|) $))
         (QSETREFV $ 288 (CONS (|dispatchFunction| |FS-;coerce;FS;88|) $))
         (QSETREFV $ 294 (CONS (|dispatchFunction| |FS-;coerce;FS;89|) $))
         (QSETREFV $ 300 (CONS (|dispatchFunction| |FS-;coerce;FS;90|) $))
         (QSETREFV $ 232 (CONS (|dispatchFunction| |FS-;retract;SP;91|) $))
         (QSETREFV $ 304 (CONS (|dispatchFunction| |FS-;retract;SF;92|) $))
         (QSETREFV $ 231 (CONS (|dispatchFunction| |FS-;retract;SR;93|) $))
         (QSETREFV $ 239 (CONS (|dispatchFunction| |FS-;coerce;SOf;94|) $))
         (QSETREFV $ 233
                   (CONS (|dispatchFunction| |FS-;retractIfCan;SU;95|) $))
         (QSETREFV $ 240 (CONS (|dispatchFunction| |FS-;eval;SLS;96|) $))
         (COND
          ((|testBitVector| |pv$| 11)
           (PROGN
            (QSETREFV $ 241 (CONS (|dispatchFunction| |FS-;eval;2S;97|) $))
            (QSETREFV $ 242
                      (CONS (|dispatchFunction| |FS-;eval;SLLLS;98|) $)))))
         (QSETREFV $ 238
                   (CONS (|dispatchFunction| |FS-;differentiate;SSS;99|) $))
         (QSETREFV $ 236 (CONS (|dispatchFunction| |FS-;eval;SLLS;100|) $))
         (QSETREFV $ 237 (CONS (|dispatchFunction| |FS-;subst;SLLS;101|) $))
         (QSETREFV $ 319 (CONS (|dispatchFunction| |FS-;convert;FS;103|) $))
         (QSETREFV $ 235
                   (CONS (|dispatchFunction| |FS-;retractIfCan;SU;104|) $))
         (QSETREFV $ 323
                   (CONS (|dispatchFunction| |FS-;retractIfCan;SU;105|) $))
         (QSETREFV $ 328 (CONS (|dispatchFunction| |FS-;coerce;PS;106|) $))
         (COND
          ((|testBitVector| |pv$| 1)
           (PROGN
            (QSETREFV $ 333 (CONS (|dispatchFunction| |FS-;coerce;FS;107|) $))
            (QSETREFV $ 263
                      (CONS (|dispatchFunction| |FS-;isMult;SU;108|) $)))))
         (COND
          ((|HasCategory| |#2| '(|ConvertibleTo| (|Pattern| (|Integer|))))
           (QSETREFV $ 257
                     (CONS (|dispatchFunction| |FS-;convert;SP;109|) $))))
         (COND
          ((|HasCategory| |#2| '(|ConvertibleTo| (|Pattern| (|Float|))))
           (QSETREFV $ 260
                     (CONS (|dispatchFunction| |FS-;convert;SP;110|) $)))))))
      $)))) 

(MAKEPROP '|FunctionSpace&| '|infovec|
          (LIST
           '#(NIL NIL NIL NIL NIL NIL (|local| |#1|) (|local| |#2|) 'ODD 'EVEN
              'SPECIALDIFF (|BasicOperator|) (|Symbol|) (|CommonOperators|)
              (0 . |operator|) '|opdiff| '|opquote| (|Union| 7 '#1="failed")
              (5 . |retractIfCan|) (|Boolean|) |FS-;ground?;SB;1|
              (10 . |retract|) |FS-;ground;SR;2| (|Kernel| 6) (15 . |kernel|)
              (|Kernel| $) (20 . |coerce|) |FS-;coerce;SS;3| (25 . |retract|)
              (|Union| 12 '"failed") (30 . |symbolIfCan|) |FS-;retract;SS;4|
              (|List| $) (35 . |applyQuote|) |FS-;applyQuote;S2S;5|
              |FS-;applyQuote;S3S;6| |FS-;applyQuote;S4S;7|
              |FS-;applyQuote;S5S;8| (41 . |coerce|) (46 . |elt|)
              |FS-;applyQuote;SLS;9| (52 . =) |FS-;belong?;BoB;10|
              (58 . |operator|) (|List| 6) (63 . |argument|) (68 . |kernel|)
              (74 . |is?|) (80 . |name|) (|String|) (85 . |string|)
              (|OutputForm|) (90 . |coerce|) |FS-;operator;2Bo;12|
              (95 . |second|) (100 . |third|) (105 . |eval|) (|InputForm|)
              (112 . |convert|) (117 . |convert|) (122 . |coerce|)
              (127 . |convert|) (|List| 12) (132 . |eval|) (138 . |eval|)
              (|List| 11) (144 . |eval|) (152 . |eval|) (|Mapping| 6 6)
              (|MakeUnaryCompiledFunction| 6 6 6) (160 . |compiledFunction|)
              (|Mapping| $ $) (|List| 71) (166 . |eval|) (173 . |eval|)
              (|None|) (181 . |setProperty|) (|List| 25) (188 . |tower|)
              |FS-;variables;SL;19| (|Union| 25 '#1#) (193 . |retractIfCan|)
              |FS-;retractIfCan;SU;20| '|gendiff| (|NonNegativeInteger|)
              (198 . |characteristic|) (202 . |characteristic|)
              (|SparseMultivariatePolynomial| 7 23) (206 . |coerce|)
              (|SparseMultivariatePolynomial| 7 25) (211 . |coerce|)
              (216 . |coerce|) (221 . |numer|) (226 . |numerator|)
              (231 . |first|) (|List| 84) (|Mapping| $ 32) (|List| 96)
              (236 . |eval|) (244 . |eval|) (252 . |eval|) (260 . |new|)
              (266 . |eval|) (273 . |unary?|) (278 . |has?|)
              (284 . |leadingCoefficient|) (289 . |Zero|) (293 . |smaller?|)
              (299 . -) (304 . |elt|) (|ExpressionSpace&| 6) (310 . |elt|)
              (316 . |elt|) (322 . |eval|) (|Union| 23 '#2="failed")
              (330 . |mainVariable|) (|SparseUnivariatePolynomial| $)
              (335 . |univariate|) (|SparseUnivariatePolynomial| 6)
              (|Mapping| 6 87) (|SparseUnivariatePolynomial| 87)
              (|SparseUnivariatePolynomialFunctions2| 87 6) (341 . |map|)
              (|Integer|) (347 . |position|) (353 . |minIndex|) (358 . |elt|)
              (364 . |Zero|) (|Mapping| 6 44) (|List| 128) (368 . |elt|)
              (374 . |elt|) (380 . |Zero|) (384 . =) (390 . |degree|) (395 . ^)
              (401 . |leadingCoefficient|) (406 . *) (412 . +)
              (418 . |reductum|) (423 . |coerce|) (428 . |is?|) (|List| 51)
              (434 . |position|) (440 . |setelt|) (447 . |coerce|)
              (452 . |One|) (456 . |One|) (460 . |minIndex|) (465 . |coerce|)
              (470 . |hconcat|) (476 . |position|) (482 . |sub|)
              (488 . |differentiate|) (494 . |prefix|) (500 . |copy|)
              (505 . |setelt|) (512 . |member?|) (518 . |differentiate|)
              (524 . =) (530 . |subst|) (537 . |maxIndex|)
              (|Union| 129 '"failed") (|BasicOperatorFunctions1| 6)
              (542 . |derivative|) (547 . |elt|) (|Equation| 6) (553 . =)
              (|Equation| $) (559 . |subst|) (565 . |kernel|)
              (|Union| 75 '"failed") (571 . |property|) (|Polynomial| 7)
              (577 . |coerce|) (582 . |differentiate|) (588 . |retract|)
              (|Mapping| 7 7) (593 . |map|) (|List| 23) (599 . |variables|)
              (604 . |differentiate|) (610 . |coerce|) (|Mapping| 6 12)
              (|Mapping| 6 7)
              (|PolynomialCategoryLifting| (|IndexedExponents| 12) 12 7 173 6)
              (615 . |map|) (622 . |coerce|) (|Union| 19 '"failed")
              (|UserDefinedPartialOrdering| 12) (627 . |less?|) (633 . <)
              (639 . |retractIfCan|) (644 . |coerce|) (649 . |userOrdered?|)
              (653 . |coerce|) (658 . |outputForm|) (|ListToMap| 23 6)
              (664 . |match|) (|Mapping| 6 23)
              (|PolynomialCategoryLifting| (|IndexedExponents| 23) 23 7 87 6)
              (672 . |map|) (679 . |eval|) (686 . |map|)
              (692 . |setIntersection|) (698 . |eval|) (703 . |retract|)
              (708 . |member?|) (|InputFormFunctions1| 6) (714 . |interpret|)
              (719 . |coerce|) (|Mapping| 173 23) (|Mapping| 173 7)
              (|PolynomialCategoryLifting| (|IndexedExponents| 23) 23 7 87 173)
              (724 . |map|) (|Record| (|:| |var| 25) (|:| |exponent| 123))
              (|Union| 215 '"failed") (731 . |isExpt|) (736 . |isExpt|)
              (742 . |is?|) (748 . |isExpt|) (754 . |degree|)
              (759 . |reductum|) (764 . |leadingCoefficient|) (769 . |zero?|)
              (|Union| 123 '#1#) (774 . |retractIfCan|) (779 . |evaluate|)
              (785 . |mainKernel|) (790 . |kernels|) (795 . |retract|)
              (800 . |retract|) (805 . |retract|) (810 . |retractIfCan|)
              (|Union| 173 '"failed") (815 . |retractIfCan|) (820 . |eval|)
              (827 . |subst|) (834 . |differentiate|) (840 . |coerce|)
              (845 . |eval|) (851 . |eval|) (856 . |eval|) (|Union| 32 '#2#)
              (864 . |isPlus|) (869 . |isPlus|) (874 . |isTimes|)
              (879 . |isTimes|) (|Record| (|:| |var| 23) (|:| |exponent| 84))
              (|Union| 248 '#2#) (884 . |isExpt|) (889 . |isExpt|)
              (|Record| (|:| |val| $) (|:| |exponent| 123))
              (|Union| 252 '"failed") (894 . |isPower|) (|Pattern| 123)
              (899 . |convert|) (904 . |convert|) (|Pattern| (|Float|))
              (909 . |convert|) (914 . |convert|)
              (|Record| (|:| |coef| 123) (|:| |var| 25))
              (|Union| 261 '"failed") (919 . |isMult|) (924 . |coerce|)
              (929 . *)
              (|PolynomialCategoryQuotientFunctions| (|IndexedExponents| 23) 23
                                                     7 87 6)
              (935 . |mainVariable|) (940 . |variables|) (|Fraction| 118)
              (945 . |univariate|) (|Fraction| 116) (951 . |univariate|)
              (|Union| 44 '"failed") (957 . |isPlus|) (962 . |isTimes|)
              (|Record| (|:| |var| 23) (|:| |exponent| 123))
              (|Union| 276 '"failed") (967 . |isExpt|)
              (|Record| (|:| |val| 6) (|:| |exponent| 123))
              (|Union| 279 '"failed") (972 . |isPower|) (977 . |denom|)
              (982 . |denominator|) (|Fraction| 7) (987 . |numer|)
              (992 . |denom|) (997 . /) (1003 . |coerce|) (|Fraction| 173)
              (1008 . |numer|) (1013 . |coerce|) (1018 . |denom|) (1023 . /)
              (1029 . |coerce|) (|Polynomial| 284) (|Fraction| 295)
              (1034 . |numer|) (1039 . |coerce|) (1044 . |denom|)
              (1049 . |coerce|) (1054 . |retract|) (1059 . |retract|)
              (1064 . /) (1070 . |retract|) (|Union| $ '"failed")
              (1075 . |exquo|) (1081 . |One|) (1085 . =) (1091 . /) (1097 . -)
              (1103 . ^) (1109 . |paren|) (|Factored| 6) (1114 . |unit|)
              (|Record| (|:| |factor| 6) (|:| |exponent| 123)) (|List| 315)
              (1119 . |factors|) (|Factored| $) (1124 . |convert|)
              (|Union| 289 '#1#) (1129 . |retractIfCan|)
              (1134 . |retractIfCan|) (1139 . |retractIfCan|) (1144 . |coerce|)
              (|Mapping| 6 284)
              (|PolynomialCategoryLifting| (|IndexedExponents| 12) 12 284 295
                                           6)
              (1149 . |map|) (1156 . |coerce|) (|Fraction| 123)
              (1161 . |numer|) (1166 . |coerce|) (1171 . |denom|)
              (1176 . |coerce|) (1181 . |exquo|) (1187 . /) (1193 . /)
              (|PositiveInteger|) (|Union| 329 '#1#) (|List| 168))
           '#(|variables| 1199 |univariate| 1204 |subst| 1210 |retractIfCan|
              1217 |retract| 1237 |operator| 1257 |numerator| 1262 |mainKernel|
              1267 |kernels| 1272 |isTimes| 1277 |isPower| 1282 |isPlus| 1287
              |isMult| 1292 |isExpt| 1297 |ground?| 1314 |ground| 1319 |eval|
              1324 |elt| 1403 |differentiate| 1409 |denominator| 1415 |convert|
              1420 |coerce| 1435 |characteristic| 1480 |belong?| 1484
              |applyQuote| 1489 * 1525)
           'NIL
           (CONS (|makeByteWordVec2| 1 'NIL)
                 (CONS '#()
                       (CONS '#()
                             (|makeByteWordVec2| 336
                                                 '(1 13 11 12 14 1 6 17 0 18 1
                                                   6 7 0 21 1 23 0 12 24 1 6 0
                                                   25 26 1 6 25 0 28 1 23 29 0
                                                   30 2 6 0 12 32 33 1 6 0 12
                                                   38 2 6 0 11 32 39 2 11 19 0
                                                   0 41 1 23 11 0 43 1 23 44 0
                                                   45 2 6 0 11 32 46 2 11 19 0
                                                   12 47 1 11 12 0 48 1 12 49 0
                                                   50 1 49 51 0 52 1 44 6 0 54
                                                   1 44 6 0 55 3 6 0 0 25 0 56
                                                   1 12 57 0 58 1 57 0 32 59 1
                                                   12 0 49 60 1 6 57 0 61 2 6 0
                                                   0 62 63 2 0 0 0 12 64 4 6 0
                                                   0 65 32 12 66 4 0 0 0 11 0
                                                   12 67 2 69 68 6 12 70 3 6 0
                                                   0 65 72 73 4 0 0 0 65 32 12
                                                   74 3 11 0 0 12 75 76 1 6 77
                                                   0 78 1 6 80 0 81 0 7 84 85 0
                                                   0 84 86 1 87 0 23 88 1 6 0
                                                   89 90 1 0 0 25 91 1 6 89 0
                                                   92 1 0 0 0 93 1 44 6 0 94 4
                                                   6 0 0 62 95 97 98 4 0 0 0 12
                                                   84 71 99 4 0 0 0 12 84 96
                                                   100 2 95 0 84 84 101 3 0 0 0
                                                   62 97 102 1 11 19 0 103 2 11
                                                   19 0 12 104 1 87 7 0 105 0 7
                                                   0 106 2 7 19 0 0 107 1 6 0 0
                                                   108 2 6 0 11 0 109 2 110 0
                                                   11 32 111 2 0 0 11 32 112 4
                                                   0 0 0 62 95 72 113 1 87 114
                                                   0 115 2 87 116 0 23 117 2
                                                   121 118 119 120 122 2 62 123
                                                   12 0 124 1 62 123 0 125 2
                                                   118 6 0 6 126 0 6 0 127 2
                                                   129 128 0 123 130 2 95 84 0
                                                   123 131 0 118 0 132 2 118 19
                                                   0 0 133 1 118 84 0 134 2 6 0
                                                   0 84 135 1 118 6 0 136 2 6 0
                                                   0 0 137 2 6 0 0 0 138 1 118
                                                   0 0 139 1 6 51 0 140 2 23 19
                                                   0 11 141 2 142 123 51 0 143
                                                   3 142 51 0 123 51 144 1 12
                                                   51 0 145 0 6 0 146 0 7 0 147
                                                   1 44 123 0 148 1 123 51 0
                                                   149 2 51 0 0 0 150 2 44 123
                                                   6 0 151 2 51 0 0 0 152 2 51
                                                   0 0 84 153 2 51 0 0 32 154 1
                                                   44 0 0 155 3 44 6 0 123 6
                                                   156 2 44 19 6 0 157 2 6 0 0
                                                   12 158 2 6 19 0 0 159 3 6 0
                                                   0 77 32 160 1 44 123 0 161 1
                                                   163 162 11 164 2 44 6 0 123
                                                   165 2 166 0 6 6 167 2 6 0 0
                                                   168 169 2 6 0 11 0 170 2 11
                                                   171 0 12 172 1 173 0 7 174 2
                                                   173 0 0 12 175 1 173 7 0 176
                                                   2 87 0 177 0 178 1 87 179 0
                                                   180 2 87 0 0 23 181 1 6 0 7
                                                   182 3 185 6 183 184 173 186
                                                   1 0 0 173 187 2 189 188 12
                                                   12 190 2 23 19 0 0 191 1 87
                                                   17 0 192 1 7 51 0 193 0 189
                                                   19 194 1 23 51 0 195 2 118
                                                   51 0 51 196 4 197 6 179 44
                                                   23 6 198 3 200 6 199 184 87
                                                   201 3 6 0 0 77 32 202 2 6 0
                                                   71 25 203 2 179 0 0 0 204 1
                                                   6 0 0 205 1 6 12 0 206 2 62
                                                   19 12 0 207 1 208 6 57 209 1
                                                   173 0 12 210 3 213 173 211
                                                   212 87 214 1 6 216 0 217 2 0
                                                   216 0 11 218 2 23 19 0 12
                                                   219 2 0 216 0 12 220 1 120
                                                   84 0 221 1 120 0 0 222 1 120
                                                   87 0 223 1 87 19 0 224 1 7
                                                   225 0 226 2 163 11 11 128
                                                   227 1 0 80 0 228 1 0 77 0
                                                   229 1 87 7 0 230 1 0 7 0 231
                                                   1 0 173 0 232 1 0 17 0 233 1
                                                   0 234 0 235 3 0 0 0 77 32
                                                   236 3 0 0 0 77 32 237 2 0 0
                                                   0 12 238 1 0 51 0 239 2 0 0
                                                   0 62 240 1 0 0 0 241 4 0 0 0
                                                   62 95 97 242 1 87 243 0 244
                                                   1 0 243 0 245 1 87 243 0 246
                                                   1 0 243 0 247 1 87 249 0 250
                                                   1 0 216 0 251 1 0 253 0 254
                                                   1 87 255 0 256 1 0 255 0 257
                                                   1 87 258 0 259 1 0 258 0 260
                                                   1 0 262 0 263 1 87 0 7 264 2
                                                   0 0 7 0 265 1 266 114 6 267
                                                   1 266 179 6 268 2 266 269 6
                                                   23 270 2 0 271 0 25 272 1
                                                   266 273 6 274 1 266 273 6
                                                   275 1 266 277 6 278 1 266
                                                   280 6 281 1 6 89 0 282 1 0 0
                                                   0 283 1 284 7 0 285 1 284 7
                                                   0 286 2 6 0 89 89 287 1 0 0
                                                   284 288 1 289 173 0 290 1 6
                                                   0 173 291 1 289 173 0 292 2
                                                   6 0 0 0 293 1 0 0 289 294 1
                                                   296 295 0 297 1 6 0 295 298
                                                   1 296 295 0 299 1 0 0 296
                                                   300 1 6 289 0 301 1 289 173
                                                   0 302 2 289 0 173 173 303 1
                                                   0 289 0 304 2 7 305 0 0 306
                                                   0 87 0 307 2 87 19 0 0 308 2
                                                   51 0 0 0 309 2 6 0 0 0 310 2
                                                   6 0 0 123 311 1 6 0 0 312 1
                                                   313 6 0 314 1 313 316 0 317
                                                   1 0 0 318 319 1 6 320 0 321
                                                   1 289 234 0 322 1 0 320 0
                                                   323 1 6 0 284 324 3 326 6
                                                   183 325 295 327 1 0 0 295
                                                   328 1 329 123 0 330 1 87 0
                                                   123 331 1 329 123 0 332 1 0
                                                   0 329 333 2 123 305 0 0 334
                                                   2 255 0 0 0 335 2 258 0 0 0
                                                   336 1 0 62 0 79 2 0 271 0 25
                                                   272 3 0 0 0 77 32 237 1 0
                                                   234 0 235 1 0 320 0 323 1 0
                                                   17 0 233 1 0 29 0 82 1 0 173
                                                   0 232 1 0 289 0 304 1 0 7 0
                                                   231 1 0 12 0 31 1 0 11 11 53
                                                   1 0 0 0 93 1 0 80 0 228 1 0
                                                   77 0 229 1 0 243 0 247 1 0
                                                   253 0 254 1 0 243 0 245 1 0
                                                   262 0 263 2 0 216 0 12 220 2
                                                   0 216 0 11 218 1 0 216 0 251
                                                   1 0 19 0 20 1 0 7 0 22 4 0 0
                                                   0 12 84 96 100 4 0 0 0 12 84
                                                   71 99 4 0 0 0 62 95 97 242 4
                                                   0 0 0 62 95 72 113 4 0 0 0
                                                   65 32 12 74 4 0 0 0 11 0 12
                                                   67 2 0 0 0 62 240 1 0 0 0
                                                   241 2 0 0 0 12 64 3 0 0 0 62
                                                   97 102 3 0 0 0 77 32 236 2 0
                                                   0 11 32 112 2 0 0 0 12 238 1
                                                   0 0 0 283 1 0 0 318 319 1 0
                                                   258 0 260 1 0 255 0 257 1 0
                                                   0 329 333 1 0 0 173 187 1 0
                                                   0 289 294 1 0 0 296 300 1 0
                                                   0 295 328 1 0 0 284 288 1 0
                                                   0 12 27 1 0 51 0 239 1 0 0
                                                   25 91 0 0 84 86 1 0 19 11 42
                                                   5 0 0 12 0 0 0 0 37 2 0 0 12
                                                   32 40 4 0 0 12 0 0 0 36 2 0
                                                   0 12 0 34 3 0 0 12 0 0 35 2
                                                   0 0 7 0 265)))))
           '|lookupComplete|)) 
