
(/VERSIONCHECK 2) 

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

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

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

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

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

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

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

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

(DEFUN |FS-;applyQuote;SLS;9| (|s| |l| $)
  (SPADCALL (QREFELT $ 18) (CONS (SPADCALL |s| (QREFELT $ 40)) |l|)
      (QREFELT $ 41))) 

(DEFUN |FS-;belong?;BoB;10| (|op| $)
  (COND
    ((SPADCALL |op| (QREFELT $ 17) (QREFELT $ 43)) 'T)
    ('T (SPADCALL |op| (QREFELT $ 18) (QREFELT $ 43))))) 

(DEFUN |FS-;subs| (|fn| |k| $)
  (PROG (#0=#:G1881 |x| #1=#:G1882)
    (RETURN
      (SEQ (SPADCALL (SPADCALL |k| (QREFELT $ 45))
               (PROGN
                 (LETT #0# NIL . #2=(|FS-;subs|))
                 (SEQ (LETT |x| NIL . #2#)
                      (LETT #1# (SPADCALL |k| (QREFELT $ 47)) . #2#)
                      G190
                      (COND
                        ((OR (ATOM #1#)
                             (PROGN (LETT |x| (CAR #1#) . #2#) NIL))
                         (GO G191)))
                      (SEQ (EXIT (LETT #0#
                                       (CONS (SPADCALL |x| |fn|) #0#) . #2#)))
                      (LETT #1# (CDR #1#) . #2#) (GO G190) G191
                      (EXIT (NREVERSE0 #0#))))
               (QREFELT $ 48)))))) 

(DEFUN |FS-;operator;2Bo;12| (|op| $)
  (COND
    ((SPADCALL |op| (SPADCALL "%diff" (QREFELT $ 10)) (QREFELT $ 49))
     (QREFELT $ 17))
    ((SPADCALL |op| (SPADCALL "%quote" (QREFELT $ 10)) (QREFELT $ 49))
     (QREFELT $ 18))
    ('T (|error| "Unknown operator")))) 

(DEFUN |FS-;differentiand| (|l| $)
  (SPADCALL (|SPADfirst| |l|)
      (SPADCALL (SPADCALL |l| (QREFELT $ 51)) (QREFELT $ 30))
      (SPADCALL |l| (QREFELT $ 52)) (QREFELT $ 53))) 

(DEFUN |FS-;pint| (|l| $)
  (SPADCALL
      (CONS (SPADCALL (SPADCALL "D" (QREFELT $ 10)) (QREFELT $ 55))
            |l|)
      (QREFELT $ 56))) 

(DEFUN |FS-;indiff| (|l| $)
  (PROG (|r2|)
    (RETURN
      (SEQ (LETT |r2|
                 (SPADCALL
                     (LIST (SPADCALL (SPADCALL "::" (QREFELT $ 10))
                               (QREFELT $ 55))
                           (SPADCALL (SPADCALL |l| (QREFELT $ 52))
                               (QREFELT $ 57))
                           (SPADCALL (SPADCALL "Symbol" (QREFELT $ 10))
                               (QREFELT $ 55)))
                     (QREFELT $ 56))
                 |FS-;indiff|)
           (EXIT (|FS-;pint| (LIST (SPADCALL
                                    (|FS-;differentiand| |l| $)
                                    (QREFELT $ 57))
                                   |r2|)
                             $)))))) 

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

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

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

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

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

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

(DEFUN |FS-;coerce;KS;22| (|k| $)
  (SPADCALL (SPADCALL |k| (QREFELT $ 84)) (QREFELT $ 86))) 

(DEFUN |FS-;symsub| (|sy| |i| $)
  (SPADCALL (STRCONC (SPADCALL |sy| (QREFELT $ 88)) (STRINGIMAGE |i|))
      (QREFELT $ 10))) 

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

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

(DEFUN |FS-;eval;SSNniMS;25!0| (|#1| $$)
  (SPADCALL (SPADCALL |#1| (QREFELT (QREFELT $$ 1) 91)) (QREFELT $$ 0))) 

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

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

(DEFUN |FS-;elt;BoLS;28| (|op| |args| $)
  (PROG (|od?| |x| #0=#:G1934)
    (RETURN
      (SEQ (EXIT (SEQ (COND
                        ((SPADCALL |op| (QREFELT $ 100))
                         (SEQ (LETT |od?|
                                    (SPADCALL |op| (QREFELT $ 11)
                                     (QREFELT $ 101))
                                    . #1=(|FS-;elt;BoLS;28|))
                              (EXIT (COND
                                      ((OR |od?|
                                        (SPADCALL |op| (QREFELT $ 12)
                                         (QREFELT $ 101)))
                                       (COND
                                         ((SPADCALL
                                           (SPADCALL
                                            (SPADCALL
                                             (|SPADfirst| |args|)
                                             (QREFELT $ 89))
                                            (QREFELT $ 102))
                                           (|spadConstant| $ 103)
                                           (QREFELT $ 104))
                                          (PROGN
                                            (LETT #0#
                                             (SEQ
                                              (LETT |x|
                                               (SPADCALL |op|
                                                (SPADCALL
                                                 (|SPADfirst| |args|)
                                                 (QREFELT $ 105))
                                                (QREFELT $ 106)) . #1#)
                                              (EXIT
                                               (COND
                                                 (|od?|
                                                  (SPADCALL |x|
                                                   (QREFELT $ 105)))
                                                 ('T |x|)))) . #1#)
                                            (GO #0#))))))))))
                      (EXIT (SPADCALL |op| |args| (QREFELT $ 108)))))
           #0# (EXIT #0#))))) 

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

(DEFUN |FS-;eval;SLLLS;29!0| (|#1| $$)
  (SPADCALL (SPADCALL |#1| (QREFELT (QREFELT $$ 1) 91)) (QREFELT $$ 0))) 

(DEFUN |FS-;smprep| (|lop| |lexp| |lfunc| |p| $)
  (PROG (|v| |k| |op| #0=#:G1959 #1=#:G1960 |arg| |g| |n| |f| |e| |m|
             |qr| |t1| |t2| |a| |q|)
    (RETURN
      (SEQ (LETT |v| (SPADCALL |p| (QREFELT $ 112))
                 . #2=(|FS-;smprep|))
           (EXIT (COND
                   ((QEQCAR |v| 1) (SPADCALL |p| (QREFELT $ 86)))
                   ('T
                    (SEQ (LETT |k| (QCDR |v|) . #2#)
                         (LETT |g|
                               (SPADCALL
                                   (LETT |op|
                                    (SPADCALL |k| (QREFELT $ 45)) . #2#)
                                   (LETT |arg|
                                    (PROGN
                                      (LETT #0# NIL . #2#)
                                      (SEQ (LETT |a| NIL . #2#)
                                       (LETT #1#
                                        (SPADCALL |k| (QREFELT $ 47)) . #2#)
                                       G190
                                       (COND
                                         ((OR (ATOM #1#)
                                           (PROGN
                                             (LETT |a| (CAR #1#) . #2#)
                                             NIL))
                                          #3=(GO G191)))
                                       (SEQ
                                        (EXIT
                                         (LETT #0#
                                          (CONS
                                           (SPADCALL |a| |lop| |lexp|
                                            |lfunc| (QREFELT $ 95))
                                           #0#) . #2#)))
                                       (LETT #1# (CDR #1#) . #2#)
                                       #4=(GO G190) G191
                                       (EXIT (NREVERSE0 #0#)))) . #2#)
                                   (QREFELT $ 41)) . #2#)
                         (LETT |q|
                               (SPADCALL
                                   (CONS #'|FS-;smprep!0|
                                    (VECTOR |lfunc| |lexp| |lop| $))
                                   (SPADCALL |p| |k| (QREFELT $ 114))
                                   (QREFELT $ 119)) . #2#)
                         (EXIT (COND
                                 ((< (LETT |n|
                                      (SPADCALL
                                       (SPADCALL |op| (QREFELT $ 120))
                                       |lop| (QREFELT $ 122)) . #2#)
                                     (SPADCALL |lop| (QREFELT $ 123)))
                                  (SPADCALL |q| |g| (QREFELT $ 124)))
                                 ('T
                                  (SEQ (LETT |a|
                                        (|spadConstant| $ 125) . #2#)
                                       (LETT |f|
                                        (SPADCALL
                                         (SPADCALL |arg|
                                          (SPADCALL |lfunc| |n|
                                           (QREFELT $ 128)))
                                         |lop| |lexp| |lfunc|
                                         (QREFELT $ 95)) . #2#)
                                       (LETT |e|
                                        (SPADCALL |lexp| |n|
                                         (QREFELT $ 129)) . #2#)
                                       (SEQ G190
                                        (COND
                                          ((NULL
                                            (COND
                                              ((SPADCALL |q|
                                                (|spadConstant| $ 130)
                                                (QREFELT $ 131))
                                               'NIL)
                                              ('T 'T)))
                                           #3#))
                                        (SEQ
                                         (LETT |m|
                                          (SPADCALL |q|
                                           (QREFELT $ 132)) . #2#)
                                         (LETT |qr|
                                          (DIVIDE2 |m| |e|) . #2#)
                                         (LETT |t1|
                                          (SPADCALL |f| (QCAR |qr|)
                                           (QREFELT $ 133)) . #2#)
                                         (LETT |t2|
                                          (SPADCALL |g| (QCDR |qr|)
                                           (QREFELT $ 133)) . #2#)
                                         (LETT |a|
                                          (SPADCALL |a|
                                           (SPADCALL
                                            (SPADCALL
                                             (SPADCALL |q|
                                              (QREFELT $ 134))
                                             |t1| (QREFELT $ 135))
                                            |t2| (QREFELT $ 135))
                                           (QREFELT $ 136)) . #2#)
                                         (EXIT
                                          (LETT |q|
                                           (SPADCALL |q|
                                            (QREFELT $ 137)) . #2#)))
                                        NIL #4# G191 (EXIT NIL))
                                       (EXIT |a|))))))))))))) 

(DEFUN |FS-;smprep!0| (|#1| $$)
  (PROG ($)
    (LETT $ (QREFELT $$ 3) |FS-;smprep|)
    (RETURN
      (PROGN
        (SPADCALL (SPADCALL |#1| (QREFELT $ 86)) (QREFELT $$ 2)
            (QREFELT $$ 1) (QREFELT $$ 0) (QREFELT $ 95)))))) 

(DEFUN |FS-;dispdiff| (|l| $)
  (PROG (|s| |t| |k| |a| |rec| |i| #0=#:G1969 |x| #1=#:G1970 |m|)
    (RETURN
      (SEQ (LETT |s|
                 (SPADCALL (SPADCALL |l| (QREFELT $ 51))
                     (QREFELT $ 139))
                 . #2=(|FS-;dispdiff|))
           (LETT |t|
                 (SPADCALL (SPADCALL |l| (QREFELT $ 52))
                     (QREFELT $ 139)) . #2#)
           (LETT |a|
                 (SPADCALL
                     (LETT |k|
                           (SPADCALL (|SPADfirst| |l|) (QREFELT $ 30)) . #2#)
                     (QREFELT $ 47)) . #2#)
           (EXIT (COND
                   ((SPADCALL |k| (QREFELT $ 17) (QREFELT $ 140))
                    (SEQ (LETT |rec| (|FS-;dispdiff| |a| $) . #2#)
                         (LETT |i|
                               (SPADCALL |s| (QVELT |rec| 2)
                                   (QREFELT $ 142)) . #2#)
                         (SPADCALL (QVELT |rec| 2) |i| |t|
                             (QREFELT $ 143))
                         (EXIT (VECTOR (QVELT |rec| 0)
                                       (SPADCALL (QVELT |rec| 1)
                                        (SPADCALL
                                         (SPADCALL
                                          (SPADCALL "," (QREFELT $ 10))
                                          (QREFELT $ 144))
                                         (SPADCALL
                                          (- (+ |i| 1)
                                           (SPADCALL |a|
                                            (QREFELT $ 147)))
                                          (QREFELT $ 148))
                                         (QREFELT $ 149))
                                        (QREFELT $ 149))
                                       (QVELT |rec| 2)
                                       (COND
                                         ((ZEROP (QVELT |rec| 3)) 0)
                                         ('T (+ (QVELT |rec| 3) 1)))))))
                   ('T
                    (SEQ (LETT |i|
                               (SPADCALL (SPADCALL |l| (QREFELT $ 51))
                                   |a| (QREFELT $ 150)) . #2#)
                         (LETT |m|
                               (PROGN
                                 (LETT #0# NIL . #2#)
                                 (SEQ (LETT |x| NIL . #2#)
                                      (LETT #1# |a| . #2#) G190
                                      (COND
                                        ((OR (ATOM #1#)
                                          (PROGN
                                            (LETT |x| (CAR #1#) . #2#)
                                            NIL))
                                         (GO G191)))
                                      (SEQ
                                       (EXIT
                                        (LETT #0#
                                         (CONS
                                          (SPADCALL |x|
                                           (QREFELT $ 139))
                                          #0#) . #2#)))
                                      (LETT #1# (CDR #1#) . #2#)
                                      (GO G190) G191
                                      (EXIT (NREVERSE0 #0#)))) . #2#)
                         (SPADCALL |m| |i| |t| (QREFELT $ 143))
                         (EXIT (VECTOR (SPADCALL
                                        (SPADCALL
                                         (SPADCALL |k| (QREFELT $ 45))
                                         (QREFELT $ 120))
                                        (QREFELT $ 144))
                                       (SPADCALL
                                        (SPADCALL
                                         (SPADCALL "," (QREFELT $ 10))
                                         (QREFELT $ 144))
                                        (SPADCALL
                                         (- (+ |i| 1)
                                          (SPADCALL |a|
                                           (QREFELT $ 147)))
                                         (QREFELT $ 148))
                                        (QREFELT $ 149))
                                       |m|
                                       (COND
                                         ((NULL (CDR |a|)) 1)
                                         ('T 0)))))))))))) 

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

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

(DEFUN |FS-;diffdiff| (|l| |x| $)
  (PROG (|f|)
    (RETURN
      (SEQ (LETT |f| (SPADCALL (QREFELT $ 17) |l| (QREFELT $ 48))
                 |FS-;diffdiff|)
           (EXIT (|FS-;diffdiff0| |l| |x| |f|
                     (SPADCALL |f| (QREFELT $ 30)) NIL $)))))) 

(DEFUN |FS-;diffdiff0| (|l| |x| |expr| |kd| |done| $)
  (PROG (|k| |op| |gg| |u| |arg| |b| #0=#:G1989 |i| #1=#:G1988 |bp| |g|
             |ans|)
    (RETURN
      (SEQ (LETT |op|
                 (SPADCALL
                     (LETT |k|
                           (SPADCALL (|SPADfirst| |l|) (QREFELT $ 30))
                           . #2=(|FS-;diffdiff0|))
                     (QREFELT $ 45)) . #2#)
           (LETT |gg| (SPADCALL |l| (QREFELT $ 51)) . #2#)
           (LETT |u| (SPADCALL |l| (QREFELT $ 52)) . #2#)
           (LETT |arg| (SPADCALL |k| (QREFELT $ 47)) . #2#)
           (LETT |ans| (|spadConstant| $ 125) . #2#)
           (COND
             ((NULL (SPADCALL |u| |done| (QREFELT $ 156)))
              (SEQ (LETT |ans|
                         (SPADCALL |u| |x| (QREFELT $ 157)) . #2#)
                   (EXIT (COND
                           ((NULL (SPADCALL |ans|
                                      (|spadConstant| $ 125)
                                      (QREFELT $ 158)))
                            (LETT |ans|
                                  (SPADCALL |ans|
                                      (SPADCALL (QREFELT $ 17)
                                       (LIST
                                        (SPADCALL |expr| (LIST |kd|)
                                         (LIST
                                          (SPADCALL (QREFELT $ 17)
                                           (LIST (|SPADfirst| |l|) |gg|
                                            |gg|)
                                           (QREFELT $ 48)))
                                         (QREFELT $ 159))
                                        |gg| |u|)
                                       (QREFELT $ 48))
                                      (QREFELT $ 135)) . #2#)))))))
           (LETT |done| (CONS |gg| |done|) . #2#)
           (EXIT (COND
                   ((SPADCALL |k| (QREFELT $ 17) (QREFELT $ 140))
                    (SPADCALL |ans|
                        (|FS-;diffdiff0| |arg| |x| |expr| |k| |done| $)
                        (QREFELT $ 136)))
                   ('T
                    (SEQ (SEQ (LETT |b| NIL . #2#)
                              (LETT #0# |arg| . #2#)
                              (LETT |i|
                                    (SPADCALL |arg| (QREFELT $ 147)) . #2#)
                              (LETT #1#
                                    (SPADCALL |arg| (QREFELT $ 160)) . #2#)
                              G190
                              (COND
                                ((OR (> |i| #1#) (ATOM #0#)
                                     (PROGN
                                       (LETT |b| (CAR #0#) . #2#)
                                       NIL))
                                 (GO G191)))
                              (SEQ (EXIT
                                    (COND
                                      ((NULL
                                        (SPADCALL |b| |done|
                                         (QREFELT $ 156)))
                                       (SEQ
                                        (LETT |bp|
                                         (SPADCALL |b| |x|
                                          (QREFELT $ 157)) . #2#)
                                        (EXIT
                                         (COND
                                           ((NULL
                                             (SPADCALL |bp|
                                              (|spadConstant| $ 125)
                                              (QREFELT $ 158)))
                                            (SEQ
                                             (LETT |g|
                                              (SPADCALL
                                               (|FS-;symsub|
                                                (QREFELT $ 79) |i| $)
                                               (QREFELT $ 40)) . #2#)
                                             (EXIT
                                              (LETT |ans|
                                               (SPADCALL |ans|
                                                (SPADCALL |bp|
                                                 (SPADCALL
                                                  (QREFELT $ 17)
                                                  (LIST
                                                   (SPADCALL |expr|
                                                    (LIST |kd|)
                                                    (LIST
                                                     (SPADCALL
                                                      (QREFELT $ 17)
                                                      (LIST
                                                       (|FS-;substArg|
                                                        |op| |arg| |i|
                                                        |g| $)
                                                       |gg| |u|)
                                                      (QREFELT $ 48)))
                                                    (QREFELT $ 159))
                                                   |g| |b|)
                                                  (QREFELT $ 48))
                                                 (QREFELT $ 135))
                                                (QREFELT $ 136)) . #2#)))))))))))
                              (LETT |i|
                                    (PROG1 (+ |i| 1)
                                      (LETT #0# (CDR #0#) . #2#)) . #2#)
                              (GO G190) G191 (EXIT NIL))
                         (EXIT |ans|))))))))) 

(DEFUN |FS-;dfeval| (|l| |g| $)
  (PROG (#0=#:G1991)
    (RETURN
      (SPADCALL
          (SPADCALL (|SPADfirst| |l|)
              (PROG2 (LETT #0# (SPADCALL |g| (QREFELT $ 32))
                           |FS-;dfeval|)
                     (QCDR #0#)
                (|check-union| (QEQCAR #0# 0) (|Symbol|) #0#))
              (QREFELT $ 157))
          |g| (SPADCALL |l| (QREFELT $ 52)) (QREFELT $ 53))))) 

(DEFUN |FS-;diffEval| (|l| $)
  (PROG (|g| |u| |k| #0=#:G2011 |op| |ud| |dumm| |ss| |nl| |n| |d|)
    (RETURN
      (SEQ (EXIT (SEQ (LETT |g|
                            (SPADCALL (SPADCALL |l| (QREFELT $ 51))
                                (QREFELT $ 30))
                            . #1=(|FS-;diffEval|))
                      (SEQ (LETT |u|
                                 (SPADCALL (|SPADfirst| |l|)
                                     (QREFELT $ 77)) . #1#)
                           (EXIT (COND
                                   ((QEQCAR |u| 1)
                                    (PROGN
                                      (LETT #0#
                                       (|FS-;dfeval| |l| |g| $) . #1#)
                                      (GO #0#)))
                                   ((QEQCAR |u| 0)
                                    (COND
                                      ((QEQCAR
                                        (SPADCALL
                                         (LETT |k| (QCDR |u|) . #1#)
                                         (QREFELT $ 32))
                                        0)
                                       (PROGN
                                         (LETT #0#
                                          (|FS-;dfeval| |l| |g| $) . #1#)
                                         (GO #0#))))))))
                      (LETT |op| (SPADCALL |k| (QREFELT $ 45)) . #1#)
                      (LETT |ud| (SPADCALL |op| (QREFELT $ 163)) . #1#)
                      (EXIT (COND
                              ((QEQCAR |ud| 1)
                               (SEQ (LETT |dumm|
                                     (SPADCALL
                                      (|FS-;symsub| (QREFELT $ 79) 1 $)
                                      (QREFELT $ 40)) . #1#)
                                    (LETT |ss|
                                     (SPADCALL
                                      (SPADCALL |l| 1 (QREFELT $ 164))
                                      (SPADCALL
                                       (SPADCALL |l| 2 (QREFELT $ 164))
                                       |dumm| (QREFELT $ 166))
                                      (QREFELT $ 168)) . #1#)
                                    (LETT |nl|
                                     (LIST |ss| |dumm|
                                      (SPADCALL |l| 3 (QREFELT $ 164))) . #1#)
                                    (EXIT
                                     (SPADCALL (QREFELT $ 17) |nl|
                                      (QREFELT $ 48)))))
                              ((< (LETT |n|
                                        (SPADCALL
                                         (SPADCALL |l| (QREFELT $ 51))
                                         (SPADCALL |k| (QREFELT $ 47))
                                         (QREFELT $ 150)) . #1#)
                                  (SPADCALL |l| (QREFELT $ 147)))
                               (|FS-;dfeval| |l| |g| $))
                              ('T
                               (SEQ (LETT |d| (QCDR |ud|) . #1#)
                                    (EXIT
                                     (SPADCALL
                                      (SPADCALL
                                       (SPADCALL |k| (QREFELT $ 47))
                                       (SPADCALL |d| |n|
                                        (QREFELT $ 128)))
                                      |g| (SPADCALL |l| (QREFELT $ 52))
                                      (QREFELT $ 53)))))))))
           #0# (EXIT #0#))))) 

(DEFUN |FS-;diffArg| (|l| |op| |i| $)
  (PROG (|n| |z| |g|)
    (RETURN
      (SEQ (LETT |n| (+ (- |i| 1) (SPADCALL |l| (QREFELT $ 147)))
                 . #0=(|FS-;diffArg|))
           (LETT |z| (SPADCALL |l| (QREFELT $ 154)) . #0#)
           (SPADCALL |z| |n|
               (LETT |g|
                     (SPADCALL (|FS-;symsub| (QREFELT $ 79) |n| $)
                         (QREFELT $ 40)) . #0#)
               (QREFELT $ 155))
           (EXIT (LIST (SPADCALL |op| |z| (QREFELT $ 48)) |g|
                       (SPADCALL |l| |n| (QREFELT $ 164)))))))) 

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

(DEFUN |FS-;opderiv!1| (|#1| $$)
  (PROG ($)
    (LETT $ (QREFELT $$ 0) |FS-;opderiv|)
    (RETURN
      (PROGN
        (SPADCALL (QREFELT $$ 3)
            (|FS-;diffArg| |#1| (QREFELT $$ 2) (QREFELT $$ 1) $)
            (QREFELT $ 48)))))) 

(DEFUN |FS-;opderiv!0| (|#1| $$)
  (PROG (|g| $)
    (LETT |g| (QREFELT $$ 1) . #0=(|FS-;opderiv|))
    (LETT $ (QREFELT $$ 0) . #0#)
    (RETURN
      (PROGN
        (SPADCALL (QREFELT $$ 3)
            (LIST (SPADCALL (QREFELT $$ 2) |g| (QREFELT $ 169)) |g|
                  (SPADCALL |#1| (QREFELT $ 91)))
            (QREFELT $ 48)))))) 

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

(DEFUN |FS-;kerderiv| (|k| |x| $)
  (PROG (|v| |fn| |y| #0=#:G2047 |g| #1=#:G2046 #2=#:G2042 #3=#:G2040
             #4=#:G2041)
    (RETURN
      (SEQ (LETT |v| (SPADCALL |k| (QREFELT $ 32))
                 . #5=(|FS-;kerderiv|))
           (EXIT (COND
                   ((QEQCAR |v| 0)
                    (COND
                      ((EQUAL (QCDR |v|) |x|) (|spadConstant| $ 145))
                      (#6='T (|spadConstant| $ 125))))
                   (#6#
                    (SEQ (LETT |fn|
                               (SPADCALL (SPADCALL |k| (QREFELT $ 45))
                                   (QREFELT $ 13) (QREFELT $ 171)) . #5#)
                         (EXIT (COND
                                 ((QEQCAR |fn| 0)
                                  (SPADCALL
                                      (SPADCALL |k| (QREFELT $ 47)) |x|
                                      (QCDR |fn|)))
                                 (#6#
                                  (PROGN
                                    (LETT #4# NIL . #5#)
                                    (SEQ (LETT |y| NIL . #5#)
                                     (LETT #0#
                                      (SPADCALL |k| (QREFELT $ 47)) . #5#)
                                     (LETT |g| NIL . #5#)
                                     (LETT #1#
                                      (|FS-;kderiv| |k| $) . #5#)
                                     G190
                                     (COND
                                       ((OR (ATOM #1#)
                                         (PROGN
                                           (LETT |g| (CAR #1#) . #5#)
                                           NIL)
                                         (ATOM #0#)
                                         (PROGN
                                           (LETT |y| (CAR #0#) . #5#)
                                           NIL))
                                        (GO G191)))
                                     (SEQ
                                      (EXIT
                                       (PROGN
                                         (LETT #2#
                                          (SPADCALL |g|
                                           (SPADCALL |y| |x|
                                            (QREFELT $ 157))
                                           (QREFELT $ 135)) . #5#)
                                         (COND
                                           (#4#
                                            (LETT #3#
                                             (SPADCALL #3# #2#
                                              (QREFELT $ 136)) . #5#))
                                           ('T
                                            (PROGN
                                              (LETT #3# #2# . #5#)
                                              (LETT #4# 'T . #5#)))))))
                                     (LETT #1#
                                      (PROG1 (CDR #1#)
                                        (LETT #0# (CDR #0#) . #5#)) . #5#)
                                     (GO G190) G191 (EXIT NIL))
                                    (COND
                                      (#4# #3#)
                                      (#6# (|spadConstant| $ 125))))))))))))))) 

(DEFUN |FS-;smpderiv| (|p| |x| $)
  (PROG (|k| #0=#:G2053 #1=#:G2051 #2=#:G2049 #3=#:G2050)
    (RETURN
      (SEQ (SPADCALL
               (SPADCALL
                   (SPADCALL (CONS #'|FS-;smpderiv!0| (VECTOR |x| $))
                       |p| (QREFELT $ 177))
                   (QREFELT $ 86))
               (PROGN
                 (LETT #3# NIL . #4=(|FS-;smpderiv|))
                 (SEQ (LETT |k| NIL . #4#)
                      (LETT #0# (SPADCALL |p| (QREFELT $ 179)) . #4#)
                      G190
                      (COND
                        ((OR (ATOM #0#)
                             (PROGN (LETT |k| (CAR #0#) . #4#) NIL))
                         (GO G191)))
                      (SEQ (EXIT (PROGN
                                   (LETT #1#
                                    (SPADCALL
                                     (SPADCALL
                                      (SPADCALL |p| |k|
                                       (QREFELT $ 180))
                                      (QREFELT $ 86))
                                     (|FS-;kerderiv| |k| |x| $)
                                     (QREFELT $ 135)) . #4#)
                                   (COND
                                     (#3#
                                      (LETT #2#
                                       (SPADCALL #2# #1#
                                        (QREFELT $ 136)) . #4#))
                                     ('T
                                      (PROGN
                                        (LETT #2# #1# . #4#)
                                        (LETT #3# 'T . #4#)))))))
                      (LETT #0# (CDR #0#) . #4#) (GO G190) G191
                      (EXIT NIL))
                 (COND (#3# #2#) ('T (|spadConstant| $ 125))))
               (QREFELT $ 136)))))) 

(DEFUN |FS-;smpderiv!0| (|#1| $$)
  (PROG ($)
    (LETT $ (QREFELT $$ 1) |FS-;smpderiv|)
    (RETURN
      (PROGN
        (SPADCALL
            (SPADCALL (SPADCALL |#1| (QREFELT $ 173)) (QREFELT $$ 0)
                (QREFELT $ 174))
            (QREFELT $ 175)))))) 

(DEFUN |FS-;coerce;PS;43| (|p| $)
  (SPADCALL (CONS #'|FS-;coerce;PS;43!0| $)
      (CONS #'|FS-;coerce;PS;43!1| $) |p| (QREFELT $ 185))) 

(DEFUN |FS-;coerce;PS;43!1| (|#1| $) (SPADCALL |#1| (QREFELT $ 181))) 

(DEFUN |FS-;coerce;PS;43!0| (|#1| $) (SPADCALL |#1| (QREFELT $ 40))) 

(DEFUN |FS-;worse?| (|k1| |k2| $)
  (PROG (|u|)
    (RETURN
      (SEQ (LETT |u|
                 (SPADCALL
                     (SPADCALL (SPADCALL |k1| (QREFELT $ 45))
                         (QREFELT $ 120))
                     (SPADCALL (SPADCALL |k2| (QREFELT $ 45))
                         (QREFELT $ 120))
                     (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|))
             ('T
              (SEQ (LETT |a| (|FS-;bestKernel| (CDR |l|) $)
                         |FS-;bestKernel|)
                   (EXIT (COND
                           ((|FS-;worse?| (|SPADfirst| |l|) |a| $) |a|)
                           ('T (|SPADfirst| |l|))))))))))) 

(DEFUN |FS-;smp2O| (|p| $)
  (PROG (|r| #0=#:G2072 |a|)
    (RETURN
      (SEQ (LETT |r| (SPADCALL |p| (QREFELT $ 191)) . #1=(|FS-;smp2O|))
           (EXIT (COND
                   ((QEQCAR |r| 0)
                    (SPADCALL (QCDR |r|) (QREFELT $ 192)))
                   (#2='T
                    (SEQ (LETT |a|
                               (COND
                                 ((SPADCALL (QREFELT $ 193))
                                  (|FS-;bestKernel|
                                      (SPADCALL |p| (QREFELT $ 179)) $))
                                 (#2#
                                  (PROG2 (LETT #0#
                                          (SPADCALL |p|
                                           (QREFELT $ 112)) . #1#)
                                         (QCDR #0#)
                                    (|check-union| (QEQCAR #0# 0)
                                     (|Kernel| (QREFELT $ 6)) #0#)))) . #1#)
                         (EXIT (SPADCALL
                                   (SPADCALL (CONS #'|FS-;smp2O!0| $)
                                    (SPADCALL |p| |a| (QREFELT $ 114))
                                    (QREFELT $ 119))
                                   (SPADCALL |a| (QREFELT $ 194))
                                   (QREFELT $ 195))))))))))) 

(DEFUN |FS-;smp2O!0| (|#1| $) (SPADCALL |#1| (QREFELT $ 86))) 

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

(DEFUN |FS-;smpsubst!3| (|#1| $) (SPADCALL |#1| (QREFELT $ 181))) 

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

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

(DEFUN |FS-;smpsubst!0| (|#1| $$)
  (SPADCALL |#1| (QREFELT $$ 2) (QREFELT $$ 1)
      (QREFELT (QREFELT $$ 0) 159))) 

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

(DEFUN |FS-;smpeval!3| (|#1| $) (SPADCALL |#1| (QREFELT $ 181))) 

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

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

(DEFUN |FS-;smpeval!0| (|#1| $$)
  (SPADCALL |#1| (QREFELT $$ 2) (QREFELT $$ 1)
      (QREFELT (QREFELT $$ 0) 201))) 

(DEFUN |FS-;notfound| (|fn| |lk| |k| $)
  (PROG (|f|)
    (RETURN
      (COND
        ((NULL (SPADCALL
                   (SPADCALL
                       (LETT |f| (SPADCALL |k| (QREFELT $ 28))
                             |FS-;notfound|)
                       (QREFELT $ 74))
                   |lk| (QREFELT $ 203)))
         |f|)
        ('T (SPADCALL |k| |fn|)))))) 

(DEFUN |FS-;pushunq| (|l| |arg| $)
  (PROG (#0=#:G2086 #1=#:G2087 #2=#:G2088 |a| #3=#:G2089)
    (RETURN
      (SEQ (COND
             ((NULL |l|)
              (PROGN
                (LETT #0# NIL . #4=(|FS-;pushunq|))
                (SEQ (LETT |a| NIL . #4#) (LETT #1# |arg| . #4#) G190
                     (COND
                       ((OR (ATOM #1#)
                            (PROGN (LETT |a| (CAR #1#) . #4#) NIL))
                        #5=(GO G191)))
                     (SEQ (EXIT (LETT #0#
                                      (CONS
                                       (SPADCALL |a| (QREFELT $ 204))
                                       #0#) . #4#)))
                     (LETT #1# (CDR #1#) . #4#) #6=(GO G190) G191
                     (EXIT (NREVERSE0 #0#)))))
             ('T
              (PROGN
                (LETT #2# NIL . #4#)
                (SEQ (LETT |a| NIL . #4#) (LETT #3# |arg| . #4#) G190
                     (COND
                       ((OR (ATOM #3#)
                            (PROGN (LETT |a| (CAR #3#) . #4#) NIL))
                        #5#))
                     (SEQ (EXIT (LETT #2#
                                      (CONS
                                       (SPADCALL |a| |l|
                                        (QREFELT $ 59))
                                       #2#) . #4#)))
                     (LETT #3# (CDR #3#) . #4#) #6# G191
                     (EXIT (NREVERSE0 #2#)))))))))) 

(DEFUN |FS-;kunq| (|k| |l| |givenlist?| $)
  (PROG (|s| #0=#:G2128 |a| #1=#:G2129)
    (RETURN
      (SEQ (COND
             (|givenlist?|
                 (COND
                   ((NULL |l|) (EXIT (SPADCALL |k| (QREFELT $ 28)))))))
           (COND
             ((SPADCALL |k| (QREFELT $ 18) (QREFELT $ 140))
              (COND
                ((OR (SPADCALL
                         (LETT |s|
                               (SPADCALL
                                   (|SPADfirst|
                                    (SPADCALL |k| (QREFELT $ 47)))
                                   (QREFELT $ 205))
                               . #2=(|FS-;kunq|))
                         |l| (QREFELT $ 206))
                     (NULL |l|))
                 (EXIT (SPADCALL
                           (SPADCALL
                               (CONS (SPADCALL |s| (QREFELT $ 55))
                                     (PROGN
                                       (LETT #0# NIL . #2#)
                                       (SEQ (LETT |a| NIL . #2#)
                                        (LETT #1#
                                         (|FS-;pushunq| |l|
                                          (CDR
                                           (SPADCALL |k|
                                            (QREFELT $ 47)))
                                          $) . #2#)
                                        G190
                                        (COND
                                          ((OR (ATOM #1#)
                                            (PROGN
                                              (LETT |a|
                                               (CAR #1#) . #2#)
                                              NIL))
                                           (GO G191)))
                                        (SEQ
                                         (EXIT
                                          (LETT #0#
                                           (CONS
                                            (SPADCALL |a|
                                             (QREFELT $ 57))
                                            #0#) . #2#)))
                                        (LETT #1# (CDR #1#) . #2#)
                                        (GO G190) G191
                                        (EXIT (NREVERSE0 #0#)))))
                               (QREFELT $ 56))
                           (QREFELT $ 208)))))))
           (EXIT (SPADCALL (SPADCALL |k| (QREFELT $ 45))
                     (|FS-;pushunq| |l| (SPADCALL |k| (QREFELT $ 47))
                         $)
                     (QREFELT $ 41))))))) 

(DEFUN |FS-;smpunq| (|p| |l| |givenlist?| $)
  (SEQ (COND
         (|givenlist?|
             (COND ((NULL |l|) (EXIT (SPADCALL |p| (QREFELT $ 86)))))))
       (EXIT (SPADCALL
                 (CONS #'|FS-;smpunq!0| (VECTOR $ |givenlist?| |l|))
                 (CONS #'|FS-;smpunq!1| $) |p| (QREFELT $ 200))))) 

(DEFUN |FS-;smpunq!1| (|#1| $) (SPADCALL |#1| (QREFELT $ 181))) 

(DEFUN |FS-;smpunq!0| (|#1| $$)
  (|FS-;kunq| |#1| (QREFELT $$ 2) (QREFELT $$ 1) (QREFELT $$ 0))) 

(DEFUN |FS-;smpret| (|p| $)
  (PROG (|k| #0=#:G2146 #1=#:G2138 #2=#:G2136 #3=#:G2137)
    (RETURN
      (SEQ (COND
             ((PROGN
                (LETT #3# NIL . #4=(|FS-;smpret|))
                (SEQ (LETT |k| NIL . #4#)
                     (LETT #0# (SPADCALL |p| (QREFELT $ 179)) . #4#)
                     G190
                     (COND
                       ((OR (ATOM #0#)
                            (PROGN (LETT |k| (CAR #0#) . #4#) NIL))
                        (GO G191)))
                     (SEQ (EXIT (PROGN
                                  (LETT #1#
                                        (QEQCAR
                                         (SPADCALL |k| (QREFELT $ 32))
                                         1) . #4#)
                                  (COND
                                    (#3#
                                     (LETT #2#
                                      (COND (#2# 'T) ('T #1#)) . #4#))
                                    ('T
                                     (PROGN
                                       (LETT #2# #1# . #4#)
                                       (LETT #3# 'T . #4#)))))))
                     (LETT #0# (CDR #0#) . #4#) (GO G190) G191
                     (EXIT NIL))
                (COND (#3# #2#) ('T 'NIL)))
              (CONS 1 "failed"))
             ('T
              (CONS 0
                    (SPADCALL (CONS #'|FS-;smpret!0| $)
                        (CONS #'|FS-;smpret!1| $) |p| (QREFELT $ 213))))))))) 

(DEFUN |FS-;smpret!1| (|#1| $) (SPADCALL |#1| (QREFELT $ 173))) 

(DEFUN |FS-;smpret!0| (|#1| $)
  (PROG (#0=#:G2140)
    (RETURN
      (SPADCALL
          (PROG2 (LETT #0# (SPADCALL |#1| (QREFELT $ 32)) NIL)
                 (QCDR #0#)
            (|check-union| (QEQCAR #0# 0) (|Symbol|) #0#))
          (QREFELT $ 209))))) 

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

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

(DEFUN |FS-;smpIsMult| (|p| $)
  (PROG (|u| |q| |r| |n| #0=#:G2190)
    (RETURN
      (SEQ (EXIT (SEQ (SEQ (LETT |u| (SPADCALL |p| (QREFELT $ 112))
                                 . #1=(|FS-;smpIsMult|))
                           (EXIT (COND
                                   ((QEQCAR |u| 0)
                                    (COND
                                      ((EQL
                                        (SPADCALL
                                         (LETT |q|
                                          (SPADCALL |p| (QCDR |u|)
                                           (QREFELT $ 114)) . #1#)
                                         (QREFELT $ 220))
                                        1)
                                       (COND
                                         ((SPADCALL
                                           (SPADCALL
                                            (SPADCALL |q|
                                             (QREFELT $ 221))
                                            (QREFELT $ 222))
                                           (QREFELT $ 223))
                                          (SEQ
                                           (LETT |r|
                                            (SPADCALL
                                             (SPADCALL |q|
                                              (QREFELT $ 222))
                                             (QREFELT $ 191)) . #1#)
                                           (EXIT
                                            (COND
                                              ((QEQCAR |r| 0)
                                               (SEQ
                                                (LETT |n|
                                                 (SPADCALL (QCDR |r|)
                                                  (QREFELT $ 225)) . #1#)
                                                (EXIT
                                                 (COND
                                                   ((QEQCAR |n| 0)
                                                    (PROGN
                                                      (LETT #0#
                                                       (CONS 0
                                                        (CONS
                                                         (QCDR |n|)
                                                         (QCDR |u|))) . #1#)
                                                      (GO #0#))))))))))))))))))
                      (EXIT (CONS 1 "failed"))))
           #0# (EXIT #0#))))) 

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

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

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

(DEFUN |FS-;mainKernel;SU;59| (|x| $)
  (SPADCALL (SPADCALL |x| (QREFELT $ 89)) (QREFELT $ 112))) 

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

(DEFUN |FS-;retract;SR;61| (|x| $)
  (SPADCALL (SPADCALL |x| (QREFELT $ 89)) (QREFELT $ 229))) 

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

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

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

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

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

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

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

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

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

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

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

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

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

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

(DEFUN |FS-;convert;SP;76| (|x| $)
  (SPADCALL (SPADCALL |x| (QREFELT $ 89)) (QREFELT $ 255))) 

(DEFUN |FS-;convert;SP;77| (|x| $)
  (SPADCALL (SPADCALL |x| (QREFELT $ 89)) (QREFELT $ 258))) 

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

(DEFUN |FS-;*;R2S;79| (|r| |x| $)
  (SPADCALL (SPADCALL (SPADCALL |r| (QREFELT $ 263)) (QREFELT $ 86))
      |x| (QREFELT $ 135))) 

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

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

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

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

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

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

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

(DEFUN |FS-;denominator;2S;87| (|x| $)
  (SPADCALL (SPADCALL |x| (QREFELT $ 281)) (QREFELT $ 86))) 

(DEFUN |FS-;coerce;FS;88| (|q| $)
  (SPADCALL (SPADCALL (SPADCALL |q| (QREFELT $ 284)) (QREFELT $ 263))
      (SPADCALL (SPADCALL |q| (QREFELT $ 285)) (QREFELT $ 263))
      (QREFELT $ 286))) 

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

(DEFUN |FS-;coerce;FS;90| (|q| $)
  (SPADCALL (SPADCALL (SPADCALL |q| (QREFELT $ 296)) (QREFELT $ 297))
      (SPADCALL (SPADCALL |q| (QREFELT $ 298)) (QREFELT $ 297))
      (QREFELT $ 292))) 

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

(DEFUN |FS-;retract;SF;92| (|x| $)
  (PROG (#0=#:G2335)
    (RETURN
      (SPADCALL
          (PROG2 (LETT #0#
                       (|FS-;smpret| (SPADCALL |x| (QREFELT $ 89)) $)
                       . #1=(|FS-;retract;SF;92|))
                 (QCDR #0#)
            (|check-union| (QEQCAR #0# 0) (|Polynomial| (QREFELT $ 7))
                #0#))
          (PROG2 (LETT #0#
                       (|FS-;smpret| (SPADCALL |x| (QREFELT $ 281)) $) . #1#)
                 (QCDR #0#)
            (|check-union| (QEQCAR #0# 0) (|Polynomial| (QREFELT $ 7))
                #0#))
          (QREFELT $ 302))))) 

(DEFUN |FS-;retract;SR;93| (|x| $)
  (PROG (#0=#:G2342)
    (RETURN
      (PROG2 (LETT #0#
                   (SPADCALL
                       (SPADCALL (SPADCALL |x| (QREFELT $ 89))
                           (QREFELT $ 229))
                       (SPADCALL (SPADCALL |x| (QREFELT $ 281))
                           (QREFELT $ 229))
                       (QREFELT $ 305))
                   |FS-;retract;SR;93|)
             (QCDR #0#)
        (|check-union| (QEQCAR #0# 0) (QREFELT $ 7) #0#))))) 

(DEFUN |FS-;coerce;SOf;94| (|x| $)
  (COND
    ((SPADCALL (SPADCALL |x| (QREFELT $ 281)) (|spadConstant| $ 306)
         (QREFELT $ 307))
     (|FS-;smp2O| (SPADCALL |x| (QREFELT $ 89)) $))
    ('T
     (SPADCALL (|FS-;smp2O| (SPADCALL |x| (QREFELT $ 89)) $)
         (|FS-;smp2O| (SPADCALL |x| (QREFELT $ 281)) $)
         (QREFELT $ 308))))) 

(DEFUN |FS-;retractIfCan;SU;95| (|x| $)
  (PROG (|n| |d| |r| #0=#:G2353)
    (RETURN
      (SEQ (EXIT (SEQ (SEQ (LETT |n|
                                 (SPADCALL
                                     (SPADCALL |x| (QREFELT $ 89))
                                     (QREFELT $ 191))
                                 . #1=(|FS-;retractIfCan;SU;95|))
                           (EXIT (COND
                                   ((QEQCAR |n| 1)
                                    (PROGN
                                      (LETT #0#
                                       (CONS 1 "failed") . #1#)
                                      (GO #0#)))
                                   (#2='T
                                    (SEQ
                                     (LETT |d|
                                      (SPADCALL
                                       (SPADCALL |x| (QREFELT $ 281))
                                       (QREFELT $ 191)) . #1#)
                                     (EXIT
                                      (COND
                                        ((QEQCAR |d| 1)
                                         (PROGN
                                           (LETT #0#
                                            (CONS 1 "failed") . #1#)
                                           (GO #0#)))
                                        (#2#
                                         (SEQ
                                          (LETT |r|
                                           (SPADCALL (QCDR |n|)
                                            (QCDR |d|) (QREFELT $ 305)) . #1#)
                                          (EXIT
                                           (COND
                                             ((QEQCAR |r| 1)
                                              (PROGN
                                                (LETT #0#
                                                 (CONS 1 "failed") . #1#)
                                                (GO #0#))))))))))))))
                      (EXIT (CONS 0 (QCDR |r|)))))
           #0# (EXIT #0#))))) 

(DEFUN |FS-;eval;SLS;96| (|f| |l| $)
  (SPADCALL (|FS-;smpunq| (SPADCALL |f| (QREFELT $ 89)) |l| 'T $)
      (|FS-;smpunq| (SPADCALL |f| (QREFELT $ 281)) |l| 'T $)
      (QREFELT $ 292))) 

(DEFUN |FS-;eval;2S;97| (|f| $)
  (SPADCALL (|FS-;smpunq| (SPADCALL |f| (QREFELT $ 89)) NIL 'NIL $)
      (|FS-;smpunq| (SPADCALL |f| (QREFELT $ 281)) NIL 'NIL $)
      (QREFELT $ 292))) 

(DEFUN |FS-;eval;SLLLS;98| (|x| |s| |n| |f| $)
  (SPADCALL (|FS-;smprep| |s| |n| |f| (SPADCALL |x| (QREFELT $ 89)) $)
      (|FS-;smprep| |s| |n| |f| (SPADCALL |x| (QREFELT $ 281)) $)
      (QREFELT $ 292))) 

(DEFUN |FS-;differentiate;SSS;99| (|f| |x| $)
  (SPADCALL
      (SPADCALL
          (SPADCALL
              (|FS-;smpderiv| (SPADCALL |f| (QREFELT $ 89)) |x| $)
              (SPADCALL (SPADCALL |f| (QREFELT $ 281)) (QREFELT $ 86))
              (QREFELT $ 135))
          (SPADCALL
              (SPADCALL (SPADCALL |f| (QREFELT $ 89)) (QREFELT $ 86))
              (|FS-;smpderiv| (SPADCALL |f| (QREFELT $ 281)) |x| $)
              (QREFELT $ 135))
          (QREFELT $ 309))
      (SPADCALL
          (SPADCALL (SPADCALL |f| (QREFELT $ 281)) (QREFELT $ 86)) 2
          (QREFELT $ 310))
      (QREFELT $ 292))) 

(DEFUN |FS-;eval;SLLS;100| (|x| |lk| |lv| $)
  (SPADCALL (|FS-;smpeval| (SPADCALL |x| (QREFELT $ 89)) |lk| |lv| $)
      (|FS-;smpeval| (SPADCALL |x| (QREFELT $ 281)) |lk| |lv| $)
      (QREFELT $ 292))) 

(DEFUN |FS-;subst;SLLS;101| (|x| |lk| |lv| $)
  (SPADCALL (|FS-;smpsubst| (SPADCALL |x| (QREFELT $ 89)) |lk| |lv| $)
      (|FS-;smpsubst| (SPADCALL |x| (QREFELT $ 281)) |lk| |lv| $)
      (QREFELT $ 292))) 

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

(DEFUN |FS-;convert;FS;103| (|x| $)
  (PROG (|f| #0=#:G2382 #1=#:G2380 #2=#:G2378 #3=#:G2379)
    (RETURN
      (SEQ (SPADCALL (|FS-;par| (SPADCALL |x| (QREFELT $ 313)) $)
               (PROGN
                 (LETT #3# NIL . #4=(|FS-;convert;FS;103|))
                 (SEQ (LETT |f| NIL . #4#)
                      (LETT #0# (SPADCALL |x| (QREFELT $ 316)) . #4#)
                      G190
                      (COND
                        ((OR (ATOM #0#)
                             (PROGN (LETT |f| (CAR #0#) . #4#) NIL))
                         (GO G191)))
                      (SEQ (EXIT (PROGN
                                   (LETT #1#
                                    (SPADCALL (|FS-;par| (QCAR |f|) $)
                                     (QCDR |f|) (QREFELT $ 310)) . #4#)
                                   (COND
                                     (#3#
                                      (LETT #2#
                                       (SPADCALL #2# #1#
                                        (QREFELT $ 135)) . #4#))
                                     ('T
                                      (PROGN
                                        (LETT #2# #1# . #4#)
                                        (LETT #3# 'T . #4#)))))))
                      (LETT #0# (CDR #0#) . #4#) (GO G190) G191
                      (EXIT NIL))
                 (COND (#3# #2#) ('T (|spadConstant| $ 145))))
               (QREFELT $ 135)))))) 

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

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

(DEFUN |FS-;coerce;PS;106| (|p| $)
  (SPADCALL (CONS #'|FS-;coerce;PS;106!0| $)
      (CONS #'|FS-;coerce;PS;106!1| $) |p| (QREFELT $ 326))) 

(DEFUN |FS-;coerce;PS;106!1| (|#1| $) (SPADCALL |#1| (QREFELT $ 323))) 

(DEFUN |FS-;coerce;PS;106!0| (|#1| $) (SPADCALL |#1| (QREFELT $ 40))) 

(DEFUN |FS-;coerce;FS;107| (|x| $)
  (SPADCALL (SPADCALL (SPADCALL |x| (QREFELT $ 329)) (QREFELT $ 330))
      (SPADCALL (SPADCALL |x| (QREFELT $ 331)) (QREFELT $ 330))
      (QREFELT $ 286))) 

(DEFUN |FS-;isMult;SU;108| (|x| $)
  (PROG (|u| |v| |w| #0=#:G2419 |r| |q|)
    (RETURN
      (SEQ (EXIT (SEQ (SEQ (LETT |u|
                                 (|FS-;smpIsMult|
                                     (SPADCALL |x| (QREFELT $ 89)) $)
                                 . #1=(|FS-;isMult;SU;108|))
                           (EXIT (COND
                                   ((QEQCAR |u| 1)
                                    (PROGN
                                      (LETT #0#
                                       (CONS 1 "failed") . #1#)
                                      (GO #0#)))
                                   (#2='T
                                    (SEQ
                                     (LETT |v|
                                      (SPADCALL
                                       (SPADCALL |x| (QREFELT $ 281))
                                       (QREFELT $ 191)) . #1#)
                                     (EXIT
                                      (COND
                                        ((QEQCAR |v| 1)
                                         (PROGN
                                           (LETT #0#
                                            (CONS 1 "failed") . #1#)
                                           (GO #0#)))
                                        (#2#
                                         (SEQ
                                          (LETT |w|
                                           (SPADCALL (QCDR |v|)
                                            (QREFELT $ 225)) . #1#)
                                          (EXIT
                                           (COND
                                             ((QEQCAR |w| 1)
                                              (PROGN
                                                (LETT #0#
                                                 (CONS 1 "failed") . #1#)
                                                (GO #0#))))))))))))))
                      (LETT |r| (QCDR |u|) . #1#)
                      (LETT |q|
                            (SPADCALL (QCAR |r|) (QCDR |w|)
                                (QREFELT $ 333)) . #1#)
                      (EXIT (COND
                              ((QEQCAR |q| 1) (CONS 1 "failed"))
                              (#2#
                               (CONS 0 (CONS (QCDR |q|) (QCDR |r|))))))))
           #0# (EXIT #0#))))) 

(DEFUN |FS-;convert;SP;109| (|x| $)
  (SPADCALL (SPADCALL (SPADCALL |x| (QREFELT $ 89)) (QREFELT $ 255))
      (SPADCALL (SPADCALL |x| (QREFELT $ 281)) (QREFELT $ 255))
      (QREFELT $ 334))) 

(DEFUN |FS-;convert;SP;110| (|x| $)
  (SPADCALL (SPADCALL (SPADCALL |x| (QREFELT $ 89)) (QREFELT $ 258))
      (SPADCALL (SPADCALL |x| (QREFELT $ 281)) (QREFELT $ 258))
      (QREFELT $ 335))) 

(DEFUN |FunctionSpace&| (|#1| |#2|)
  (PROG (DV$1 DV$2 |dv$| $ |pv$|)
    (RETURN
      (PROGN
        (LETT DV$1 (|devaluate| |#1|) . #0=(|FunctionSpace&|))
        (LETT DV$2 (|devaluate| |#2|) . #0#)
        (LETT |dv$| (LIST '|FunctionSpace&| DV$1 DV$2) . #0#)
        (LETT $ (GETREFV 339) . #0#)
        (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|))))) . #0#))
        (|stuffDomainSlots| $)
        (QSETREFV $ 6 |#1|)
        (QSETREFV $ 7 |#2|)
        (QSETREFV $ 11 (SPADCALL "odd" (QREFELT $ 10)))
        (QSETREFV $ 12 (SPADCALL "even" (QREFELT $ 10)))
        (QSETREFV $ 13 (SPADCALL "%specialDiff" (QREFELT $ 10)))
        (QSETREFV $ 17
            (SPADCALL (SPADCALL "%diff" (QREFELT $ 10)) (QREFELT $ 16)))
        (QSETREFV $ 18
            (SPADCALL (SPADCALL "applyQuote" (QREFELT $ 10))
                (QREFELT $ 16)))
        (COND
          ((|testBitVector| |pv$| 11)
           (PROGN
             (QSETREFV $ 60
                 (CONS (|dispatchFunction| |FS-;eval;SSS;16|) $))
             (QSETREFV $ 63
                 (CONS (|dispatchFunction| |FS-;eval;SBoSSS;17|) $))
             (QSETREFV $ 70
                 (CONS (|dispatchFunction| |FS-;eval;SLLSS;18|) $))
             (SPADCALL (QREFELT $ 17)
                 (SPADCALL "%specialInput" (QREFELT $ 10))
                 (CONS (|function| |FS-;indiff|) $) (QREFELT $ 72)))))
        (COND
          ((|testBitVector| |pv$| 6)
           (PROGN
             (QSETREFV $ 79 (SPADCALL "%%0" (QREFELT $ 10)))
             (QSETREFV $ 82
                 (CONS (|dispatchFunction| |FS-;characteristic;Nni;21|)
                       $))
             (QSETREFV $ 87
                 (CONS (|dispatchFunction| |FS-;coerce;KS;22|) $))
             (QSETREFV $ 90
                 (CONS (|dispatchFunction| |FS-;numerator;2S;24|) $))
             (QSETREFV $ 96
                 (CONS (|dispatchFunction| |FS-;eval;SSNniMS;25|) $))
             (QSETREFV $ 97
                 (CONS (|dispatchFunction| |FS-;eval;SSNniMS;26|) $))
             (QSETREFV $ 99
                 (CONS (|dispatchFunction| |FS-;eval;SLLS;27|) $))
             (QSETREFV $ 109
                 (CONS (|dispatchFunction| |FS-;elt;BoLS;28|) $))
             (QSETREFV $ 110
                 (CONS (|dispatchFunction| |FS-;eval;SLLLS;29|) $))
             (QSETREFV $ 186
                 (CONS (|dispatchFunction| |FS-;coerce;PS;43|) $))
             (COND ((|testBitVector| |pv$| 11)))
             (QSETREFV $ 217
                 (CONS (|dispatchFunction| |FS-;isExpt;SBoU;54|) $))
             (QSETREFV $ 219
                 (CONS (|dispatchFunction| |FS-;isExpt;SSU;55|) $))
             (COND ((|testBitVector| |pv$| 1)))
             (SPADCALL (QREFELT $ 17)
                 (CONS (|function| |FS-;diffEval|) $) (QREFELT $ 226))
             (SPADCALL (QREFELT $ 17)
                 (SPADCALL "%specialEqual" (QREFELT $ 10))
                 (CONS (|function| |FS-;equaldiff|) $) (QREFELT $ 72))
             (SPADCALL (QREFELT $ 17) (QREFELT $ 13)
                 (CONS (|function| |FS-;diffdiff|) $) (QREFELT $ 72))
             (SPADCALL (QREFELT $ 17)
                 (SPADCALL "%specialDisp" (QREFELT $ 10))
                 (CONS (|function| |FS-;ddiff|) $) (QREFELT $ 72))
             (COND
               ((|testBitVector| |pv$| 2))
               ('T
                (PROGN
                  (QSETREFV $ 227
                      (CONS (|dispatchFunction| |FS-;mainKernel;SU;59|)
                            $))
                  (QSETREFV $ 228
                      (CONS (|dispatchFunction| |FS-;kernels;SL;60|) $))
                  (QSETREFV $ 230
                      (CONS (|dispatchFunction| |FS-;retract;SR;61|) $))
                  (QSETREFV $ 231
                      (CONS (|dispatchFunction| |FS-;retract;SP;62|) $))
                  (QSETREFV $ 232
                      (CONS (|dispatchFunction|
                                |FS-;retractIfCan;SU;63|)
                            $))
                  (QSETREFV $ 234
                      (CONS (|dispatchFunction|
                                |FS-;retractIfCan;SU;64|)
                            $))
                  (QSETREFV $ 235
                      (CONS (|dispatchFunction| |FS-;eval;SLLS;65|) $))
                  (QSETREFV $ 236
                      (CONS (|dispatchFunction| |FS-;subst;SLLS;66|) $))
                  (QSETREFV $ 237
                      (CONS (|dispatchFunction|
                                |FS-;differentiate;SSS;67|)
                            $))
                  (QSETREFV $ 238
                      (CONS (|dispatchFunction| |FS-;coerce;SOf;68|) $))
                  (COND
                    ((|testBitVector| |pv$| 11)
                     (PROGN
                       (QSETREFV $ 239
                           (CONS (|dispatchFunction| |FS-;eval;SLS;69|)
                                 $))
                       (QSETREFV $ 240
                           (CONS (|dispatchFunction| |FS-;eval;2S;70|)
                                 $)))))
                  (QSETREFV $ 241
                      (CONS (|dispatchFunction| |FS-;eval;SLLLS;71|) $))
                  (QSETREFV $ 244
                      (CONS (|dispatchFunction| |FS-;isPlus;SU;72|) $))
                  (QSETREFV $ 246
                      (CONS (|dispatchFunction| |FS-;isTimes;SU;73|) $))
                  (QSETREFV $ 250
                      (CONS (|dispatchFunction| |FS-;isExpt;SU;74|) $))
                  (QSETREFV $ 253
                      (CONS (|dispatchFunction| |FS-;isPower;SU;75|) $))
                  (COND
                    ((|HasCategory| |#2|
                         '(|ConvertibleTo| (|Pattern| (|Integer|))))
                     (QSETREFV $ 256
                         (CONS (|dispatchFunction| |FS-;convert;SP;76|)
                               $))))
                  (COND
                    ((|HasCategory| |#2|
                         '(|ConvertibleTo| (|Pattern| (|Float|))))
                     (QSETREFV $ 259
                         (CONS (|dispatchFunction| |FS-;convert;SP;77|)
                               $))))
                  (COND
                    ((|testBitVector| |pv$| 1)
                     (QSETREFV $ 262
                         (CONS (|dispatchFunction| |FS-;isMult;SU;78|)
                               $))))))))))
        (COND
          ((|testBitVector| |pv$| 3)
           (QSETREFV $ 264
               (CONS (|dispatchFunction| |FS-;*;R2S;79|) $))))
        (COND
          ((|testBitVector| |pv$| 2)
           (PROGN
             (QSETREFV $ 227
                 (CONS (|dispatchFunction| |FS-;mainKernel;SU;80|) $))
             (QSETREFV $ 228
                 (CONS (|dispatchFunction| |FS-;kernels;SL;81|) $))
             (QSETREFV $ 271
                 (CONS (|dispatchFunction| |FS-;univariate;SKF;82|) $))
             (QSETREFV $ 244
                 (CONS (|dispatchFunction| |FS-;isPlus;SU;83|) $))
             (QSETREFV $ 246
                 (CONS (|dispatchFunction| |FS-;isTimes;SU;84|) $))
             (QSETREFV $ 250
                 (CONS (|dispatchFunction| |FS-;isExpt;SU;85|) $))
             (QSETREFV $ 253
                 (CONS (|dispatchFunction| |FS-;isPower;SU;86|) $))
             (QSETREFV $ 282
                 (CONS (|dispatchFunction| |FS-;denominator;2S;87|) $))
             (QSETREFV $ 287
                 (CONS (|dispatchFunction| |FS-;coerce;FS;88|) $))
             (QSETREFV $ 293
                 (CONS (|dispatchFunction| |FS-;coerce;FS;89|) $))
             (QSETREFV $ 299
                 (CONS (|dispatchFunction| |FS-;coerce;FS;90|) $))
             (QSETREFV $ 231
                 (CONS (|dispatchFunction| |FS-;retract;SP;91|) $))
             (QSETREFV $ 303
                 (CONS (|dispatchFunction| |FS-;retract;SF;92|) $))
             (QSETREFV $ 230
                 (CONS (|dispatchFunction| |FS-;retract;SR;93|) $))
             (QSETREFV $ 238
                 (CONS (|dispatchFunction| |FS-;coerce;SOf;94|) $))
             (QSETREFV $ 232
                 (CONS (|dispatchFunction| |FS-;retractIfCan;SU;95|) $))
             (QSETREFV $ 239
                 (CONS (|dispatchFunction| |FS-;eval;SLS;96|) $))
             (COND
               ((|testBitVector| |pv$| 11)
                (PROGN
                  (QSETREFV $ 240
                      (CONS (|dispatchFunction| |FS-;eval;2S;97|) $))
                  (QSETREFV $ 241
                      (CONS (|dispatchFunction| |FS-;eval;SLLLS;98|) $)))))
             (QSETREFV $ 237
                 (CONS (|dispatchFunction| |FS-;differentiate;SSS;99|)
                       $))
             (QSETREFV $ 235
                 (CONS (|dispatchFunction| |FS-;eval;SLLS;100|) $))
             (QSETREFV $ 236
                 (CONS (|dispatchFunction| |FS-;subst;SLLS;101|) $))
             (QSETREFV $ 318
                 (CONS (|dispatchFunction| |FS-;convert;FS;103|) $))
             (QSETREFV $ 234
                 (CONS (|dispatchFunction| |FS-;retractIfCan;SU;104|)
                       $))
             (QSETREFV $ 322
                 (CONS (|dispatchFunction| |FS-;retractIfCan;SU;105|)
                       $))
             (QSETREFV $ 327
                 (CONS (|dispatchFunction| |FS-;coerce;PS;106|) $))
             (COND
               ((|testBitVector| |pv$| 1)
                (PROGN
                  (QSETREFV $ 332
                      (CONS (|dispatchFunction| |FS-;coerce;FS;107|) $))
                  (QSETREFV $ 262
                      (CONS (|dispatchFunction| |FS-;isMult;SU;108|) $)))))
             (COND
               ((|HasCategory| |#2|
                    '(|ConvertibleTo| (|Pattern| (|Integer|))))
                (QSETREFV $ 256
                    (CONS (|dispatchFunction| |FS-;convert;SP;109|) $))))
             (COND
               ((|HasCategory| |#2|
                    '(|ConvertibleTo| (|Pattern| (|Float|))))
                (QSETREFV $ 259
                    (CONS (|dispatchFunction| |FS-;convert;SP;110|) $)))))))
        $)))) 

(MAKEPROP '|FunctionSpace&| '|infovec|
    (LIST '#(NIL NIL NIL NIL NIL NIL (|local| |#1|) (|local| |#2|)
             (|String|) (|Symbol|) (0 . |coerce|) 'ODD 'EVEN
             'SPECIALDIFF (|BasicOperator|) (|CommonOperators|)
             (5 . |operator|) '|opdiff| '|opquote|
             (|Union| 7 '"failed") (10 . |retractIfCan|) (|Boolean|)
             |FS-;ground?;SB;1| (15 . |retract|) |FS-;ground;SR;2|
             (|Kernel| 6) (20 . |kernel|) (|Kernel| $) (25 . |coerce|)
             |FS-;coerce;SS;3| (30 . |retract|) (|Union| 9 '"failed")
             (35 . |symbolIfCan|) |FS-;retract;SS;4| (|List| $)
             (40 . |applyQuote|) |FS-;applyQuote;S2S;5|
             |FS-;applyQuote;S3S;6| |FS-;applyQuote;S4S;7|
             |FS-;applyQuote;S5S;8| (46 . |coerce|) (51 . |elt|)
             |FS-;applyQuote;SLS;9| (57 . =) |FS-;belong?;BoB;10|
             (63 . |operator|) (|List| 6) (68 . |argument|)
             (73 . |kernel|) (79 . |is?|) |FS-;operator;2Bo;12|
             (85 . |second|) (90 . |third|) (95 . |eval|) (|InputForm|)
             (102 . |convert|) (107 . |convert|) (112 . |convert|)
             (|List| 9) (117 . |eval|) (123 . |eval|) (|List| 14)
             (129 . |eval|) (137 . |eval|) (|Mapping| 6 6)
             (|MakeUnaryCompiledFunction| 6 6 6)
             (145 . |compiledFunction|) (|Mapping| $ $) (|List| 67)
             (151 . |eval|) (158 . |eval|) (|None|)
             (166 . |setProperty|) (|List| 27) (173 . |tower|)
             |FS-;variables;SL;19| (|Union| 27 '"failed")
             (178 . |retractIfCan|) |FS-;retractIfCan;SU;20| '|gendiff|
             (|NonNegativeInteger|) (183 . |characteristic|)
             (187 . |characteristic|)
             (|SparseMultivariatePolynomial| 7 25) (191 . |coerce|)
             (|SparseMultivariatePolynomial| 7 27) (196 . |coerce|)
             (201 . |coerce|) (206 . |string|) (211 . |numer|)
             (216 . |numerator|) (221 . |first|) (|List| 80)
             (|Mapping| $ 34) (|List| 93) (226 . |eval|) (234 . |eval|)
             (242 . |eval|) (250 . |new|) (256 . |eval|)
             (263 . |unary?|) (268 . |has?|)
             (274 . |leadingCoefficient|) (279 . |Zero|) (283 . <)
             (289 . -) (294 . |elt|) (|ExpressionSpace&| 6)
             (300 . |elt|) (306 . |elt|) (312 . |eval|)
             (|Union| 25 '"failed") (320 . |mainVariable|)
             (|SparseUnivariatePolynomial| $) (325 . |univariate|)
             (|SparseUnivariatePolynomial| 6) (|Mapping| 6 83)
             (|SparseUnivariatePolynomial| 83)
             (|SparseUnivariatePolynomialFunctions2| 83 6)
             (331 . |map|) (337 . |name|) (|Integer|)
             (342 . |position|) (348 . |minIndex|) (353 . |elt|)
             (359 . |Zero|) (|Mapping| 6 46) (|List| 126) (363 . |elt|)
             (369 . |elt|) (375 . |Zero|) (379 . =) (385 . |degree|)
             (390 . **) (396 . |leadingCoefficient|) (401 . *)
             (407 . +) (413 . |reductum|) (|OutputForm|)
             (418 . |coerce|) (423 . |is?|) (|List| 138)
             (429 . |position|) (435 . |setelt|) (442 . |coerce|)
             (447 . |One|) (451 . |One|) (455 . |minIndex|)
             (460 . |coerce|) (465 . |hconcat|) (471 . |position|)
             (477 . |sub|) (483 . |differentiate|) (489 . |prefix|)
             (495 . |copy|) (500 . |setelt|) (507 . |member?|)
             (513 . |differentiate|) (519 . =) (525 . |subst|)
             (532 . |maxIndex|) (|Union| 127 '"failed")
             (|BasicOperatorFunctions1| 6) (537 . |derivative|)
             (542 . |elt|) (|Equation| 6) (548 . =) (|Equation| $)
             (554 . |subst|) (560 . |kernel|) (|Union| 71 '"failed")
             (566 . |property|) (|Polynomial| 7) (572 . |coerce|)
             (577 . |differentiate|) (583 . |retract|) (|Mapping| 7 7)
             (588 . |map|) (|List| 25) (594 . |variables|)
             (599 . |differentiate|) (605 . |coerce|) (|Mapping| 6 9)
             (|Mapping| 6 7)
             (|PolynomialCategoryLifting| (|IndexedExponents| 9) 9 7
                 172 6)
             (610 . |map|) (617 . |coerce|) (|Union| 21 '"failed")
             (|UserDefinedPartialOrdering| 9) (622 . |less?|) (628 . <)
             (634 . |retractIfCan|) (639 . |coerce|)
             (644 . |userOrdered?|) (648 . |coerce|)
             (653 . |outputForm|) (|ListToMap| 25 6) (659 . |match|)
             (|Mapping| 6 25)
             (|PolynomialCategoryLifting| (|IndexedExponents| 25) 25 7
                 83 6)
             (667 . |map|) (674 . |eval|) (681 . |map|)
             (687 . |setIntersection|) (693 . |eval|) (698 . |retract|)
             (703 . |member?|) (|InputFormFunctions1| 6)
             (709 . |interpret|) (714 . |coerce|) (|Mapping| 172 25)
             (|Mapping| 172 7)
             (|PolynomialCategoryLifting| (|IndexedExponents| 25) 25 7
                 83 172)
             (719 . |map|)
             (|Record| (|:| |var| 27) (|:| |exponent| 121))
             (|Union| 214 '"failed") (726 . |isExpt|) (731 . |isExpt|)
             (737 . |is?|) (743 . |isExpt|) (749 . |degree|)
             (754 . |reductum|) (759 . |leadingCoefficient|)
             (764 . |zero?|) (|Union| 121 '"failed")
             (769 . |retractIfCan|) (774 . |evaluate|)
             (780 . |mainKernel|) (785 . |kernels|) (790 . |retract|)
             (795 . |retract|) (800 . |retract|) (805 . |retractIfCan|)
             (|Union| 172 '"failed") (810 . |retractIfCan|)
             (815 . |eval|) (822 . |subst|) (829 . |differentiate|)
             (835 . |coerce|) (840 . |eval|) (846 . |eval|)
             (851 . |eval|) (|Union| 34 '"failed") (859 . |isPlus|)
             (864 . |isPlus|) (869 . |isTimes|) (874 . |isTimes|)
             (|Record| (|:| |var| 25) (|:| |exponent| 80))
             (|Union| 247 '"failed") (879 . |isExpt|) (884 . |isExpt|)
             (|Record| (|:| |val| $) (|:| |exponent| 121))
             (|Union| 251 '"failed") (889 . |isPower|) (|Pattern| 121)
             (894 . |convert|) (899 . |convert|) (|Pattern| (|Float|))
             (904 . |convert|) (909 . |convert|)
             (|Record| (|:| |coef| 121) (|:| |var| 27))
             (|Union| 260 '"failed") (914 . |isMult|) (919 . |coerce|)
             (924 . *)
             (|PolynomialCategoryQuotientFunctions|
                 (|IndexedExponents| 25) 25 7 83 6)
             (930 . |mainVariable|) (935 . |variables|)
             (|Fraction| 115) (940 . |univariate|) (|Fraction| 113)
             (946 . |univariate|) (|Union| 46 '"failed")
             (952 . |isPlus|) (957 . |isTimes|)
             (|Record| (|:| |var| 25) (|:| |exponent| 121))
             (|Union| 275 '"failed") (962 . |isExpt|)
             (|Record| (|:| |val| 6) (|:| |exponent| 121))
             (|Union| 278 '"failed") (967 . |isPower|) (972 . |denom|)
             (977 . |denominator|) (|Fraction| 7) (982 . |numer|)
             (987 . |denom|) (992 . /) (998 . |coerce|)
             (|Fraction| 172) (1003 . |numer|) (1008 . |coerce|)
             (1013 . |denom|) (1018 . /) (1024 . |coerce|)
             (|Polynomial| 283) (|Fraction| 294) (1029 . |numer|)
             (1034 . |coerce|) (1039 . |denom|) (1044 . |coerce|)
             (1049 . |retract|) (1054 . |retract|) (1059 . /)
             (1065 . |retract|) (|Union| $ '"failed") (1070 . |exquo|)
             (1076 . |One|) (1080 . =) (1086 . /) (1092 . -)
             (1098 . **) (1104 . |paren|) (|Factored| 6)
             (1109 . |unit|)
             (|Record| (|:| |factor| 6) (|:| |exponent| 121))
             (|List| 314) (1114 . |factors|) (|Factored| $)
             (1119 . |convert|) (|Union| 288 '"failed")
             (1124 . |retractIfCan|) (1129 . |retractIfCan|)
             (1134 . |retractIfCan|) (1139 . |coerce|)
             (|Mapping| 6 283)
             (|PolynomialCategoryLifting| (|IndexedExponents| 9) 9 283
                 294 6)
             (1144 . |map|) (1151 . |coerce|) (|Fraction| 121)
             (1156 . |numer|) (1161 . |coerce|) (1166 . |denom|)
             (1171 . |coerce|) (1176 . |exquo|) (1182 . /) (1188 . /)
             (|PositiveInteger|) (|Union| 328 '"failed") (|List| 167))
          '#(|variables| 1194 |univariate| 1199 |subst| 1205
             |retractIfCan| 1212 |retract| 1232 |operator| 1252
             |numerator| 1257 |mainKernel| 1262 |kernels| 1267
             |isTimes| 1272 |isPower| 1277 |isPlus| 1282 |isMult| 1287
             |isExpt| 1292 |ground?| 1309 |ground| 1314 |eval| 1319
             |elt| 1398 |differentiate| 1404 |denominator| 1410
             |convert| 1415 |coerce| 1430 |characteristic| 1475
             |belong?| 1479 |applyQuote| 1484 * 1520)
          'NIL
          (CONS (|makeByteWordVec2| 1 'NIL)
                (CONS '#()
                      (CONS '#()
                            (|makeByteWordVec2| 335
                                '(1 9 0 8 10 1 15 14 9 16 1 6 19 0 20 1
                                  6 7 0 23 1 25 0 9 26 1 6 0 27 28 1 6
                                  27 0 30 1 25 31 0 32 2 6 0 9 34 35 1
                                  6 0 9 40 2 6 0 14 34 41 2 14 21 0 0
                                  43 1 25 14 0 45 1 25 46 0 47 2 6 0 14
                                  34 48 2 14 21 0 9 49 1 46 6 0 51 1 46
                                  6 0 52 3 6 0 0 27 0 53 1 9 54 0 55 1
                                  54 0 34 56 1 6 54 0 57 2 6 0 0 58 59
                                  2 0 0 0 9 60 4 6 0 0 61 34 9 62 4 0 0
                                  0 14 0 9 63 2 65 64 6 9 66 3 6 0 0 61
                                  68 69 4 0 0 0 61 34 9 70 3 14 0 0 9
                                  71 72 1 6 73 0 74 1 6 76 0 77 0 7 80
                                  81 0 0 80 82 1 83 0 25 84 1 6 0 85 86
                                  1 0 0 27 87 1 9 8 0 88 1 6 85 0 89 1
                                  0 0 0 90 1 46 6 0 91 4 6 0 0 58 92 94
                                  95 4 0 0 0 9 80 67 96 4 0 0 0 9 80 93
                                  97 2 92 0 80 80 98 3 0 0 0 58 94 99 1
                                  14 21 0 100 2 14 21 0 9 101 1 83 7 0
                                  102 0 7 0 103 2 7 21 0 0 104 1 6 0 0
                                  105 2 6 0 14 0 106 2 107 0 14 34 108
                                  2 0 0 14 34 109 4 0 0 0 58 92 68 110
                                  1 83 111 0 112 2 83 113 0 25 114 2
                                  118 115 116 117 119 1 14 9 0 120 2 58
                                  121 9 0 122 1 58 121 0 123 2 115 6 0
                                  6 124 0 6 0 125 2 127 126 0 121 128 2
                                  92 80 0 121 129 0 115 0 130 2 115 21
                                  0 0 131 1 115 80 0 132 2 6 0 0 80 133
                                  1 115 6 0 134 2 6 0 0 0 135 2 6 0 0 0
                                  136 1 115 0 0 137 1 6 138 0 139 2 25
                                  21 0 14 140 2 141 121 138 0 142 3 141
                                  138 0 121 138 143 1 9 138 0 144 0 6 0
                                  145 0 7 0 146 1 46 121 0 147 1 121
                                  138 0 148 2 138 0 0 0 149 2 46 121 6
                                  0 150 2 138 0 0 0 151 2 138 0 0 80
                                  152 2 138 0 0 34 153 1 46 0 0 154 3
                                  46 6 0 121 6 155 2 46 21 6 0 156 2 6
                                  0 0 9 157 2 6 21 0 0 158 3 6 0 0 73
                                  34 159 1 46 121 0 160 1 162 161 14
                                  163 2 46 6 0 121 164 2 165 0 6 6 166
                                  2 6 0 0 167 168 2 6 0 14 0 169 2 14
                                  170 0 9 171 1 172 0 7 173 2 172 0 0 9
                                  174 1 172 7 0 175 2 83 0 176 0 177 1
                                  83 178 0 179 2 83 0 0 25 180 1 6 0 7
                                  181 3 184 6 182 183 172 185 1 0 0 172
                                  186 2 188 187 9 9 189 2 25 21 0 0 190
                                  1 83 19 0 191 1 7 138 0 192 0 188 21
                                  193 1 25 138 0 194 2 115 138 0 138
                                  195 4 196 6 178 46 25 6 197 3 199 6
                                  198 183 83 200 3 6 0 0 73 34 201 2 6
                                  0 67 27 202 2 178 0 0 0 203 1 6 0 0
                                  204 1 6 9 0 205 2 58 21 9 0 206 1 207
                                  6 54 208 1 172 0 9 209 3 212 172 210
                                  211 83 213 1 6 215 0 216 2 0 215 0 14
                                  217 2 25 21 0 9 218 2 0 215 0 9 219 1
                                  117 80 0 220 1 117 0 0 221 1 117 83 0
                                  222 1 83 21 0 223 1 7 224 0 225 2 162
                                  14 14 126 226 1 0 76 0 227 1 0 73 0
                                  228 1 83 7 0 229 1 0 7 0 230 1 0 172
                                  0 231 1 0 19 0 232 1 0 233 0 234 3 0
                                  0 0 73 34 235 3 0 0 0 73 34 236 2 0 0
                                  0 9 237 1 0 138 0 238 2 0 0 0 58 239
                                  1 0 0 0 240 4 0 0 0 58 92 94 241 1 83
                                  242 0 243 1 0 242 0 244 1 83 242 0
                                  245 1 0 242 0 246 1 83 248 0 249 1 0
                                  215 0 250 1 0 252 0 253 1 83 254 0
                                  255 1 0 254 0 256 1 83 257 0 258 1 0
                                  257 0 259 1 0 261 0 262 1 83 0 7 263
                                  2 0 0 7 0 264 1 265 111 6 266 1 265
                                  178 6 267 2 265 268 6 25 269 2 0 270
                                  0 27 271 1 265 272 6 273 1 265 272 6
                                  274 1 265 276 6 277 1 265 279 6 280 1
                                  6 85 0 281 1 0 0 0 282 1 283 7 0 284
                                  1 283 7 0 285 2 6 0 85 85 286 1 0 0
                                  283 287 1 288 172 0 289 1 6 0 172 290
                                  1 288 172 0 291 2 6 0 0 0 292 1 0 0
                                  288 293 1 295 294 0 296 1 6 0 294 297
                                  1 295 294 0 298 1 0 0 295 299 1 6 288
                                  0 300 1 288 172 0 301 2 288 0 172 172
                                  302 1 0 288 0 303 2 7 304 0 0 305 0
                                  83 0 306 2 83 21 0 0 307 2 138 0 0 0
                                  308 2 6 0 0 0 309 2 6 0 0 121 310 1 6
                                  0 0 311 1 312 6 0 313 1 312 315 0 316
                                  1 0 0 317 318 1 6 319 0 320 1 288 233
                                  0 321 1 0 319 0 322 1 6 0 283 323 3
                                  325 6 182 324 294 326 1 0 0 294 327 1
                                  328 121 0 329 1 83 0 121 330 1 328
                                  121 0 331 1 0 0 328 332 2 121 304 0 0
                                  333 2 254 0 0 0 334 2 257 0 0 0 335 1
                                  0 58 0 75 2 0 270 0 27 271 3 0 0 0 73
                                  34 236 1 0 233 0 234 1 0 319 0 322 1
                                  0 19 0 232 1 0 31 0 78 1 0 172 0 231
                                  1 0 288 0 303 1 0 7 0 230 1 0 9 0 33
                                  1 0 14 14 50 1 0 0 0 90 1 0 76 0 227
                                  1 0 73 0 228 1 0 242 0 246 1 0 252 0
                                  253 1 0 242 0 244 1 0 261 0 262 2 0
                                  215 0 9 219 2 0 215 0 14 217 1 0 215
                                  0 250 1 0 21 0 22 1 0 7 0 24 4 0 0 0
                                  9 80 93 97 4 0 0 0 9 80 67 96 4 0 0 0
                                  58 92 94 241 4 0 0 0 58 92 68 110 4 0
                                  0 0 61 34 9 70 4 0 0 0 14 0 9 63 2 0
                                  0 0 58 239 1 0 0 0 240 2 0 0 0 9 60 3
                                  0 0 0 58 94 99 3 0 0 0 73 34 235 2 0
                                  0 14 34 109 2 0 0 0 9 237 1 0 0 0 282
                                  1 0 0 317 318 1 0 257 0 259 1 0 254 0
                                  256 1 0 0 328 332 1 0 0 172 186 1 0 0
                                  288 293 1 0 0 295 299 1 0 0 294 327 1
                                  0 0 283 287 1 0 0 9 29 1 0 138 0 238
                                  1 0 0 27 87 0 0 80 82 1 0 21 14 44 5
                                  0 0 9 0 0 0 0 39 2 0 0 9 34 42 4 0 0
                                  9 0 0 0 38 2 0 0 9 0 36 3 0 0 9 0 0
                                  37 2 0 0 7 0 264)))))
          '|lookupComplete|)) 
