
(/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=#:G1858)
    (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| '|any| (QREFELT $ 41))
    (COND ((SPADCALL |op| '|%diff| (QREFELT $ 42)) 'T)
          (#1='T (SPADCALL |op| '|%quote| (QREFELT $ 42)))))
   (#1# 'NIL))) 

(DEFUN |FS-;subs| (|fn| |k| $)
  (PROG (#1=#:G1881 |x| #2=#:G1880)
    (RETURN
     (SEQ
      (SPADCALL (SPADCALL |k| (QREFELT $ 44))
                (PROGN
                 (LETT #2# NIL . #3=(|FS-;subs|))
                 (SEQ (LETT |x| NIL . #3#)
                      (LETT #1# (SPADCALL |k| (QREFELT $ 46)) . #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 $ 47)))))) 

(DEFUN |FS-;operator;2Bo;12| (|op| $)
  (COND ((SPADCALL |op| '|%diff| (QREFELT $ 42)) (QREFELT $ 15))
        ((SPADCALL |op| '|%quote| (QREFELT $ 42)) (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 '|::| (QREFELT $ 58))
                   (SPADCALL (SPADCALL |l| (QREFELT $ 55)) (QREFELT $ 60))
                   (SPADCALL '|Symbol| (QREFELT $ 58)))
             (QREFELT $ 59))
            |FS-;indiff|)
      (EXIT
       (|FS-;pint|
        (LIST (SPADCALL (|FS-;differentiand| |l| $) (QREFELT $ 60)) |r2|)
        $)))))) 

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

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

(DEFUN |FS-;eval;SLLSS;18| (|f| |ls| |lg| |x| $)
  (PROG (#1=#:G1909 |g| #2=#:G1908)
    (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 $ 69)) #2#)
                              . #3#)))
                      (LETT #1# (CDR #1#) . #3#) (GO G190) G191
                      (EXIT (NREVERSE0 #2#))))
                (QREFELT $ 72)))))) 

(DEFUN |FS-;variables;SL;19| (|x| $)
  (PROG (|l| |s| #1=#:G1919 |k|)
    (RETURN
     (SEQ (LETT |l| NIL . #2=(|FS-;variables;SL;19|))
          (SEQ (LETT |k| NIL . #2#)
               (LETT #1# (SPADCALL |x| (QREFELT $ 77)) . #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 $ 80)) |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 $ 84))) 

(DEFUN |FS-;coerce;KS;22| (|k| $)
  (SPADCALL (SPADCALL |k| (QREFELT $ 87)) (QREFELT $ 89))) 

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

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

(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=#:G1959 |x| |od?|)
    (RETURN
     (SEQ
      (EXIT
       (SEQ
        (COND
         ((SPADCALL |op| (QREFELT $ 103))
          (SEQ
           (LETT |od?| (SPADCALL |op| (QREFELT $ 8) (QREFELT $ 41))
                 . #2=(|FS-;elt;BoLS;28|))
           (EXIT
            (COND
             ((OR |od?| (SPADCALL |op| (QREFELT $ 9) (QREFELT $ 41)))
              (COND
               ((SPADCALL
                 (SPADCALL (SPADCALL (|SPADfirst| |args|) (QREFELT $ 92))
                           (QREFELT $ 104))
                 (|spadConstant| $ 105) (QREFELT $ 106))
                (PROGN
                 (LETT #1#
                       (SEQ
                        (LETT |x|
                              (SPADCALL |op|
                                        (SPADCALL (|SPADfirst| |args|)
                                                  (QREFELT $ 107))
                                        (QREFELT $ 108))
                              . #2#)
                        (EXIT
                         (COND (|od?| (SPADCALL |x| (QREFELT $ 107)))
                               ('T |x|))))
                       . #2#)
                 (GO #1#))))))))))
        (EXIT (SPADCALL |op| |args| (QREFELT $ 110)))))
      #1# (EXIT #1#))))) 

(DEFUN |FS-;eval;SLLLS;29| (|x| |s| |n| |l| $)
  (PROG (#1=#:G1965 |f| #2=#:G1964)
    (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=#:G2009 #2=#:G2008
         |op| |k| |v|)
    (RETURN
     (SEQ (LETT |v| (SPADCALL |p| (QREFELT $ 114)) . #3=(|FS-;smprep|))
          (EXIT
           (COND ((QEQCAR |v| 1) (SPADCALL |p| (QREFELT $ 89)))
                 (#4='T
                  (SEQ (LETT |k| (QCDR |v|) . #3#)
                       (LETT |g|
                             (SPADCALL
                              (LETT |op| (SPADCALL |k| (QREFELT $ 44)) . #3#)
                              (LETT |arg|
                                    (PROGN
                                     (LETT #2# NIL . #3#)
                                     (SEQ (LETT |a| NIL . #3#)
                                          (LETT #1#
                                                (SPADCALL |k| (QREFELT $ 46))
                                                . #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 $ 116))
                              (QREFELT $ 121))
                             . #3#)
                       (EXIT
                        (COND
                         ((<
                           (LETT |n|
                                 (SPADCALL (SPADCALL |op| (QREFELT $ 48)) |lop|
                                           (QREFELT $ 123))
                                 . #3#)
                           (SPADCALL |lop| (QREFELT $ 124)))
                          (SPADCALL |q| |g| (QREFELT $ 125)))
                         (#4#
                          (SEQ (LETT |a| (|spadConstant| $ 126) . #3#)
                               (LETT |f|
                                     (SPADCALL
                                      (SPADCALL |arg|
                                                (SPADCALL |lfunc| |n|
                                                          (QREFELT $ 129)))
                                      |lop| |lexp| |lfunc| (QREFELT $ 98))
                                     . #3#)
                               (LETT |e| (SPADCALL |lexp| |n| (QREFELT $ 130))
                                     . #3#)
                               (SEQ G190
                                    (COND
                                     ((NULL
                                       (COND
                                        ((SPADCALL |q| (|spadConstant| $ 131)
                                                   (QREFELT $ 132))
                                         'NIL)
                                        ('T 'T)))
                                      #5#))
                                    (SEQ
                                     (LETT |m| (SPADCALL |q| (QREFELT $ 133))
                                           . #3#)
                                     (LETT |qr| (DIVIDE2 |m| |e|) . #3#)
                                     (LETT |t1|
                                           (SPADCALL |f| (QCAR |qr|)
                                                     (QREFELT $ 134))
                                           . #3#)
                                     (LETT |t2|
                                           (SPADCALL |g| (QCDR |qr|)
                                                     (QREFELT $ 134))
                                           . #3#)
                                     (LETT |a|
                                           (SPADCALL |a|
                                                     (SPADCALL
                                                      (SPADCALL
                                                       (SPADCALL |q|
                                                                 (QREFELT $
                                                                          135))
                                                       |t1| (QREFELT $ 136))
                                                      |t2| (QREFELT $ 136))
                                                     (QREFELT $ 137))
                                           . #3#)
                                     (EXIT
                                      (LETT |q| (SPADCALL |q| (QREFELT $ 138))
                                            . #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 $ 89)) |lop| |lexp| |lfunc|
                (QREFELT $ 98)))))) 

(DEFUN |FS-;dispdiff| (|l| $)
  (PROG (|m| #1=#:G2021 |x| #2=#:G2020 |i| |rec| |a| |k| |t| |s|)
    (RETURN
     (SEQ
      (LETT |s| (SPADCALL (SPADCALL |l| (QREFELT $ 54)) (QREFELT $ 139))
            . #3=(|FS-;dispdiff|))
      (LETT |t| (SPADCALL (SPADCALL |l| (QREFELT $ 55)) (QREFELT $ 139)) . #3#)
      (LETT |a|
            (SPADCALL
             (LETT |k| (SPADCALL (|SPADfirst| |l|) (QREFELT $ 28)) . #3#)
             (QREFELT $ 46))
            . #3#)
      (EXIT
       (COND
        ((SPADCALL |k| (QREFELT $ 15) (QREFELT $ 140))
         (SEQ (LETT |rec| (|FS-;dispdiff| |a| $) . #3#)
              (LETT |i| (SPADCALL |s| (QVELT |rec| 2) (QREFELT $ 142)) . #3#)
              (SPADCALL (QVELT |rec| 2) |i| |t| (QREFELT $ 143))
              (EXIT
               (VECTOR (QVELT |rec| 0)
                       (SPADCALL (QVELT |rec| 1)
                                 (SPADCALL (SPADCALL '|,| (QREFELT $ 144))
                                           (SPADCALL
                                            (- (+ |i| 1)
                                               (SPADCALL |a| (QREFELT $ 147)))
                                            (QREFELT $ 148))
                                           (QREFELT $ 149))
                                 (QREFELT $ 149))
                       (QVELT |rec| 2) (QVELT |rec| 3)
                       (COND ((ZEROP (QVELT |rec| 4)) 0)
                             (#4='T (+ (QVELT |rec| 4) 1)))))))
        (#4#
         (SEQ
          (LETT |i|
                (SPADCALL (SPADCALL |l| (QREFELT $ 54)) |a| (QREFELT $ 150))
                . #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 $ 139)) #2#)
                              . #3#)))
                      (LETT #1# (CDR #1#) . #3#) (GO G190) G191
                      (EXIT (NREVERSE0 #2#))))
                . #3#)
          (SPADCALL |m| |i| |t| (QREFELT $ 143))
          (EXIT
           (VECTOR
            (SPADCALL (SPADCALL (SPADCALL |k| (QREFELT $ 44)) (QREFELT $ 48))
                      (QREFELT $ 144))
            (SPADCALL (SPADCALL '|,| (QREFELT $ 144))
                      (SPADCALL (- (+ |i| 1) (SPADCALL |a| (QREFELT $ 147)))
                                (QREFELT $ 148))
                      (QREFELT $ 149))
            |m| (SPADCALL |k| (QREFELT $ 44))
            (COND ((NULL (CDR |a|)) 1) (#4# 0)))))))))))) 

(DEFUN |FS-;ddiff| (|l| $)
  (PROG (|f| |opname| |rec|)
    (RETURN
     (SEQ (LETT |rec| (|FS-;dispdiff| |l| $) . #1=(|FS-;ddiff|))
          (LETT |opname|
                (COND
                 ((ZEROP (QVELT |rec| 4))
                  (SPADCALL (QVELT |rec| 0) (QVELT |rec| 1) (QREFELT $ 151)))
                 (#2='T
                  (SPADCALL (QVELT |rec| 0) (QVELT |rec| 4) (QREFELT $ 152))))
                . #1#)
          (LETT |f| (SPADCALL (QVELT |rec| 3) '|%diffDisp| (QREFELT $ 154))
                . #1#)
          (EXIT
           (COND
            ((QEQCAR |f| 0)
             (SPADCALL (CONS |opname| (QVELT |rec| 2)) (QCDR |f|)))
            (#2# (SPADCALL |opname| (QVELT |rec| 2) (QREFELT $ 155))))))))) 

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

(DEFUN |FS-;diffdiff| (|l| |x| $)
  (PROG (|f|)
    (RETURN
     (SEQ
      (LETT |f| (SPADCALL (QREFELT $ 15) |l| (QREFELT $ 47)) |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=#:G2046 |i| #2=#:G2047 |b| |arg| |u| |gg| |op| |k|)
    (RETURN
     (SEQ
      (LETT |op|
            (SPADCALL
             (LETT |k| (SPADCALL (|SPADfirst| |l|) (QREFELT $ 28))
                   . #3=(|FS-;diffdiff0|))
             (QREFELT $ 44))
            . #3#)
      (LETT |gg| (SPADCALL |l| (QREFELT $ 54)) . #3#)
      (LETT |u| (SPADCALL |l| (QREFELT $ 55)) . #3#)
      (LETT |arg| (SPADCALL |k| (QREFELT $ 46)) . #3#)
      (LETT |ans| (|spadConstant| $ 126) . #3#)
      (COND
       ((NULL (SPADCALL |u| |done| (QREFELT $ 158)))
        (SEQ (LETT |ans| (SPADCALL |u| |x| (QREFELT $ 159)) . #3#)
             (EXIT
              (COND
               ((NULL (SPADCALL |ans| (|spadConstant| $ 126) (QREFELT $ 160)))
                (LETT |ans|
                      (SPADCALL |ans|
                                (SPADCALL (QREFELT $ 15)
                                          (LIST
                                           (SPADCALL |expr| (LIST |kd|)
                                                     (LIST
                                                      (SPADCALL (QREFELT $ 15)
                                                                (LIST
                                                                 (|SPADfirst|
                                                                  |l|)
                                                                 |gg| |gg|)
                                                                (QREFELT $
                                                                         47)))
                                                     (QREFELT $ 161))
                                           |gg| |u|)
                                          (QREFELT $ 47))
                                (QREFELT $ 136))
                      . #3#)))))))
      (LETT |done| (CONS |gg| |done|) . #3#)
      (EXIT
       (COND
        ((SPADCALL |k| (QREFELT $ 15) (QREFELT $ 140))
         (SPADCALL |ans| (|FS-;diffdiff0| |arg| |x| |expr| |k| |done| $)
                   (QREFELT $ 137)))
        ('T
         (SEQ
          (SEQ (LETT |b| NIL . #3#) (LETT #2# |arg| . #3#)
               (LETT |i| (SPADCALL |arg| (QREFELT $ 147)) . #3#)
               (LETT #1# (SPADCALL |arg| (QREFELT $ 162)) . #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 $ 158)))
                   (SEQ (LETT |bp| (SPADCALL |b| |x| (QREFELT $ 159)) . #3#)
                        (EXIT
                         (COND
                          ((NULL
                            (SPADCALL |bp| (|spadConstant| $ 126)
                                      (QREFELT $ 160)))
                           (SEQ
                            (LETT |g|
                                  (SPADCALL (|FS-;symsub| (QREFELT $ 82) |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 $
                                                                              47)))
                                                                   (QREFELT $
                                                                            161))
                                                                  |g| |b|)
                                                                 (QREFELT $
                                                                          47))
                                                       (QREFELT $ 136))
                                             (QREFELT $ 137))
                                   . #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=#:G2049)
    (RETURN
     (SPADCALL
      (SPADCALL (|SPADfirst| |l|)
                (PROG2
                    (LETT #1# (SPADCALL |g| (QREFELT $ 30)) |FS-;dfeval|)
                    (QCDR #1#)
                  (|check-union| (QEQCAR #1# 0) (|Symbol|) #1#))
                (QREFELT $ 159))
      |g| (SPADCALL |l| (QREFELT $ 55)) (QREFELT $ 56))))) 

(DEFUN |FS-;diffEval| (|l| $)
  (PROG (|d| |n| |nl| |ss| |dumm| |ud| |op| #1=#:G2080 |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 $ 80)) . #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 $ 44)) . #2#)
        (LETT |ud| (SPADCALL |op| (QREFELT $ 165)) . #2#)
        (EXIT
         (COND
          ((QEQCAR |ud| 1)
           (SEQ
            (LETT |dumm|
                  (SPADCALL (|FS-;symsub| (QREFELT $ 82) 1 $) (QREFELT $ 38))
                  . #2#)
            (LETT |ss|
                  (SPADCALL (SPADCALL |l| 1 (QREFELT $ 166))
                            (SPADCALL (SPADCALL |l| 2 (QREFELT $ 166)) |dumm|
                                      (QREFELT $ 168))
                            (QREFELT $ 170))
                  . #2#)
            (LETT |nl| (LIST |ss| |dumm| (SPADCALL |l| 3 (QREFELT $ 166)))
                  . #2#)
            (EXIT (SPADCALL (QREFELT $ 15) |nl| (QREFELT $ 47)))))
          ((<
            (LETT |n|
                  (SPADCALL (SPADCALL |l| (QREFELT $ 54))
                            (SPADCALL |k| (QREFELT $ 46)) (QREFELT $ 150))
                  . #2#)
            (SPADCALL |l| (QREFELT $ 147)))
           (|FS-;dfeval| |l| |g| $))
          ('T
           (SEQ (LETT |d| (QCDR |ud|) . #2#)
                (EXIT
                 (SPADCALL
                  (SPADCALL (SPADCALL |k| (QREFELT $ 46))
                            (SPADCALL |d| |n| (QREFELT $ 129)))
                  |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 $ 147)))
            . #1=(|FS-;diffArg|))
      (LETT |z| (SPADCALL |l| (QREFELT $ 156)) . #1#)
      (SPADCALL |z| |n|
                (LETT |g|
                      (SPADCALL (|FS-;symsub| (QREFELT $ 82) |n| $)
                                (QREFELT $ 38))
                      . #1#)
                (QREFELT $ 157))
      (EXIT
       (LIST (SPADCALL |op| |z| (QREFELT $ 47)) |g|
             (SPADCALL |l| |n| (QREFELT $ 166)))))))) 

(DEFUN |FS-;opderiv| (|op| |n| $)
  (PROG (|i| #1=#:G2091 |g|)
    (RETURN
     (SEQ
      (COND
       ((EQL |n| 1)
        (SEQ
         (LETT |g|
               (SPADCALL (|FS-;symsub| (QREFELT $ 82) |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 $ 47)))))) 

(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 $ 171)) |g|
                      (SPADCALL |x| (QREFELT $ 94)))
                (QREFELT $ 47)))))) 

(DEFUN |FS-;kderiv| (|k| $)
  (PROG (#1=#:G2103 |g| #2=#:G2102 |grad| |u| |op| |n| |args|)
    (RETURN
     (SEQ
      (COND
       ((ZEROP
         (LETT |n|
               (LENGTH
                (LETT |args| (SPADCALL |k| (QREFELT $ 46))
                      . #3=(|FS-;kderiv|)))
               . #3#))
        NIL)
       (#4='T
        (SEQ (LETT |op| (SPADCALL |k| (QREFELT $ 44)) . #3#)
             (LETT |grad|
                   (SEQ (LETT |u| (SPADCALL |op| (QREFELT $ 165)) . #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=#:G2113 #2=#:G2112 #3=#:G2114 #4=#:G2118 |g| #5=#:G2119 |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| $ 145))
                   (#7='T (|spadConstant| $ 126))))
            (#7#
             (SEQ
              (LETT |fn|
                    (SPADCALL (SPADCALL |k| (QREFELT $ 44)) (QREFELT $ 10)
                              (QREFELT $ 154))
                    . #6#)
              (EXIT
               (COND
                ((QEQCAR |fn| 0)
                 (SPADCALL (SPADCALL |k| (QREFELT $ 46)) |x| (QCDR |fn|)))
                (#7#
                 (PROGN
                  (LETT #1# NIL . #6#)
                  (SEQ (LETT |y| NIL . #6#)
                       (LETT #5# (SPADCALL |k| (QREFELT $ 46)) . #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 $ 159))
                                          (QREFELT $ 136))
                                . #6#)
                          (COND
                           (#1#
                            (LETT #2# (SPADCALL #2# #3# (QREFELT $ 137))
                                  . #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| $ 126))))))))))))))) 

(DEFUN |FS-;smpderiv| (|p| |x| $)
  (PROG (#1=#:G2143 #2=#:G2142 #3=#:G2144 #4=#:G2146 |k|)
    (RETURN
     (SEQ
      (SPADCALL
       (SPADCALL
        (SPADCALL (CONS #'|FS-;smpderiv!0| (VECTOR |x| $)) |p| (QREFELT $ 177))
        (QREFELT $ 89))
       (PROGN
        (LETT #1# NIL . #5=(|FS-;smpderiv|))
        (SEQ (LETT |k| NIL . #5#)
             (LETT #4# (SPADCALL |p| (QREFELT $ 179)) . #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 $ 180))
                                 (QREFELT $ 89))
                       (|FS-;kerderiv| |k| |x| $) (QREFELT $ 136))
                      . #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| $ 126))))
       (QREFELT $ 137)))))) 

(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 $ 173)) |x| (QREFELT $ 174))
                (QREFELT $ 175)))))) 

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

(DEFUN |FS-;worse?| (|k1| |k2| $)
  (PROG (|u|)
    (RETURN
     (SEQ
      (LETT |u|
            (SPADCALL (SPADCALL (SPADCALL |k1| (QREFELT $ 44)) (QREFELT $ 48))
                      (SPADCALL (SPADCALL |k2| (QREFELT $ 44)) (QREFELT $ 48))
                      (QREFELT $ 189))
            |FS-;worse?|)
      (EXIT
       (COND ((QEQCAR |u| 1) (SPADCALL |k1| |k2| (QREFELT $ 190)))
             ('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=#:G2165 |r|)
    (RETURN
     (SEQ (LETT |r| (SPADCALL |p| (QREFELT $ 191)) . #2=(|FS-;smp2O|))
          (EXIT
           (COND ((QEQCAR |r| 0) (SPADCALL (QCDR |r|) (QREFELT $ 192)))
                 (#3='T
                  (SEQ
                   (LETT |a|
                         (COND
                          ((SPADCALL (QREFELT $ 193))
                           (|FS-;bestKernel| (SPADCALL |p| (QREFELT $ 179)) $))
                          (#3#
                           (PROG2
                               (LETT #1# (SPADCALL |p| (QREFELT $ 114)) . #2#)
                               (QCDR #1#)
                             (|check-union| (QEQCAR #1# 0)
                                            (|Kernel| (QREFELT $ 6)) #1#))))
                         . #2#)
                   (EXIT
                    (SPADCALL
                     (SPADCALL (ELT $ 89) (SPADCALL |p| |a| (QREFELT $ 116))
                               (QREFELT $ 121))
                     (SPADCALL |a| (QREFELT $ 194)) (QREFELT $ 195))))))))))) 

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

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

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

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

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

(DEFUN |FS-;notfound| (|fn| |lk| $)
  (PROG () (RETURN (CONS #'|FS-;notfound!0| (VECTOR |fn| |lk| $))))) 

(DEFUN |FS-;notfound!0| (|k| $$)
  (PROG ($ |lk| |fn|)
    (LETT $ (QREFELT $$ 2) . #1=(|FS-;notfound|))
    (LETT |lk| (QREFELT $$ 1) . #1#)
    (LETT |fn| (QREFELT $$ 0) . #1#)
    (RETURN
     (PROGN
      (PROG (|f|)
        (RETURN
         (COND
          ((SPADCALL
            (SPADCALL
             (SPADCALL (LETT |f| (SPADCALL |k| (QREFELT $ 26)) NIL)
                       (QREFELT $ 77))
             |lk| (QREFELT $ 203))
            (QREFELT $ 204))
           |f|)
          ('T (SPADCALL |k| |fn|))))))))) 

(DEFUN |FS-;pushunq| (|l| |arg| $)
  (PROG (#1=#:G2223 |a| #2=#:G2222 #3=#:G2221 #4=#:G2220)
    (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 $ 62)) #2#) . #5#)))
              (LETT #1# (CDR #1#) . #5#) #7# G191 (EXIT (NREVERSE0 #2#)))))))))) 

(DEFUN |FS-;kunq| (|k| |l| |givenlist?| $)
  (PROG (#1=#:G2263 |a| #2=#:G2262 |s|)
    (RETURN
     (SEQ
      (COND
       (|givenlist?| (COND ((NULL |l|) (EXIT (SPADCALL |k| (QREFELT $ 26)))))))
      (COND
       ((SPADCALL |k| (QREFELT $ 16) (QREFELT $ 140))
        (COND
         ((OR
           (SPADCALL
            (LETT |s|
                  (SPADCALL (|SPADfirst| (SPADCALL |k| (QREFELT $ 46)))
                            (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 $ 46))) $)
                               . #3#)
                         G190
                         (COND
                          ((OR (ATOM #1#)
                               (PROGN (LETT |a| (CAR #1#) . #3#) NIL))
                           (GO G191)))
                         (SEQ
                          (EXIT
                           (LETT #2# (CONS (SPADCALL |a| (QREFELT $ 60)) #2#)
                                 . #3#)))
                         (LETT #1# (CDR #1#) . #3#) (GO G190) G191
                         (EXIT (NREVERSE0 #2#)))))
             (QREFELT $ 59))
            (QREFELT $ 209)))))))
      (EXIT
       (SPADCALL (SPADCALL |k| (QREFELT $ 44))
                 (|FS-;pushunq| |l| (SPADCALL |k| (QREFELT $ 46)) $)
                 (QREFELT $ 39))))))) 

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

(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=#:G2272 #2=#:G2271 #3=#:G2273 #4=#:G2282 |k|)
    (RETURN
     (SEQ
      (COND
       ((PROGN
         (LETT #1# NIL . #5=(|FS-;smpret|))
         (SEQ (LETT |k| NIL . #5#)
              (LETT #4# (SPADCALL |p| (QREFELT $ 179)) . #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 $ 173) |p|
                        (QREFELT $ 214))))))))) 

(DEFUN |FS-;smpret!0| (|x| $)
  (PROG (#1=#:G2275)
    (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 $ 140))
                         (COND
                          ((EQL (LENGTH (SPADCALL |v| (QREFELT $ 46))) 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 $ 46))) 1)
                           (EXIT |u|)))))
                       (EXIT (CONS 1 "failed")))))))))) 

(DEFUN |FS-;smpIsMult| (|p| $)
  (PROG (#1=#:G2326 |n| |r| |q| |u|)
    (RETURN
     (SEQ
      (EXIT
       (SEQ
        (SEQ (LETT |u| (SPADCALL |p| (QREFELT $ 114)) . #2=(|FS-;smpIsMult|))
             (EXIT
              (COND
               ((QEQCAR |u| 0)
                (COND
                 ((EQL
                   (SPADCALL
                    (LETT |q| (SPADCALL |p| (QCDR |u|) (QREFELT $ 116)) . #2#)
                    (QREFELT $ 221))
                   1)
                  (COND
                   ((SPADCALL
                     (SPADCALL (SPADCALL |q| (QREFELT $ 222)) (QREFELT $ 223))
                     (QREFELT $ 224))
                    (SEQ
                     (LETT |r|
                           (SPADCALL (SPADCALL |q| (QREFELT $ 223))
                                     (QREFELT $ 191))
                           . #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 $ 46)) . #1=(|FS-;equaldiff|))
          (LETT |a2| (SPADCALL |k2| (QREFELT $ 46)) . #1#)
          (LETT |res|
                (SPADCALL (SPADCALL |k1| (QREFELT $ 44))
                          (SPADCALL |k2| (QREFELT $ 44)) (QREFELT $ 228))
                . #1#)
          (EXIT
           (COND
            (|res|
             (SEQ
              (LETT |res|
                    (SPADCALL (SPADCALL |a1| 3 (QREFELT $ 166))
                              (SPADCALL |a2| 3 (QREFELT $ 166))
                              (QREFELT $ 160))
                    . #1#)
              (EXIT
               (COND
                (|res|
                 (SEQ
                  (LETT |res|
                        (COND
                         ((SPADCALL (SPADCALL |a1| 1 (QREFELT $ 166))
                                    (SPADCALL |a2| 1 (QREFELT $ 166))
                                    (QREFELT $ 160))
                          (SPADCALL (SPADCALL |a1| 2 (QREFELT $ 166))
                                    (SPADCALL |a2| 2 (QREFELT $ 166))
                                    (QREFELT $ 160)))
                         (#2='T 'NIL))
                        . #1#)
                  (EXIT
                   (COND (|res| (|FS-;debugA| |a1| |a2| |res| $))
                         ((SPADCALL
                           (SPADCALL (SPADCALL |a1| 1 (QREFELT $ 166))
                                     (LIST
                                      (SPADCALL
                                       (SPADCALL |a1| 2 (QREFELT $ 166))
                                       (QREFELT $ 28)))
                                     (LIST (SPADCALL |a2| 2 (QREFELT $ 166)))
                                     (QREFELT $ 161))
                           (SPADCALL |a2| 1 (QREFELT $ 166)) (QREFELT $ 160))
                          (|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 $ 114))) 

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

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

(DEFUN |FS-;retract;SP;62| (|x| $)
  (PROG (#1=#:G2353)
    (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 $ 231)))) 

(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=#:G2387 |p| #2=#:G2386 |u|)
    (RETURN
     (SEQ
      (LETT |u| (SPADCALL (SPADCALL |x| (QREFELT $ 92)) (QREFELT $ 245))
            . #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 $ 89)) #2#)
                                  . #3#)))
                          (LETT #1# (CDR #1#) . #3#) (GO G190) G191
                          (EXIT (NREVERSE0 #2#)))))))))))) 

(DEFUN |FS-;isTimes;SU;73| (|x| $)
  (PROG (#1=#:G2398 |p| #2=#:G2397 |u|)
    (RETURN
     (SEQ
      (LETT |u| (SPADCALL (SPADCALL |x| (QREFELT $ 92)) (QREFELT $ 247))
            . #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 $ 89)) #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 $ 251))
            . #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 $ 251))
            . #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 $ 257))) 

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

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

(DEFUN |FS-;*;R2S;79| (|r| |x| $)
  (SPADCALL (SPADCALL (SPADCALL |r| (QREFELT $ 265)) (QREFELT $ 89)) |x|
            (QREFELT $ 136))) 

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

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

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

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

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

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

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

(DEFUN |FS-;denominator;2S;87| (|x| $)
  (SPADCALL (SPADCALL |x| (QREFELT $ 283)) (QREFELT $ 89))) 

(DEFUN |FS-;coerce;FS;88| (|q| $)
  (SPADCALL (SPADCALL (SPADCALL |q| (QREFELT $ 286)) (QREFELT $ 265))
            (SPADCALL (SPADCALL |q| (QREFELT $ 287)) (QREFELT $ 265))
            (QREFELT $ 288))) 

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

(DEFUN |FS-;coerce;FS;90| (|q| $)
  (SPADCALL (SPADCALL (SPADCALL |q| (QREFELT $ 298)) (QREFELT $ 299))
            (SPADCALL (SPADCALL |q| (QREFELT $ 300)) (QREFELT $ 299))
            (QREFELT $ 294))) 

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

(DEFUN |FS-;retract;SF;92| (|x| $)
  (PROG (#1=#:G2485)
    (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 $ 283)) $) . #2#)
          (QCDR #1#)
        (|check-union| (QEQCAR #1# 0) (|Polynomial| (QREFELT $ 7)) #1#))
      (QREFELT $ 304))))) 

(DEFUN |FS-;retract;SR;93| (|x| $)
  (PROG (#1=#:G2492)
    (RETURN
     (PROG2
         (LETT #1#
               (SPADCALL
                (SPADCALL (SPADCALL |x| (QREFELT $ 92)) (QREFELT $ 231))
                (SPADCALL (SPADCALL |x| (QREFELT $ 283)) (QREFELT $ 231))
                (QREFELT $ 307))
               |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 $ 283)) (|spadConstant| $ 308)
              (QREFELT $ 309))
    (|FS-;smp2O| (SPADCALL |x| (QREFELT $ 92)) $))
   ('T
    (SPADCALL (|FS-;smp2O| (SPADCALL |x| (QREFELT $ 92)) $)
              (|FS-;smp2O| (SPADCALL |x| (QREFELT $ 283)) $) (QREFELT $ 310))))) 

(DEFUN |FS-;retractIfCan;SU;95| (|x| $)
  (PROG (#1=#:G2503 |r| |d| |n|)
    (RETURN
     (SEQ
      (EXIT
       (SEQ
        (SEQ
         (LETT |n| (SPADCALL (SPADCALL |x| (QREFELT $ 92)) (QREFELT $ 191))
               . #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 $ 283)) (QREFELT $ 191))
                   . #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 $ 307))
                       . #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 $ 283)) |l| 'T $)
            (QREFELT $ 294))) 

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

(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 $ 283)) $)
            (QREFELT $ 294))) 

(DEFUN |FS-;differentiate;SSS;99| (|f| |x| $)
  (SPADCALL
   (SPADCALL
    (SPADCALL (|FS-;smpderiv| (SPADCALL |f| (QREFELT $ 92)) |x| $)
              (SPADCALL (SPADCALL |f| (QREFELT $ 283)) (QREFELT $ 89))
              (QREFELT $ 136))
    (SPADCALL (SPADCALL (SPADCALL |f| (QREFELT $ 92)) (QREFELT $ 89))
              (|FS-;smpderiv| (SPADCALL |f| (QREFELT $ 283)) |x| $)
              (QREFELT $ 136))
    (QREFELT $ 311))
   (SPADCALL (SPADCALL (SPADCALL |f| (QREFELT $ 283)) (QREFELT $ 89)) 2
             (QREFELT $ 312))
   (QREFELT $ 294))) 

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

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

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

(DEFUN |FS-;convert;FS;103| (|x| $)
  (PROG (#1=#:G2538 #2=#:G2537 #3=#:G2539 #4=#:G2541 |f|)
    (RETURN
     (SEQ
      (SPADCALL (|FS-;par| (SPADCALL |x| (QREFELT $ 315)) $)
                (PROGN
                 (LETT #1# NIL . #5=(|FS-;convert;FS;103|))
                 (SEQ (LETT |f| NIL . #5#)
                      (LETT #4# (SPADCALL |x| (QREFELT $ 318)) . #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 $ 312))
                               . #5#)
                         (COND
                          (#1#
                           (LETT #2# (SPADCALL #2# #3# (QREFELT $ 136)) . #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| $ 145))))
                (QREFELT $ 136)))))) 

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

(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 $ 283)) $) . #1#)
               (EXIT
                (COND ((QEQCAR |d| 1) (CONS 1 "failed"))
                      (#2#
                       (CONS 0
                             (SPADCALL (QCDR |n|) (QCDR |d|)
                                       (QREFELT $ 304)))))))))))))) 

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

(DEFUN |FS-;coerce;FS;107| (|x| $)
  (SPADCALL (SPADCALL (SPADCALL |x| (QREFELT $ 331)) (QREFELT $ 332))
            (SPADCALL (SPADCALL |x| (QREFELT $ 333)) (QREFELT $ 332))
            (QREFELT $ 288))) 

(DEFUN |FS-;isMult;SU;108| (|x| $)
  (PROG (|q| |r| #1=#:G2578 |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 $ 283)) (QREFELT $ 191))
                   . #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 $ 335)) . #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 $ 257))
            (SPADCALL (SPADCALL |x| (QREFELT $ 283)) (QREFELT $ 257))
            (QREFELT $ 336))) 

(DEFUN |FS-;convert;SP;110| (|x| $)
  (SPADCALL (SPADCALL (SPADCALL |x| (QREFELT $ 92)) (QREFELT $ 260))
            (SPADCALL (SPADCALL |x| (QREFELT $ 283)) (QREFELT $ 260))
            (QREFELT $ 337))) 

(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 341) . #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|)
      (SETF |pv$| (QREFELT $ 3))
      (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 $ 63 (CONS (|dispatchFunction| |FS-;eval;SSS;16|) $))
         (QSETREFV $ 66 (CONS (|dispatchFunction| |FS-;eval;SBoSSS;17|) $))
         (QSETREFV $ 73 (CONS (|dispatchFunction| |FS-;eval;SLLSS;18|) $))
         (SPADCALL (QREFELT $ 15) '|%specialInput|
                   (CONS (|function| |FS-;indiff|) $) (QREFELT $ 75)))))
      (COND
       ((|testBitVector| |pv$| 6)
        (PROGN
         (QSETREFV $ 82 '%%0)
         (QSETREFV $ 85
                   (CONS (|dispatchFunction| |FS-;characteristic;Nni;21|) $))
         (QSETREFV $ 90 (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 $ 111 (CONS (|dispatchFunction| |FS-;elt;BoLS;28|) $))
         (QSETREFV $ 112 (CONS (|dispatchFunction| |FS-;eval;SLLLS;29|) $))
         (QSETREFV $ 186 (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 $ 75))
         (SPADCALL (QREFELT $ 15) (QREFELT $ 10)
                   (CONS (|function| |FS-;diffdiff|) $) (QREFELT $ 75))
         (SPADCALL (QREFELT $ 15) '|%specialDisp|
                   (CONS (|function| |FS-;ddiff|) $) (QREFELT $ 75))
         (COND ((|testBitVector| |pv$| 2))
               ('T
                (PROGN
                 (QSETREFV $ 229
                           (CONS (|dispatchFunction| |FS-;mainKernel;SU;59|)
                                 $))
                 (QSETREFV $ 230
                           (CONS (|dispatchFunction| |FS-;kernels;SL;60|) $))
                 (QSETREFV $ 232
                           (CONS (|dispatchFunction| |FS-;retract;SR;61|) $))
                 (QSETREFV $ 233
                           (CONS (|dispatchFunction| |FS-;retract;SP;62|) $))
                 (QSETREFV $ 234
                           (CONS (|dispatchFunction| |FS-;retractIfCan;SU;63|)
                                 $))
                 (QSETREFV $ 236
                           (CONS (|dispatchFunction| |FS-;retractIfCan;SU;64|)
                                 $))
                 (QSETREFV $ 237
                           (CONS (|dispatchFunction| |FS-;eval;SLLS;65|) $))
                 (QSETREFV $ 238
                           (CONS (|dispatchFunction| |FS-;subst;SLLS;66|) $))
                 (QSETREFV $ 239
                           (CONS
                            (|dispatchFunction| |FS-;differentiate;SSS;67|) $))
                 (QSETREFV $ 240
                           (CONS (|dispatchFunction| |FS-;coerce;SOf;68|) $))
                 (COND
                  ((|testBitVector| |pv$| 11)
                   (PROGN
                    (QSETREFV $ 241
                              (CONS (|dispatchFunction| |FS-;eval;SLS;69|) $))
                    (QSETREFV $ 242
                              (CONS (|dispatchFunction| |FS-;eval;2S;70|)
                                    $)))))
                 (QSETREFV $ 243
                           (CONS (|dispatchFunction| |FS-;eval;SLLLS;71|) $))
                 (QSETREFV $ 246
                           (CONS (|dispatchFunction| |FS-;isPlus;SU;72|) $))
                 (QSETREFV $ 248
                           (CONS (|dispatchFunction| |FS-;isTimes;SU;73|) $))
                 (QSETREFV $ 252
                           (CONS (|dispatchFunction| |FS-;isExpt;SU;74|) $))
                 (QSETREFV $ 255
                           (CONS (|dispatchFunction| |FS-;isPower;SU;75|) $))
                 (COND
                  ((|HasCategory| |#2|
                                  '(|ConvertibleTo| (|Pattern| (|Integer|))))
                   (QSETREFV $ 258
                             (CONS (|dispatchFunction| |FS-;convert;SP;76|)
                                   $))))
                 (COND
                  ((|HasCategory| |#2|
                                  '(|ConvertibleTo| (|Pattern| (|Float|))))
                   (QSETREFV $ 261
                             (CONS (|dispatchFunction| |FS-;convert;SP;77|)
                                   $))))
                 (COND
                  ((|testBitVector| |pv$| 1)
                   (QSETREFV $ 264
                             (CONS (|dispatchFunction| |FS-;isMult;SU;78|)
                                   $))))))))))
      (COND
       ((|testBitVector| |pv$| 3)
        (QSETREFV $ 266 (CONS (|dispatchFunction| |FS-;*;R2S;79|) $))))
      (COND
       ((|testBitVector| |pv$| 2)
        (PROGN
         (QSETREFV $ 229 (CONS (|dispatchFunction| |FS-;mainKernel;SU;80|) $))
         (QSETREFV $ 230 (CONS (|dispatchFunction| |FS-;kernels;SL;81|) $))
         (QSETREFV $ 273 (CONS (|dispatchFunction| |FS-;univariate;SKF;82|) $))
         (QSETREFV $ 246 (CONS (|dispatchFunction| |FS-;isPlus;SU;83|) $))
         (QSETREFV $ 248 (CONS (|dispatchFunction| |FS-;isTimes;SU;84|) $))
         (QSETREFV $ 252 (CONS (|dispatchFunction| |FS-;isExpt;SU;85|) $))
         (QSETREFV $ 255 (CONS (|dispatchFunction| |FS-;isPower;SU;86|) $))
         (QSETREFV $ 284 (CONS (|dispatchFunction| |FS-;denominator;2S;87|) $))
         (QSETREFV $ 289 (CONS (|dispatchFunction| |FS-;coerce;FS;88|) $))
         (QSETREFV $ 295 (CONS (|dispatchFunction| |FS-;coerce;FS;89|) $))
         (QSETREFV $ 301 (CONS (|dispatchFunction| |FS-;coerce;FS;90|) $))
         (QSETREFV $ 233 (CONS (|dispatchFunction| |FS-;retract;SP;91|) $))
         (QSETREFV $ 305 (CONS (|dispatchFunction| |FS-;retract;SF;92|) $))
         (QSETREFV $ 232 (CONS (|dispatchFunction| |FS-;retract;SR;93|) $))
         (QSETREFV $ 240 (CONS (|dispatchFunction| |FS-;coerce;SOf;94|) $))
         (QSETREFV $ 234
                   (CONS (|dispatchFunction| |FS-;retractIfCan;SU;95|) $))
         (QSETREFV $ 241 (CONS (|dispatchFunction| |FS-;eval;SLS;96|) $))
         (COND
          ((|testBitVector| |pv$| 11)
           (PROGN
            (QSETREFV $ 242 (CONS (|dispatchFunction| |FS-;eval;2S;97|) $))
            (QSETREFV $ 243
                      (CONS (|dispatchFunction| |FS-;eval;SLLLS;98|) $)))))
         (QSETREFV $ 239
                   (CONS (|dispatchFunction| |FS-;differentiate;SSS;99|) $))
         (QSETREFV $ 237 (CONS (|dispatchFunction| |FS-;eval;SLLS;100|) $))
         (QSETREFV $ 238 (CONS (|dispatchFunction| |FS-;subst;SLLS;101|) $))
         (QSETREFV $ 320 (CONS (|dispatchFunction| |FS-;convert;FS;103|) $))
         (QSETREFV $ 236
                   (CONS (|dispatchFunction| |FS-;retractIfCan;SU;104|) $))
         (QSETREFV $ 324
                   (CONS (|dispatchFunction| |FS-;retractIfCan;SU;105|) $))
         (QSETREFV $ 329 (CONS (|dispatchFunction| |FS-;coerce;PS;106|) $))
         (COND
          ((|testBitVector| |pv$| 1)
           (PROGN
            (QSETREFV $ 334 (CONS (|dispatchFunction| |FS-;coerce;FS;107|) $))
            (QSETREFV $ 264
                      (CONS (|dispatchFunction| |FS-;isMult;SU;108|) $)))))
         (COND
          ((|HasCategory| |#2| '(|ConvertibleTo| (|Pattern| (|Integer|))))
           (QSETREFV $ 258
                     (CONS (|dispatchFunction| |FS-;convert;SP;109|) $))))
         (COND
          ((|HasCategory| |#2| '(|ConvertibleTo| (|Pattern| (|Float|))))
           (QSETREFV $ 261
                     (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 . |has?|) (58 . |is?|)
              |FS-;belong?;BoB;10| (64 . |operator|) (|List| 6)
              (69 . |argument|) (74 . |kernel|) (80 . |name|) (|String|)
              (85 . |string|) (|OutputForm|) (90 . |coerce|)
              |FS-;operator;2Bo;12| (95 . |second|) (100 . |third|)
              (105 . |eval|) (|InputForm|) (112 . |convert|) (117 . |convert|)
              (122 . |convert|) (|List| 12) (127 . |eval|) (133 . |eval|)
              (|List| 11) (139 . |eval|) (147 . |eval|) (|Mapping| 6 6)
              (|MakeUnaryCompiledFunction| 6 6 6) (155 . |compiledFunction|)
              (|Mapping| $ $) (|List| 70) (161 . |eval|) (168 . |eval|)
              (|None|) (176 . |setProperty|) (|List| 25) (183 . |tower|)
              |FS-;variables;SL;19| (|Union| 25 '#1#) (188 . |retractIfCan|)
              |FS-;retractIfCan;SU;20| '|gendiff| (|NonNegativeInteger|)
              (193 . |characteristic|) (197 . |characteristic|)
              (|SparseMultivariatePolynomial| 7 23) (201 . |coerce|)
              (|SparseMultivariatePolynomial| 7 25) (206 . |coerce|)
              (211 . |coerce|) (216 . |coerce|) (221 . |numer|)
              (226 . |numerator|) (231 . |first|) (|List| 83) (|Mapping| $ 32)
              (|List| 96) (236 . |eval|) (244 . |eval|) (252 . |eval|)
              (260 . |new|) (266 . |eval|) (273 . |unary?|)
              (278 . |leadingCoefficient|) (283 . |Zero|) (287 . |smaller?|)
              (293 . -) (298 . |elt|) (|ExpressionSpace&| 6) (304 . |elt|)
              (310 . |elt|) (316 . |eval|) (|Union| 23 '#2="failed")
              (324 . |mainVariable|) (|SparseUnivariatePolynomial| $)
              (329 . |univariate|) (|SparseUnivariatePolynomial| 6)
              (|Mapping| 6 86) (|SparseUnivariatePolynomial| 86)
              (|SparseUnivariatePolynomialFunctions2| 86 6) (335 . |map|)
              (|Integer|) (341 . |position|) (347 . |minIndex|) (352 . |elt|)
              (358 . |Zero|) (|Mapping| 6 45) (|List| 127) (362 . |elt|)
              (368 . |elt|) (374 . |Zero|) (378 . =) (384 . |degree|) (389 . ^)
              (395 . |leadingCoefficient|) (400 . *) (406 . +)
              (412 . |reductum|) (417 . |coerce|) (422 . |is?|) (|List| 51)
              (428 . |position|) (434 . |setelt|) (441 . |coerce|)
              (446 . |One|) (450 . |One|) (454 . |minIndex|) (459 . |coerce|)
              (464 . |hconcat|) (470 . |position|) (476 . |sub|)
              (482 . |differentiate|) (|Union| 74 '"failed") (488 . |property|)
              (494 . |prefix|) (500 . |copy|) (505 . |setelt|)
              (512 . |member?|) (518 . |differentiate|) (524 . =)
              (530 . |subst|) (537 . |maxIndex|) (|Union| 128 '"failed")
              (|BasicOperatorFunctions1| 6) (542 . |derivative|) (547 . |elt|)
              (|Equation| 6) (553 . =) (|Equation| $) (559 . |subst|)
              (565 . |kernel|) (|Polynomial| 7) (571 . |coerce|)
              (576 . |differentiate|) (582 . |retract|) (|Mapping| 7 7)
              (587 . |map|) (|List| 23) (593 . |variables|)
              (598 . |differentiate|) (604 . |coerce|) (|Mapping| 6 12)
              (|Mapping| 6 7)
              (|PolynomialCategoryLifting| (|IndexedExponents| 12) 12 7 172 6)
              (609 . |map|) (616 . |coerce|) (|Union| 19 '"failed")
              (|UserDefinedPartialOrdering| 12) (621 . |less?|) (627 . <)
              (633 . |retractIfCan|) (638 . |coerce|) (643 . |userOrdered?|)
              (647 . |coerce|) (652 . |outputForm|) (|Mapping| 6 23)
              (|ListToMap| 23 6) (658 . |match|)
              (|PolynomialCategoryLifting| (|IndexedExponents| 23) 23 7 86 6)
              (666 . |map|) (673 . |eval|) (680 . |map|)
              (686 . |setIntersection|) (692 . |empty?|) (697 . |eval|)
              (702 . |retract|) (707 . |member?|) (|InputFormFunctions1| 6)
              (713 . |interpret|) (718 . |coerce|) (|Mapping| 172 23)
              (|Mapping| 172 7)
              (|PolynomialCategoryLifting| (|IndexedExponents| 23) 23 7 86 172)
              (723 . |map|) (|Record| (|:| |var| 25) (|:| |exponent| 122))
              (|Union| 215 '"failed") (730 . |isExpt|) (735 . |isExpt|)
              (741 . |is?|) (747 . |isExpt|) (753 . |degree|)
              (758 . |reductum|) (763 . |leadingCoefficient|) (768 . |zero?|)
              (|Union| 122 '#1#) (773 . |retractIfCan|) (778 . |evaluate|)
              (784 . =) (790 . |mainKernel|) (795 . |kernels|)
              (800 . |retract|) (805 . |retract|) (810 . |retract|)
              (815 . |retractIfCan|) (|Union| 172 '"failed")
              (820 . |retractIfCan|) (825 . |eval|) (832 . |subst|)
              (839 . |differentiate|) (845 . |coerce|) (850 . |eval|)
              (856 . |eval|) (861 . |eval|) (|Union| 32 '#2#) (869 . |isPlus|)
              (874 . |isPlus|) (879 . |isTimes|) (884 . |isTimes|)
              (|Record| (|:| |var| 23) (|:| |exponent| 83)) (|Union| 249 '#2#)
              (889 . |isExpt|) (894 . |isExpt|)
              (|Record| (|:| |val| $) (|:| |exponent| 122))
              (|Union| 253 '"failed") (899 . |isPower|) (|Pattern| 122)
              (904 . |convert|) (909 . |convert|) (|Pattern| (|Float|))
              (914 . |convert|) (919 . |convert|)
              (|Record| (|:| |coef| 122) (|:| |var| 25))
              (|Union| 262 '"failed") (924 . |isMult|) (929 . |coerce|)
              (934 . *)
              (|PolynomialCategoryQuotientFunctions| (|IndexedExponents| 23) 23
                                                     7 86 6)
              (940 . |mainVariable|) (945 . |variables|) (|Fraction| 117)
              (950 . |univariate|) (|Fraction| 115) (956 . |univariate|)
              (|Union| 45 '"failed") (962 . |isPlus|) (967 . |isTimes|)
              (|Record| (|:| |var| 23) (|:| |exponent| 122))
              (|Union| 277 '"failed") (972 . |isExpt|)
              (|Record| (|:| |val| 6) (|:| |exponent| 122))
              (|Union| 280 '"failed") (977 . |isPower|) (982 . |denom|)
              (987 . |denominator|) (|Fraction| 7) (992 . |numer|)
              (997 . |denom|) (1002 . /) (1008 . |coerce|) (|Fraction| 172)
              (1013 . |numer|) (1018 . |coerce|) (1023 . |denom|) (1028 . /)
              (1034 . |coerce|) (|Polynomial| 285) (|Fraction| 296)
              (1039 . |numer|) (1044 . |coerce|) (1049 . |denom|)
              (1054 . |coerce|) (1059 . |retract|) (1064 . |retract|)
              (1069 . /) (1075 . |retract|) (|Union| $ '"failed")
              (1080 . |exquo|) (1086 . |One|) (1090 . =) (1096 . /) (1102 . -)
              (1108 . ^) (1114 . |paren|) (|Factored| 6) (1119 . |unit|)
              (|Record| (|:| |factor| 6) (|:| |exponent| 122)) (|List| 316)
              (1124 . |factors|) (|Factored| $) (1129 . |convert|)
              (|Union| 290 '#1#) (1134 . |retractIfCan|)
              (1139 . |retractIfCan|) (1144 . |retractIfCan|) (1149 . |coerce|)
              (|Mapping| 6 285)
              (|PolynomialCategoryLifting| (|IndexedExponents| 12) 12 285 296
                                           6)
              (1154 . |map|) (1161 . |coerce|) (|Fraction| 122)
              (1166 . |numer|) (1171 . |coerce|) (1176 . |denom|)
              (1181 . |coerce|) (1186 . |exquo|) (1192 . /) (1198 . /)
              (|PositiveInteger|) (|Union| 330 '#1#) (|List| 169))
           '#(|variables| 1204 |univariate| 1209 |subst| 1215 |retractIfCan|
              1222 |retract| 1242 |operator| 1262 |numerator| 1267 |mainKernel|
              1272 |kernels| 1277 |isTimes| 1282 |isPower| 1287 |isPlus| 1292
              |isMult| 1297 |isExpt| 1302 |ground?| 1319 |ground| 1324 |eval|
              1329 |elt| 1408 |differentiate| 1414 |denominator| 1420 |convert|
              1425 |coerce| 1440 |characteristic| 1485 |belong?| 1489
              |applyQuote| 1494 * 1530)
           'NIL
           (CONS (|makeByteWordVec2| 1 'NIL)
                 (CONS '#()
                       (CONS '#()
                             (|makeByteWordVec2| 337
                                                 '(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
                                                   12 41 2 11 19 0 12 42 1 23
                                                   11 0 44 1 23 45 0 46 2 6 0
                                                   11 32 47 1 11 12 0 48 1 12
                                                   49 0 50 1 49 51 0 52 1 45 6
                                                   0 54 1 45 6 0 55 3 6 0 0 25
                                                   0 56 1 12 57 0 58 1 57 0 32
                                                   59 1 6 57 0 60 2 6 0 0 61 62
                                                   2 0 0 0 12 63 4 6 0 0 64 32
                                                   12 65 4 0 0 0 11 0 12 66 2
                                                   68 67 6 12 69 3 6 0 0 64 71
                                                   72 4 0 0 0 64 32 12 73 3 11
                                                   0 0 12 74 75 1 6 76 0 77 1 6
                                                   79 0 80 0 7 83 84 0 0 83 85
                                                   1 86 0 23 87 1 6 0 88 89 1 0
                                                   0 25 90 1 12 0 49 91 1 6 88
                                                   0 92 1 0 0 0 93 1 45 6 0 94
                                                   4 6 0 0 61 95 97 98 4 0 0 0
                                                   12 83 70 99 4 0 0 0 12 83 96
                                                   100 2 95 0 83 83 101 3 0 0 0
                                                   61 97 102 1 11 19 0 103 1 86
                                                   7 0 104 0 7 0 105 2 7 19 0 0
                                                   106 1 6 0 0 107 2 6 0 11 0
                                                   108 2 109 0 11 32 110 2 0 0
                                                   11 32 111 4 0 0 0 61 95 71
                                                   112 1 86 113 0 114 2 86 115
                                                   0 23 116 2 120 117 118 119
                                                   121 2 61 122 12 0 123 1 61
                                                   122 0 124 2 117 6 0 6 125 0
                                                   6 0 126 2 128 127 0 122 129
                                                   2 95 83 0 122 130 0 117 0
                                                   131 2 117 19 0 0 132 1 117
                                                   83 0 133 2 6 0 0 83 134 1
                                                   117 6 0 135 2 6 0 0 0 136 2
                                                   6 0 0 0 137 1 117 0 0 138 1
                                                   6 51 0 139 2 23 19 0 11 140
                                                   2 141 122 51 0 142 3 141 51
                                                   0 122 51 143 1 12 51 0 144 0
                                                   6 0 145 0 7 0 146 1 45 122 0
                                                   147 1 122 51 0 148 2 51 0 0
                                                   0 149 2 45 122 6 0 150 2 51
                                                   0 0 0 151 2 51 0 0 83 152 2
                                                   11 153 0 12 154 2 51 0 0 32
                                                   155 1 45 0 0 156 3 45 6 0
                                                   122 6 157 2 45 19 6 0 158 2
                                                   6 0 0 12 159 2 6 19 0 0 160
                                                   3 6 0 0 76 32 161 1 45 122 0
                                                   162 1 164 163 11 165 2 45 6
                                                   0 122 166 2 167 0 6 6 168 2
                                                   6 0 0 169 170 2 6 0 11 0 171
                                                   1 172 0 7 173 2 172 0 0 12
                                                   174 1 172 7 0 175 2 86 0 176
                                                   0 177 1 86 178 0 179 2 86 0
                                                   0 23 180 1 6 0 7 181 3 184 6
                                                   182 183 172 185 1 0 0 172
                                                   186 2 188 187 12 12 189 2 23
                                                   19 0 0 190 1 86 17 0 191 1 7
                                                   51 0 192 0 188 19 193 1 23
                                                   51 0 194 2 117 51 0 51 195 4
                                                   197 6 178 45 23 196 198 3
                                                   199 6 196 183 86 200 3 6 0 0
                                                   76 32 201 2 6 0 70 25 202 2
                                                   178 0 0 0 203 1 178 19 0 204
                                                   1 6 0 0 205 1 6 12 0 206 2
                                                   61 19 12 0 207 1 208 6 57
                                                   209 1 172 0 12 210 3 213 172
                                                   211 212 86 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
                                                   119 83 0 221 1 119 0 0 222 1
                                                   119 86 0 223 1 86 19 0 224 1
                                                   7 225 0 226 2 164 11 11 127
                                                   227 2 11 19 0 0 228 1 0 79 0
                                                   229 1 0 76 0 230 1 86 7 0
                                                   231 1 0 7 0 232 1 0 172 0
                                                   233 1 0 17 0 234 1 0 235 0
                                                   236 3 0 0 0 76 32 237 3 0 0
                                                   0 76 32 238 2 0 0 0 12 239 1
                                                   0 51 0 240 2 0 0 0 61 241 1
                                                   0 0 0 242 4 0 0 0 61 95 97
                                                   243 1 86 244 0 245 1 0 244 0
                                                   246 1 86 244 0 247 1 0 244 0
                                                   248 1 86 250 0 251 1 0 216 0
                                                   252 1 0 254 0 255 1 86 256 0
                                                   257 1 0 256 0 258 1 86 259 0
                                                   260 1 0 259 0 261 1 0 263 0
                                                   264 1 86 0 7 265 2 0 0 7 0
                                                   266 1 267 113 6 268 1 267
                                                   178 6 269 2 267 270 6 23 271
                                                   2 0 272 0 25 273 1 267 274 6
                                                   275 1 267 274 6 276 1 267
                                                   278 6 279 1 267 281 6 282 1
                                                   6 88 0 283 1 0 0 0 284 1 285
                                                   7 0 286 1 285 7 0 287 2 6 0
                                                   88 88 288 1 0 0 285 289 1
                                                   290 172 0 291 1 6 0 172 292
                                                   1 290 172 0 293 2 6 0 0 0
                                                   294 1 0 0 290 295 1 297 296
                                                   0 298 1 6 0 296 299 1 297
                                                   296 0 300 1 0 0 297 301 1 6
                                                   290 0 302 1 290 172 0 303 2
                                                   290 0 172 172 304 1 0 290 0
                                                   305 2 7 306 0 0 307 0 86 0
                                                   308 2 86 19 0 0 309 2 51 0 0
                                                   0 310 2 6 0 0 0 311 2 6 0 0
                                                   122 312 1 6 0 0 313 1 314 6
                                                   0 315 1 314 317 0 318 1 0 0
                                                   319 320 1 6 321 0 322 1 290
                                                   235 0 323 1 0 321 0 324 1 6
                                                   0 285 325 3 327 6 182 326
                                                   296 328 1 0 0 296 329 1 330
                                                   122 0 331 1 86 0 122 332 1
                                                   330 122 0 333 1 0 0 330 334
                                                   2 122 306 0 0 335 2 256 0 0
                                                   0 336 2 259 0 0 0 337 1 0 61
                                                   0 78 2 0 272 0 25 273 3 0 0
                                                   0 76 32 238 1 0 235 0 236 1
                                                   0 321 0 324 1 0 17 0 234 1 0
                                                   29 0 81 1 0 172 0 233 1 0
                                                   290 0 305 1 0 7 0 232 1 0 12
                                                   0 31 1 0 11 11 53 1 0 0 0 93
                                                   1 0 79 0 229 1 0 76 0 230 1
                                                   0 244 0 248 1 0 254 0 255 1
                                                   0 244 0 246 1 0 263 0 264 2
                                                   0 216 0 11 218 2 0 216 0 12
                                                   220 1 0 216 0 252 1 0 19 0
                                                   20 1 0 7 0 22 4 0 0 0 12 83
                                                   70 99 4 0 0 0 61 95 97 243 4
                                                   0 0 0 12 83 96 100 4 0 0 0
                                                   61 95 71 112 4 0 0 0 64 32
                                                   12 73 1 0 0 0 242 4 0 0 0 11
                                                   0 12 66 2 0 0 0 12 63 2 0 0
                                                   0 61 241 3 0 0 0 61 97 102 3
                                                   0 0 0 76 32 237 2 0 0 11 32
                                                   111 2 0 0 0 12 239 1 0 0 0
                                                   284 1 0 0 319 320 1 0 259 0
                                                   261 1 0 256 0 258 1 0 0 330
                                                   334 1 0 0 172 186 1 0 0 290
                                                   295 1 0 0 296 329 1 0 0 297
                                                   301 1 0 0 285 289 1 0 0 12
                                                   27 1 0 51 0 240 1 0 0 25 90
                                                   0 0 83 85 1 0 19 11 43 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
                                                   266)))))
           '|lookupComplete|)) 
