
(/VERSIONCHECK 2) 

(DEFUN |STTAYLOR;zro| ($) (SPADCALL (QREFELT $ 8))) 

(DEFUN |STTAYLOR;+;3S;2| (|x| |y| $)
  (PROG ()
    (RETURN
     (SPADCALL (CONS #'|STTAYLOR;+;3S;2!2| (VECTOR |x| $ |y|))
               (QREFELT $ 20))))) 

(DEFUN |STTAYLOR;+;3S;2!2| ($$)
  (PROG (|y| $ |x|)
    (LETT |y| (QREFELT $$ 2) . #1=(|STTAYLOR;+;3S;2|))
    (LETT $ (QREFELT $$ 1) . #1#)
    (LETT |x| (QREFELT $$ 0) . #1#)
    (RETURN
     (PROGN
      (PROG ()
        (RETURN
         (COND ((SPADCALL |y| (QREFELT $ 10)) |x|)
               ((SPADCALL |x| (QREFELT $ 10)) |y|)
               ((SPADCALL |x| (SPADCALL |x| (QREFELT $ 11)) (QREFELT $ 12))
                (SPADCALL (CONS #'|STTAYLOR;+;3S;2!0| (VECTOR $ |x|)) |y|
                          (QREFELT $ 16)))
               ((SPADCALL |y| (SPADCALL |y| (QREFELT $ 11)) (QREFELT $ 12))
                (SPADCALL (CONS #'|STTAYLOR;+;3S;2!1| (VECTOR $ |y|)) |x|
                          (QREFELT $ 16)))
               ('T
                (SPADCALL
                 (SPADCALL (SPADCALL |x| (QREFELT $ 13))
                           (SPADCALL |y| (QREFELT $ 13)) (QREFELT $ 14))
                 (SPADCALL (SPADCALL |x| (QREFELT $ 11))
                           (SPADCALL |y| (QREFELT $ 11)) (QREFELT $ 17))
                 (QREFELT $ 18)))))))))) 

(DEFUN |STTAYLOR;+;3S;2!1| (|z| $$)
  (PROG (|y| $)
    (LETT |y| (QREFELT $$ 1) NIL)
    (LETT $ (QREFELT $$ 0) NIL)
    (RETURN
     (PROGN (SPADCALL (SPADCALL |y| (QREFELT $ 13)) |z| (QREFELT $ 14)))))) 

(DEFUN |STTAYLOR;+;3S;2!0| (|z| $$)
  (PROG (|x| $)
    (LETT |x| (QREFELT $$ 1) NIL)
    (LETT $ (QREFELT $$ 0) NIL)
    (RETURN
     (PROGN (SPADCALL (SPADCALL |x| (QREFELT $ 13)) |z| (QREFELT $ 14)))))) 

(DEFUN |STTAYLOR;-;3S;3| (|x| |y| $)
  (PROG ()
    (RETURN
     (SPADCALL (CONS #'|STTAYLOR;-;3S;3!2| (VECTOR |x| $ |y|))
               (QREFELT $ 20))))) 

(DEFUN |STTAYLOR;-;3S;3!2| ($$)
  (PROG (|y| $ |x|)
    (LETT |y| (QREFELT $$ 2) . #1=(|STTAYLOR;-;3S;3|))
    (LETT $ (QREFELT $$ 1) . #1#)
    (LETT |x| (QREFELT $$ 0) . #1#)
    (RETURN
     (PROGN
      (PROG ()
        (RETURN
         (COND ((SPADCALL |y| (QREFELT $ 10)) |x|)
               ((SPADCALL |x| (QREFELT $ 10)) (SPADCALL |y| (QREFELT $ 21)))
               ((SPADCALL |x| (SPADCALL |x| (QREFELT $ 11)) (QREFELT $ 12))
                (SPADCALL (CONS #'|STTAYLOR;-;3S;3!0| (VECTOR $ |x|)) |y|
                          (QREFELT $ 16)))
               ((SPADCALL |y| (SPADCALL |y| (QREFELT $ 11)) (QREFELT $ 12))
                (SPADCALL (CONS #'|STTAYLOR;-;3S;3!1| (VECTOR $ |y|)) |x|
                          (QREFELT $ 16)))
               ('T
                (SPADCALL
                 (SPADCALL (SPADCALL |x| (QREFELT $ 13))
                           (SPADCALL |y| (QREFELT $ 13)) (QREFELT $ 22))
                 (SPADCALL (SPADCALL |x| (QREFELT $ 11))
                           (SPADCALL |y| (QREFELT $ 11)) (QREFELT $ 23))
                 (QREFELT $ 18)))))))))) 

(DEFUN |STTAYLOR;-;3S;3!1| (|z| $$)
  (PROG (|y| $)
    (LETT |y| (QREFELT $$ 1) NIL)
    (LETT $ (QREFELT $$ 0) NIL)
    (RETURN
     (PROGN (SPADCALL |z| (SPADCALL |y| (QREFELT $ 13)) (QREFELT $ 22)))))) 

(DEFUN |STTAYLOR;-;3S;3!0| (|z| $$)
  (PROG (|x| $)
    (LETT |x| (QREFELT $$ 1) NIL)
    (LETT $ (QREFELT $$ 0) NIL)
    (RETURN
     (PROGN (SPADCALL (SPADCALL |x| (QREFELT $ 13)) |z| (QREFELT $ 22)))))) 

(DEFUN |STTAYLOR;-;2S;4| (|y| $) (SPADCALL (ELT $ 24) |y| (QREFELT $ 16))) 

(DEFUN |STTAYLOR;*;A2S;5| (|s| |x| $)
  (PROG ()
    (RETURN
     (COND ((SPADCALL |s| (QREFELT $ 25)) (|STTAYLOR;zro| $))
           ('T
            (SPADCALL (CONS #'|STTAYLOR;*;A2S;5!0| (VECTOR $ |s|)) |x|
                      (QREFELT $ 16))))))) 

(DEFUN |STTAYLOR;*;A2S;5!0| (|z| $$)
  (PROG (|s| $)
    (LETT |s| (QREFELT $$ 1) . #1=(|STTAYLOR;*;A2S;5|))
    (LETT $ (QREFELT $$ 0) . #1#)
    (RETURN (PROGN (SPADCALL |s| |z| (QREFELT $ 26)))))) 

(DEFUN |STTAYLOR;*;SAS;6| (|x| |s| $)
  (PROG ()
    (RETURN
     (COND ((SPADCALL |s| (QREFELT $ 25)) (|STTAYLOR;zro| $))
           ('T
            (SPADCALL (CONS #'|STTAYLOR;*;SAS;6!0| (VECTOR $ |s|)) |x|
                      (QREFELT $ 16))))))) 

(DEFUN |STTAYLOR;*;SAS;6!0| (|z| $$)
  (PROG (|s| $)
    (LETT |s| (QREFELT $$ 1) . #1=(|STTAYLOR;*;SAS;6|))
    (LETT $ (QREFELT $$ 0) . #1#)
    (RETURN (PROGN (SPADCALL |z| |s| (QREFELT $ 26)))))) 

(DEFUN |STTAYLOR;iDiv| (|x| |y| |ry0| $)
  (PROG ()
    (RETURN
     (SEQ
      (SPADCALL (CONS #'|STTAYLOR;iDiv!0| (VECTOR |y| |ry0| $ |x|))
                (QREFELT $ 20)))))) 

(DEFUN |STTAYLOR;iDiv!0| ($$)
  (PROG (|x| $ |ry0| |y|)
    (LETT |x| (QREFELT $$ 3) . #1=(|STTAYLOR;iDiv|))
    (LETT $ (QREFELT $$ 2) . #1#)
    (LETT |ry0| (QREFELT $$ 1) . #1#)
    (LETT |y| (QREFELT $$ 0) . #1#)
    (RETURN
     (PROGN
      (PROG (|c0|)
        (RETURN
         (SEQ
          (COND ((SPADCALL |x| (QREFELT $ 10)) (SPADCALL (QREFELT $ 8)))
                ('T
                 (SEQ
                  (LETT |c0|
                        (SPADCALL (SPADCALL |x| (QREFELT $ 13)) |ry0|
                                  (QREFELT $ 26))
                        NIL)
                  (EXIT
                   (SPADCALL |c0|
                             (|STTAYLOR;iDiv|
                              (SPADCALL (SPADCALL |x| (QREFELT $ 11))
                                        (SPADCALL |c0|
                                                  (SPADCALL |y| (QREFELT $ 11))
                                                  (QREFELT $ 27))
                                        (QREFELT $ 23))
                              |y| |ry0| $)
                             (QREFELT $ 18))))))))))))) 

(DEFUN |STTAYLOR;exquo;2SU;8| (|x| |y| $)
  (PROG (|ry0| #1=#:G1952 #2=#:G1965 |n|)
    (RETURN
     (SEQ
      (EXIT
       (SEQ
        (SEQ
         (EXIT
          (SEQ (LETT |n| 1 . #3=(|STTAYLOR;exquo;2SU;8|)) G190 NIL
               (SEQ
                (EXIT
                 (COND
                  ((OR (< 1000 |n|) (SPADCALL |y| (QREFELT $ 10)))
                   (PROGN (LETT #2# (CONS 1 "failed") . #3#) (GO #2#)))
                  ((SPADCALL |x| (QREFELT $ 10))
                   (PROGN
                    (LETT #2# (CONS 0 (SPADCALL (QREFELT $ 8))) . #3#)
                    (GO #2#)))
                  ((SPADCALL (SPADCALL |y| (QREFELT $ 13))
                             (|spadConstant| $ 29) (QREFELT $ 30))
                   (COND
                    ((SPADCALL (SPADCALL |x| (QREFELT $ 13))
                               (|spadConstant| $ 29) (QREFELT $ 30))
                     (SEQ (LETT |x| (SPADCALL |x| (QREFELT $ 11)) . #3#)
                          (EXIT
                           (LETT |y| (SPADCALL |y| (QREFELT $ 11)) . #3#))))
                    ('T (PROGN (LETT #2# (CONS 1 "failed") . #3#) (GO #2#)))))
                  ('T
                   (PROGN
                    (LETT #1# "first entry in y is non-zero" . #3#)
                    (GO #1#))))))
               (LETT |n| (QSADD1 |n|) . #3#) (GO G190) G191 (EXIT NIL)))
         #1# (EXIT #1#))
        (LETT |ry0| (SPADCALL (SPADCALL |y| (QREFELT $ 13)) (QREFELT $ 32))
              . #3#)
        (EXIT
         (COND ((QEQCAR |ry0| 1) (CONS 1 "failed"))
               ((SPADCALL (SPADCALL |y| (QREFELT $ 11)) (QREFELT $ 10))
                (CONS 0
                      (SPADCALL
                       (CONS #'|STTAYLOR;exquo;2SU;8!0| (VECTOR $ |ry0|)) |x|
                       (QREFELT $ 16))))
               ('T (CONS 0 (|STTAYLOR;iDiv| |x| |y| (QCDR |ry0|) $)))))))
      #2# (EXIT #2#))))) 

(DEFUN |STTAYLOR;exquo;2SU;8!0| (|z| $$)
  (PROG (|ry0| $)
    (LETT |ry0| (QREFELT $$ 1) . #1=(|STTAYLOR;exquo;2SU;8|))
    (LETT $ (QREFELT $$ 0) . #1#)
    (RETURN (PROGN (SPADCALL |z| (QCDR |ry0|) (QREFELT $ 26)))))) 

(DEFUN |STTAYLOR;/;3S;9| (|x| |y| $)
  (PROG ()
    (RETURN
     (SEQ
      (SPADCALL (CONS #'|STTAYLOR;/;3S;9!1| (VECTOR |x| $ |y|))
                (QREFELT $ 20)))))) 

(DEFUN |STTAYLOR;/;3S;9!1| ($$)
  (PROG (|y| $ |x|)
    (LETT |y| (QREFELT $$ 2) . #1=(|STTAYLOR;/;3S;9|))
    (LETT $ (QREFELT $$ 1) . #1#)
    (LETT |x| (QREFELT $$ 0) . #1#)
    (RETURN
     (PROGN
      (PROG (|ry0|)
        (RETURN
         (SEQ
          (COND ((SPADCALL |y| (QREFELT $ 10)) (|error| "/: division by zero"))
                ((SPADCALL |x| (QREFELT $ 10)) (SPADCALL (QREFELT $ 8)))
                ('T
                 (SEQ
                  (LETT |ry0|
                        (SPADCALL (SPADCALL |y| (QREFELT $ 13)) (QREFELT $ 32))
                        NIL)
                  (EXIT
                   (COND
                    ((QEQCAR |ry0| 1)
                     (|error| "/: second argument is not invertible"))
                    ((SPADCALL (SPADCALL |y| (QREFELT $ 11)) (QREFELT $ 10))
                     (SPADCALL (CONS #'|STTAYLOR;/;3S;9!0| (VECTOR $ |ry0|))
                               |x| (QREFELT $ 16)))
                    ('T (|STTAYLOR;iDiv| |x| |y| (QCDR |ry0|) $)))))))))))))) 

(DEFUN |STTAYLOR;/;3S;9!0| (|z| $$)
  (PROG (|ry0| $)
    (LETT |ry0| (QREFELT $$ 1) NIL)
    (LETT $ (QREFELT $$ 0) NIL)
    (RETURN (PROGN (SPADCALL |z| (QCDR |ry0|) (QREFELT $ 26)))))) 

(DEFUN |STTAYLOR;recip;SU;10| (|x| $)
  (PROG (|rh| |rh1|)
    (RETURN
     (SEQ
      (COND ((SPADCALL |x| (QREFELT $ 10)) (CONS 1 "failed"))
            (#1='T
             (SEQ
              (LETT |rh1|
                    (SPADCALL (SPADCALL |x| (QREFELT $ 13)) (QREFELT $ 32))
                    . #2=(|STTAYLOR;recip;SU;10|))
              (EXIT
               (COND ((QEQCAR |rh1| 1) (CONS 1 "failed"))
                     (#1#
                      (SEQ (LETT |rh| (QCDR |rh1|) . #2#)
                           (EXIT
                            (CONS 0
                                  (SPADCALL
                                   (CONS #'|STTAYLOR;recip;SU;10!0|
                                         (VECTOR $ |x| |rh|))
                                   (QREFELT $ 20))))))))))))))) 

(DEFUN |STTAYLOR;recip;SU;10!0| ($$)
  (PROG (|rh| |x| $)
    (LETT |rh| (QREFELT $$ 2) . #1=(|STTAYLOR;recip;SU;10|))
    (LETT |x| (QREFELT $$ 1) . #1#)
    (LETT $ (QREFELT $$ 0) . #1#)
    (RETURN
     (PROGN
      (SPADCALL |rh|
                (|STTAYLOR;iDiv|
                 (SPADCALL
                  (SPADCALL |rh| (SPADCALL |x| (QREFELT $ 11)) (QREFELT $ 27))
                  (QREFELT $ 21))
                 |x| |rh| $)
                (QREFELT $ 18)))))) 

(DEFUN |STTAYLOR;rp| (|z| |s| $)
  (COND ((< 0 |z|) (CONS |s| (|STTAYLOR;rp| (- |z| 1) |s| $))) ('T NIL))) 

(DEFUN |STTAYLOR;rpSt| (|z| |s| $)
  (PROG ()
    (RETURN
     (SPADCALL (CONS #'|STTAYLOR;rpSt!0| (VECTOR |s| |z| $)) (QREFELT $ 20))))) 

(DEFUN |STTAYLOR;rpSt!0| ($$)
  (PROG ($ |z| |s|)
    (LETT $ (QREFELT $$ 2) . #1=(|STTAYLOR;rpSt|))
    (LETT |z| (QREFELT $$ 1) . #1#)
    (LETT |s| (QREFELT $$ 0) . #1#)
    (RETURN
     (PROGN
      (COND
       ((SPADCALL (|spadConstant| $ 39) |z| (QREFELT $ 40))
        (SPADCALL |s|
                  (|STTAYLOR;rpSt|
                   (SPADCALL |z| (|spadConstant| $ 41) (QREFELT $ 42)) |s| $)
                  (QREFELT $ 18)))
       ('T (SPADCALL (QREFELT $ 8)))))))) 

(DEFUN |STTAYLOR;monom;AIS;13| (|s| |z| $)
  (COND
   ((< |z| 0) (|error| "monom: cannot create monomial of negative degree"))
   ('T
    (SPADCALL (|STTAYLOR;rpSt| |z| (|spadConstant| $ 29) $)
              (SPADCALL |s| (|STTAYLOR;zro| $) (QREFELT $ 18))
              (QREFELT $ 43))))) 

(DEFUN |STTAYLOR;nnintegers| (|zz| $)
  (SPADCALL (CONS #'|STTAYLOR;nnintegers!0| $) |zz| (QREFELT $ 50))) 

(DEFUN |STTAYLOR;nnintegers!0| (|y| $)
  (SPADCALL |y| (|spadConstant| $ 46) (QREFELT $ 47))) 

(DEFUN |STTAYLOR;integers;IS;15| (|z| $)
  (SPADCALL (CONS #'|STTAYLOR;integers;IS;15!0| $) |z| (QREFELT $ 54))) 

(DEFUN |STTAYLOR;integers;IS;15!0| (|y| $)
  (SPADCALL |y| (|spadConstant| $ 41) (QREFELT $ 51))) 

(DEFUN |STTAYLOR;oddintegers;IS;16| (|z| $)
  (SPADCALL (CONS #'|STTAYLOR;oddintegers;IS;16!0| $) |z| (QREFELT $ 54))) 

(DEFUN |STTAYLOR;oddintegers;IS;16!0| (|y| $) (SPADCALL |y| 2 (QREFELT $ 51))) 

(DEFUN |STTAYLOR;int;AS;17| (|s| $)
  (SPADCALL (CONS #'|STTAYLOR;int;AS;17!0| $) |s| (QREFELT $ 57))) 

(DEFUN |STTAYLOR;int;AS;17!0| (|y| $)
  (SPADCALL |y| (|spadConstant| $ 37) (QREFELT $ 14))) 

(DEFUN |STTAYLOR;stmult| (|n0| |x0| |y0| |ll0| $)
  (PROG ()
    (RETURN
     (SEQ
      (SPADCALL (CONS #'|STTAYLOR;stmult!0| (VECTOR $ |ll0| |n0| |y0| |x0|))
                (QREFELT $ 20)))))) 

(DEFUN |STTAYLOR;stmult!0| ($$)
  (PROG (|x0| |y0| |n0| |ll0| $)
    (LETT |x0| (QREFELT $$ 4) . #1=(|STTAYLOR;stmult|))
    (LETT |y0| (QREFELT $$ 3) . #1#)
    (LETT |n0| (QREFELT $$ 2) . #1#)
    (LETT |ll0| (QREFELT $$ 1) . #1#)
    (LETT $ (QREFELT $$ 0) . #1#)
    (RETURN
     (PROGN
      (PROG (|x| |c| |y| |ll| |n| |i| #2=#:G2084 #3=#:G2080 |res| |llp| |xp|)
        (RETURN
         (SEQ
          (EXIT
           (SEQ (LETT |x| |x0| NIL) (LETT |y| |y0| NIL) (LETT |n| |n0| NIL)
                (LETT |ll| |ll0| NIL)
                (COND
                 ((SPADCALL |y| (QREFELT $ 10))
                  (COND
                   ((OR (SPADCALL |n| (|spadConstant| $ 62) (QREFELT $ 40))
                        (SPADCALL |x| (QREFELT $ 10)))
                    (PROGN (LETT #2# (SPADCALL (QREFELT $ 8)) NIL) (GO #2#)))
                   ('T (LETT |x| (SPADCALL |x| (QREFELT $ 11)) NIL))))
                 ('T
                  (SEQ (LETT |c| (SPADCALL |y| (QREFELT $ 13)) NIL)
                       (LETT |y| (SPADCALL |y| (QREFELT $ 11)) NIL)
                       (EXIT
                        (COND
                         ((SPADCALL |n| (|spadConstant| $ 62) (QREFELT $ 40))
                          (COND
                           ((SPADCALL |c| (|spadConstant| $ 29) (QREFELT $ 30))
                            (PROGN
                             (LETT #2#
                                   (SPADCALL (|spadConstant| $ 29)
                                             (|STTAYLOR;stmult| |n| |x| |y|
                                              |ll| $)
                                             (QREFELT $ 18))
                                   NIL)
                             (GO #2#)))
                           ('T
                            (SEQ
                             (LETT |ll| (SPADCALL |c| |ll| (QREFELT $ 60)) NIL)
                             (EXIT
                              (LETT |n|
                                    (SPADCALL |n| (|spadConstant| $ 68)
                                              (QREFELT $ 51))
                                    NIL))))))
                         ('T
                          (SEQ
                           (LETT |ll| (SPADCALL |c| |ll| (QREFELT $ 60)) NIL)
                           (EXIT
                            (LETT |n|
                                  (SPADCALL |n| (|spadConstant| $ 68)
                                            (QREFELT $ 51))
                                  NIL)))))))))
                (LETT |res| (|spadConstant| $ 29) NIL) (LETT |xp| |x| NIL)
                (LETT |llp| |ll| NIL)
                (SEQ
                 (EXIT
                  (SEQ (LETT |i| (|spadConstant| $ 62) NIL) G190
                       (COND ((> |i| |n|) (GO G191)))
                       (SEQ
                        (EXIT
                         (COND
                          ((SPADCALL |xp| (QREFELT $ 10))
                           (COND
                            ((SPADCALL |i| (|spadConstant| $ 63)
                                       (QREFELT $ 64))
                             (PROGN
                              (LETT #2# (SPADCALL (QREFELT $ 8)) NIL)
                              (GO #2#)))
                            ('T (PROGN (LETT #3# |$NoValue| NIL) (GO #3#)))))
                          ('T
                           (SEQ
                            (LETT |res|
                                  (SPADCALL |res|
                                            (SPADCALL
                                             (SPADCALL |xp| (QREFELT $ 13))
                                             (SPADCALL |llp| (QREFELT $ 65))
                                             (QREFELT $ 26))
                                            (QREFELT $ 14))
                                  NIL)
                            (LETT |llp| (SPADCALL |llp| (QREFELT $ 66)) NIL)
                            (EXIT
                             (LETT |xp| (SPADCALL |xp| (QREFELT $ 11))
                                   NIL)))))))
                       (LETT |i| (+ |i| 1) NIL) (GO G190) G191 (EXIT NIL)))
                 #3# (EXIT #3#))
                (COND
                 ((SPADCALL (SPADCALL |x| (QREFELT $ 11)) (QREFELT $ 67))
                  (COND
                   ((SPADCALL |y| (QREFELT $ 67))
                    (EXIT
                     (SPADCALL |res| (SPADCALL (QREFELT $ 8))
                               (QREFELT $ 18)))))))
                (EXIT
                 (SPADCALL |res| (|STTAYLOR;stmult| |n| |x| |y| |ll| $)
                           (QREFELT $ 18)))))
          #2# (EXIT #2#)))))))) 

(DEFUN |STTAYLOR;*;3S;19| (|x| |y| $)
  (PROG ()
    (RETURN
     (SPADCALL (CONS #'|STTAYLOR;*;3S;19!0| (VECTOR |x| $ |y|))
               (QREFELT $ 20))))) 

(DEFUN |STTAYLOR;*;3S;19!0| ($$)
  (PROG (|y| $ |x|)
    (LETT |y| (QREFELT $$ 2) . #1=(|STTAYLOR;*;3S;19|))
    (LETT $ (QREFELT $$ 1) . #1#)
    (LETT |x| (QREFELT $$ 0) . #1#)
    (RETURN
     (PROGN
      (COND
       ((OR (SPADCALL |y| (QREFELT $ 10)) (SPADCALL |x| (QREFELT $ 10)))
        (|STTAYLOR;zro| $))
       ('T
        (|STTAYLOR;stmult| (SPADCALL (|spadConstant| $ 41) (QREFELT $ 69)) |x|
         |y| NIL $))))))) 

(DEFUN |STTAYLOR;mapmult;3S;20| (|x| |y| $)
  (PROG ()
    (RETURN
     (SPADCALL (CONS #'|STTAYLOR;mapmult;3S;20!0| (VECTOR |x| $ |y|))
               (QREFELT $ 20))))) 

(DEFUN |STTAYLOR;mapmult;3S;20!0| ($$)
  (PROG (|y| $ |x|)
    (LETT |y| (QREFELT $$ 2) . #1=(|STTAYLOR;mapmult;3S;20|))
    (LETT $ (QREFELT $$ 1) . #1#)
    (LETT |x| (QREFELT $$ 0) . #1#)
    (RETURN
     (PROGN
      (COND
       ((OR (SPADCALL |y| (QREFELT $ 10)) (SPADCALL |x| (QREFELT $ 10)))
        (|STTAYLOR;zro| $))
       ('T
        (SPADCALL
         (SPADCALL (SPADCALL |x| (QREFELT $ 13)) (SPADCALL |y| (QREFELT $ 13))
                   (QREFELT $ 26))
         (SPADCALL (SPADCALL |x| (QREFELT $ 11)) (SPADCALL |y| (QREFELT $ 11))
                   (QREFELT $ 71))
         (QREFELT $ 18)))))))) 

(DEFUN |STTAYLOR;deriv;2S;21| (|x| $)
  (COND ((SPADCALL |x| (QREFELT $ 10)) (|STTAYLOR;zro| $))
        ('T
         (SPADCALL (SPADCALL (|spadConstant| $ 37) (QREFELT $ 58))
                   (SPADCALL |x| (QREFELT $ 72)) (QREFELT $ 71))))) 

(DEFUN |STTAYLOR;gderiv;M2S;22| (|f| |x| $)
  (COND ((SPADCALL |x| (QREFELT $ 10)) (|STTAYLOR;zro| $))
        ('T
         (SPADCALL (SPADCALL |f| (SPADCALL 0 (QREFELT $ 55)) (QREFELT $ 76))
                   |x| (QREFELT $ 71))))) 

(DEFUN |STTAYLOR;coerce;AS;23| (|s| $)
  (COND ((SPADCALL |s| (QREFELT $ 25)) (|STTAYLOR;zro| $))
        ('T (SPADCALL |s| (|STTAYLOR;zro| $) (QREFELT $ 18))))) 

(DEFUN |STTAYLOR;eval;SAS;24| (|x| |at| $)
  (PROG ()
    (RETURN
     (SPADCALL (|spadConstant| $ 29) (ELT $ 14)
               (SPADCALL |x|
                         (SPADCALL
                          (CONS #'|STTAYLOR;eval;SAS;24!0| (VECTOR $ |at|))
                          (|spadConstant| $ 37) (QREFELT $ 57))
                         (QREFELT $ 71))
               (QREFELT $ 81))))) 

(DEFUN |STTAYLOR;eval;SAS;24!0| (|y| $$)
  (PROG (|at| $)
    (LETT |at| (QREFELT $$ 1) . #1=(|STTAYLOR;eval;SAS;24|))
    (LETT $ (QREFELT $$ 0) . #1#)
    (RETURN (PROGN (SPADCALL |at| |y| (QREFELT $ 26)))))) 

(DEFUN |STTAYLOR;compose;3S;25| (|x| |y| $)
  (PROG ()
    (RETURN
     (SPADCALL (CONS #'|STTAYLOR;compose;3S;25!0| (VECTOR |x| $ |y|))
               (QREFELT $ 20))))) 

(DEFUN |STTAYLOR;compose;3S;25!0| ($$)
  (PROG (|y| $ |x|)
    (LETT |y| (QREFELT $$ 2) . #1=(|STTAYLOR;compose;3S;25|))
    (LETT $ (QREFELT $$ 1) . #1#)
    (LETT |x| (QREFELT $$ 0) . #1#)
    (RETURN
     (PROGN
      (COND
       ((SPADCALL |y| (QREFELT $ 10))
        (SPADCALL (SPADCALL |x| (QREFELT $ 13)) (|STTAYLOR;zro| $)
                  (QREFELT $ 18)))
       ((NULL (SPADCALL (SPADCALL |y| (QREFELT $ 13)) (QREFELT $ 25)))
        (|error| "compose: 2nd argument should have 0 constant coefficient"))
       ('T
        (COND ((SPADCALL |x| (QREFELT $ 10)) (|STTAYLOR;zro| $))
              ('T
               (SPADCALL (SPADCALL |x| (QREFELT $ 13))
                         (SPADCALL
                          (SPADCALL (SPADCALL |x| (QREFELT $ 11)) |y|
                                    (QREFELT $ 83))
                          (SPADCALL |y| (QREFELT $ 11)) (QREFELT $ 70))
                         (QREFELT $ 18)))))))))) 

(DEFUN |STTAYLOR;lagrangere| (|x| |c| $)
  (PROG ()
    (RETURN
     (SPADCALL (CONS #'|STTAYLOR;lagrangere!0| (VECTOR |c| |x| $))
               (QREFELT $ 20))))) 

(DEFUN |STTAYLOR;lagrangere!0| ($$)
  (PROG ($ |x| |c|)
    (LETT $ (QREFELT $$ 2) . #1=(|STTAYLOR;lagrangere|))
    (LETT |x| (QREFELT $$ 1) . #1#)
    (LETT |c| (QREFELT $$ 0) . #1#)
    (RETURN
     (PROGN
      (SPADCALL (|spadConstant| $ 29) (SPADCALL |x| |c| (QREFELT $ 83))
                (QREFELT $ 18)))))) 

(DEFUN |STTAYLOR;lagrange;2S;27| (|x| $)
  (PROG ()
    (RETURN
     (SPADCALL (CONS #'|STTAYLOR;lagrange;2S;27!0| (VECTOR $ |x|))
               (QREFELT $ 86))))) 

(DEFUN |STTAYLOR;lagrange;2S;27!0| (|y| $$)
  (PROG (|x| $)
    (LETT |x| (QREFELT $$ 1) . #1=(|STTAYLOR;lagrange;2S;27|))
    (LETT $ (QREFELT $$ 0) . #1#)
    (RETURN (PROGN (|STTAYLOR;lagrangere| |x| |y| $))))) 

(DEFUN |STTAYLOR;revert;2S;28| (|x| $)
  (PROG (#1=#:G2144)
    (RETURN
     (COND
      ((SPADCALL |x| (QREFELT $ 10)) (|error| "revert should start 0,1,..."))
      ((SPADCALL (SPADCALL |x| (QREFELT $ 13)) (QREFELT $ 25))
       (COND
        ((SPADCALL (SPADCALL |x| (QREFELT $ 11)) (QREFELT $ 10))
         (|error| "revert: should start 0,1,..."))
        ((SPADCALL (SPADCALL (SPADCALL |x| (QREFELT $ 11)) (QREFELT $ 13))
                   (|spadConstant| $ 37) (QREFELT $ 30))
         (SPADCALL
          (PROG2
              (LETT #1# (SPADCALL (SPADCALL |x| (QREFELT $ 11)) (QREFELT $ 36))
                    |STTAYLOR;revert;2S;28|)
              (QCDR #1#)
            (|check-union| (QEQCAR #1# 0) (|Stream| (QREFELT $ 6)) #1#))
          (QREFELT $ 87)))))
      ('T (|error| "revert:should start 0,1,...")))))) 

(DEFUN |STTAYLOR;addiag;SS;29| (|ststa| $)
  (PROG ()
    (RETURN
     (SPADCALL (CONS #'|STTAYLOR;addiag;SS;29!0| (VECTOR $ |ststa|))
               (QREFELT $ 20))))) 

(DEFUN |STTAYLOR;addiag;SS;29!0| ($$)
  (PROG (|ststa| $)
    (LETT |ststa| (QREFELT $$ 1) . #1=(|STTAYLOR;addiag;SS;29|))
    (LETT $ (QREFELT $$ 0) . #1#)
    (RETURN
     (PROGN
      (COND ((SPADCALL |ststa| (QREFELT $ 90)) (|STTAYLOR;zro| $))
            ((SPADCALL (SPADCALL |ststa| (QREFELT $ 91)) (QREFELT $ 10))
             (SPADCALL (|spadConstant| $ 29)
                       (SPADCALL (SPADCALL |ststa| (QREFELT $ 92))
                                 (QREFELT $ 93))
                       (QREFELT $ 18)))
            ('T
             (SPADCALL
              (SPADCALL (SPADCALL |ststa| (QREFELT $ 91)) (QREFELT $ 13))
              (SPADCALL
               (SPADCALL (SPADCALL |ststa| (QREFELT $ 91)) (QREFELT $ 11))
               (SPADCALL (SPADCALL |ststa| (QREFELT $ 92)) (QREFELT $ 93))
               (QREFELT $ 17))
              (QREFELT $ 18)))))))) 

(DEFUN |STTAYLOR;rptg1| (|z| |s| $)
  (SPADCALL (CONS |s| (|STTAYLOR;rp| |z| (|spadConstant| $ 29) $))
            (QREFELT $ 94))) 

(DEFUN |STTAYLOR;rptg2| (|z| |s| $)
  (SPADCALL
   (SPADCALL (|STTAYLOR;rp| |z| (|spadConstant| $ 29) $)
             (CONS |s| (|STTAYLOR;rp| (- |z| 1) (|spadConstant| $ 29) $))
             (QREFELT $ 95))
   (QREFELT $ 94))) 

(DEFUN |STTAYLOR;rptg3| (|a| |d| |n| |s| $)
  (SPADCALL (|STTAYLOR;rpSt| (* |n| (- |a| 1)) (|spadConstant| $ 29) $)
            (SPADCALL
             (CONS |s|
                   (|STTAYLOR;rp| (- (* |d| |n|) 1) (|spadConstant| $ 29) $))
             (QREFELT $ 94))
            (QREFELT $ 43))) 

(DEFUN |STTAYLOR;lambert;2S;33| (|x| $)
  (PROG ()
    (RETURN
     (SPADCALL (CONS #'|STTAYLOR;lambert;2S;33!0| (VECTOR $ |x|))
               (QREFELT $ 20))))) 

(DEFUN |STTAYLOR;lambert;2S;33!0| ($$)
  (PROG (|x| $)
    (LETT |x| (QREFELT $$ 1) . #1=(|STTAYLOR;lambert;2S;33|))
    (LETT $ (QREFELT $$ 0) . #1#)
    (RETURN
     (PROGN
      (COND ((SPADCALL |x| (QREFELT $ 10)) (|STTAYLOR;zro| $))
            ((SPADCALL (SPADCALL |x| (QREFELT $ 13)) (QREFELT $ 25))
             (SPADCALL (|spadConstant| $ 29)
                       (SPADCALL
                        (SPADCALL (CONS (|function| |STTAYLOR;rptg1|) $)
                                  (SPADCALL (|spadConstant| $ 39)
                                            (QREFELT $ 55))
                                  (SPADCALL |x| (QREFELT $ 11)) (QREFELT $ 98))
                        (QREFELT $ 93))
                       (QREFELT $ 18)))
            ('T (|error| "lambert:constant coefficient should be zero"))))))) 

(DEFUN |STTAYLOR;oddlambert;2S;34| (|x| $)
  (PROG ()
    (RETURN
     (SPADCALL (CONS #'|STTAYLOR;oddlambert;2S;34!0| (VECTOR $ |x|))
               (QREFELT $ 20))))) 

(DEFUN |STTAYLOR;oddlambert;2S;34!0| ($$)
  (PROG (|x| $)
    (LETT |x| (QREFELT $$ 1) . #1=(|STTAYLOR;oddlambert;2S;34|))
    (LETT $ (QREFELT $$ 0) . #1#)
    (RETURN
     (PROGN
      (COND ((SPADCALL |x| (QREFELT $ 10)) (|STTAYLOR;zro| $))
            ((SPADCALL (SPADCALL |x| (QREFELT $ 13)) (QREFELT $ 25))
             (SPADCALL (|spadConstant| $ 29)
                       (SPADCALL
                        (SPADCALL (CONS (|function| |STTAYLOR;rptg1|) $)
                                  (SPADCALL (|spadConstant| $ 41)
                                            (QREFELT $ 56))
                                  (SPADCALL |x| (QREFELT $ 11)) (QREFELT $ 98))
                        (QREFELT $ 93))
                       (QREFELT $ 18)))
            ('T
             (|error| "oddlambert: constant coefficient should be zero"))))))) 

(DEFUN |STTAYLOR;evenlambert;2S;35| (|x| $)
  (PROG ()
    (RETURN
     (SPADCALL (CONS #'|STTAYLOR;evenlambert;2S;35!0| (VECTOR $ |x|))
               (QREFELT $ 20))))) 

(DEFUN |STTAYLOR;evenlambert;2S;35!0| ($$)
  (PROG (|x| $)
    (LETT |x| (QREFELT $$ 1) . #1=(|STTAYLOR;evenlambert;2S;35|))
    (LETT $ (QREFELT $$ 0) . #1#)
    (RETURN
     (PROGN
      (COND ((SPADCALL |x| (QREFELT $ 10)) (|STTAYLOR;zro| $))
            ((SPADCALL (SPADCALL |x| (QREFELT $ 13)) (QREFELT $ 25))
             (SPADCALL (|spadConstant| $ 29)
                       (SPADCALL
                        (SPADCALL (CONS (|function| |STTAYLOR;rptg2|) $)
                                  (SPADCALL (|spadConstant| $ 41)
                                            (QREFELT $ 55))
                                  (SPADCALL |x| (QREFELT $ 11)) (QREFELT $ 98))
                        (QREFELT $ 93))
                       (QREFELT $ 18)))
            ('T
             (|error| "evenlambert: constant coefficient should be zero"))))))) 

(DEFUN |STTAYLOR;generalLambert;S2IS;36| (|st| |a| |d| $)
  (PROG ()
    (RETURN
     (SPADCALL
      (CONS #'|STTAYLOR;generalLambert;S2IS;36!1| (VECTOR |st| |d| $ |a|))
      (QREFELT $ 20))))) 

(DEFUN |STTAYLOR;generalLambert;S2IS;36!1| ($$)
  (PROG (|a| $ |d| |st|)
    (LETT |a| (QREFELT $$ 3) . #1=(|STTAYLOR;generalLambert;S2IS;36|))
    (LETT $ (QREFELT $$ 2) . #1#)
    (LETT |d| (QREFELT $$ 1) . #1#)
    (LETT |st| (QREFELT $$ 0) . #1#)
    (RETURN
     (PROGN
      (PROG ()
        (RETURN
         (COND
          ((OR (SPADCALL |a| (|spadConstant| $ 41) (QREFELT $ 40))
               (SPADCALL |d| (|spadConstant| $ 41) (QREFELT $ 40)))
           (|error| "generalLambert: both integer arguments must be positive"))
          ('T
           (COND ((SPADCALL |st| (QREFELT $ 10)) (|STTAYLOR;zro| $))
                 ((SPADCALL (SPADCALL |st| (QREFELT $ 13)) (QREFELT $ 25))
                  (SPADCALL (|spadConstant| $ 29)
                            (SPADCALL
                             (SPADCALL
                              (CONS #'|STTAYLOR;generalLambert;S2IS;36!0|
                                    (VECTOR $ |d| |a|))
                              (SPADCALL (|spadConstant| $ 41) (QREFELT $ 55))
                              (SPADCALL |st| (QREFELT $ 11)) (QREFELT $ 98))
                             (QREFELT $ 93))
                            (QREFELT $ 18)))
                 ('T
                  (|error|
                   "generalLambert: constant coefficient should be zero"))))))))))) 

(DEFUN |STTAYLOR;generalLambert;S2IS;36!0| (|x| |y| $$)
  (PROG (|a| |d| $)
    (LETT |a| (QREFELT $$ 2) NIL)
    (LETT |d| (QREFELT $$ 1) NIL)
    (LETT $ (QREFELT $$ 0) NIL)
    (RETURN (PROGN (|STTAYLOR;rptg3| |a| |d| |x| |y| $))))) 

(DEFUN |STTAYLOR;ms| (|m| |n| |s| $)
  (PROG ()
    (RETURN
     (SPADCALL (CONS #'|STTAYLOR;ms!0| (VECTOR |m| |n| $ |s|))
               (QREFELT $ 20))))) 

(DEFUN |STTAYLOR;ms!0| ($$)
  (PROG (|s| $ |n| |m|)
    (LETT |s| (QREFELT $$ 3) . #1=(|STTAYLOR;ms|))
    (LETT $ (QREFELT $$ 2) . #1#)
    (LETT |n| (QREFELT $$ 1) . #1#)
    (LETT |m| (QREFELT $$ 0) . #1#)
    (RETURN
     (PROGN
      (COND ((SPADCALL |s| (QREFELT $ 10)) (|STTAYLOR;zro| $))
            ((SPADCALL |n| (QREFELT $ 103))
             (SPADCALL (SPADCALL |s| (QREFELT $ 13))
                       (|STTAYLOR;ms| |m|
                        (SPADCALL |m| (|spadConstant| $ 41) (QREFELT $ 42))
                        (SPADCALL |s| (QREFELT $ 11)) $)
                       (QREFELT $ 18)))
            ('T
             (|STTAYLOR;ms| |m|
              (SPADCALL |n| (|spadConstant| $ 41) (QREFELT $ 42))
              (SPADCALL |s| (QREFELT $ 11)) $))))))) 

(DEFUN |STTAYLOR;multisect;2I2S;38| (|b| |a| |x| $)
  (PROG (#1=#:G2270)
    (RETURN
     (|STTAYLOR;ms| (+ |a| |b|) 0
      (SPADCALL |x|
                (PROG1 (LETT #1# |a| |STTAYLOR;multisect;2I2S;38|)
                  (|check-subtype| (>= #1# 0) '(|NonNegativeInteger|) #1#))
                (QREFELT $ 104))
      $)))) 

(DEFUN |STTAYLOR;altn| (|zs| |s| $)
  (PROG ()
    (RETURN
     (SPADCALL (CONS #'|STTAYLOR;altn!0| (VECTOR |zs| $ |s|)) (QREFELT $ 20))))) 

(DEFUN |STTAYLOR;altn!0| ($$)
  (PROG (|s| $ |zs|)
    (LETT |s| (QREFELT $$ 2) . #1=(|STTAYLOR;altn|))
    (LETT $ (QREFELT $$ 1) . #1#)
    (LETT |zs| (QREFELT $$ 0) . #1#)
    (RETURN
     (PROGN
      (COND ((SPADCALL |s| (QREFELT $ 10)) (|STTAYLOR;zro| $))
            ('T
             (SPADCALL (SPADCALL |s| (QREFELT $ 13))
                       (SPADCALL |zs|
                                 (|STTAYLOR;altn| |zs|
                                  (SPADCALL |s| (QREFELT $ 11)) $)
                                 (QREFELT $ 43))
                       (QREFELT $ 18)))))))) 

(DEFUN |STTAYLOR;invmultisect;2I2S;40| (|a| |b| |x| $)
  (SPADCALL (|STTAYLOR;rpSt| |b| (|spadConstant| $ 29) $)
            (|STTAYLOR;altn|
             (|STTAYLOR;rpSt| (- (+ |a| |b|) 1) (|spadConstant| $ 29) $) |x| $)
            (QREFELT $ 43))) 

(DEFUN |STTAYLOR;comps| (|ststa| |x| $)
  (PROG ()
    (RETURN
     (SPADCALL (CONS #'|STTAYLOR;comps!1| (VECTOR |x| $ |ststa|))
               (QREFELT $ 111))))) 

(DEFUN |STTAYLOR;comps!1| ($$)
  (PROG (|ststa| $ |x|)
    (LETT |ststa| (QREFELT $$ 2) . #1=(|STTAYLOR;comps|))
    (LETT $ (QREFELT $$ 1) . #1#)
    (LETT |x| (QREFELT $$ 0) . #1#)
    (RETURN
     (PROGN
      (PROG ()
        (RETURN
         (COND ((SPADCALL |ststa| (QREFELT $ 90)) (SPADCALL (QREFELT $ 107)))
               ((SPADCALL |x| (QREFELT $ 10))
                (SPADCALL (SPADCALL |ststa| (QREFELT $ 91))
                          (SPADCALL (QREFELT $ 107)) (QREFELT $ 108)))
               ('T
                (SPADCALL (SPADCALL |ststa| (QREFELT $ 91))
                          (SPADCALL (CONS #'|STTAYLOR;comps!0| (VECTOR $ |x|))
                                    (|STTAYLOR;comps|
                                     (SPADCALL |ststa| (QREFELT $ 92)) |x| $)
                                    (QREFELT $ 110))
                          (QREFELT $ 108)))))))))) 

(DEFUN |STTAYLOR;comps!0| (|y| $$)
  (PROG (|x| $)
    (LETT |x| (QREFELT $$ 1) NIL)
    (LETT $ (QREFELT $$ 0) NIL)
    (RETURN
     (PROGN (SPADCALL (SPADCALL |x| (QREFELT $ 11)) |y| (QREFELT $ 70)))))) 

(DEFUN |STTAYLOR;integre| (|x| |n| $)
  (PROG ()
    (RETURN
     (SPADCALL (CONS #'|STTAYLOR;integre!0| (VECTOR |n| $ |x|))
               (QREFELT $ 20))))) 

(DEFUN |STTAYLOR;integre!0| ($$)
  (PROG (|x| $ |n|)
    (LETT |x| (QREFELT $$ 2) . #1=(|STTAYLOR;integre|))
    (LETT $ (QREFELT $$ 1) . #1#)
    (LETT |n| (QREFELT $$ 0) . #1#)
    (RETURN
     (PROGN
      (COND ((SPADCALL |x| (QREFELT $ 10)) (|STTAYLOR;zro| $))
            ('T
             (SPADCALL
              (SPADCALL (SPADCALL (|spadConstant| $ 41) |n| (QREFELT $ 113))
                        (SPADCALL |x| (QREFELT $ 13)) (QREFELT $ 114))
              (|STTAYLOR;integre| (SPADCALL |x| (QREFELT $ 11))
               (SPADCALL |n| (|spadConstant| $ 41) (QREFELT $ 51)) $)
              (QREFELT $ 18)))))))) 

(DEFUN |STTAYLOR;integ| (|x| $) (|STTAYLOR;integre| |x| 1 $)) 

(DEFUN |STTAYLOR;integrate;A2S;44| (|a| |x| $)
  (SPADCALL |a| (|STTAYLOR;integ| |x| $) (QREFELT $ 18))) 

(DEFUN |STTAYLOR;lazyIntegrate;AMS;45| (|s| |xf| $)
  (SPADCALL |s| (|STTAYLOR;integ| (SPADCALL |xf| (QREFELT $ 20)) $)
            (QREFELT $ 18))) 

(DEFUN |STTAYLOR;nldere| (|lslsa| |c| $)
  (PROG ()
    (RETURN
     (SPADCALL (|spadConstant| $ 29)
               (CONS #'|STTAYLOR;nldere!0| (VECTOR $ |c| |lslsa|))
               (QREFELT $ 117))))) 

(DEFUN |STTAYLOR;nldere!0| ($$)
  (PROG (|lslsa| |c| $)
    (LETT |lslsa| (QREFELT $$ 2) . #1=(|STTAYLOR;nldere|))
    (LETT |c| (QREFELT $$ 1) . #1#)
    (LETT $ (QREFELT $$ 0) . #1#)
    (RETURN
     (PROGN (SPADCALL (|STTAYLOR;comps| |lslsa| |c| $) (QREFELT $ 93)))))) 

(DEFUN |STTAYLOR;nlde;SS;47| (|lslsa| $)
  (PROG ()
    (RETURN
     (SPADCALL (CONS #'|STTAYLOR;nlde;SS;47!0| (VECTOR $ |lslsa|))
               (QREFELT $ 86))))) 

(DEFUN |STTAYLOR;nlde;SS;47!0| (|y| $$)
  (PROG (|lslsa| $)
    (LETT |lslsa| (QREFELT $$ 1) . #1=(|STTAYLOR;nlde;SS;47|))
    (LETT $ (QREFELT $$ 0) . #1#)
    (RETURN (PROGN (|STTAYLOR;nldere| |lslsa| |y| $))))) 

(DEFUN |STTAYLOR;smult| (|rn| |x| $)
  (PROG ()
    (RETURN
     (SPADCALL (CONS #'|STTAYLOR;smult!0| (VECTOR $ |rn|)) |x|
               (QREFELT $ 16))))) 

(DEFUN |STTAYLOR;smult!0| (|y| $$)
  (PROG (|rn| $)
    (LETT |rn| (QREFELT $$ 1) . #1=(|STTAYLOR;smult|))
    (LETT $ (QREFELT $$ 0) . #1#)
    (RETURN (PROGN (SPADCALL |rn| |y| (QREFELT $ 114)))))) 

(DEFUN |STTAYLOR;powerrn| (|rn| |x| |c| $)
  (PROG ()
    (RETURN
     (SPADCALL (CONS #'|STTAYLOR;powerrn!0| (VECTOR |x| |c| |rn| $))
               (QREFELT $ 20))))) 

(DEFUN |STTAYLOR;powerrn!0| ($$)
  (PROG ($ |rn| |c| |x|)
    (LETT $ (QREFELT $$ 3) . #1=(|STTAYLOR;powerrn|))
    (LETT |rn| (QREFELT $$ 2) . #1#)
    (LETT |c| (QREFELT $$ 1) . #1#)
    (LETT |x| (QREFELT $$ 0) . #1#)
    (RETURN
     (PROGN
      (SPADCALL (|spadConstant| $ 37)
                (SPADCALL
                 (|STTAYLOR;integ|
                  (|STTAYLOR;smult|
                   (SPADCALL |rn| (|spadConstant| $ 120) (QREFELT $ 121))
                   (SPADCALL |c| (SPADCALL |x| (QREFELT $ 73)) (QREFELT $ 70))
                   $)
                  $)
                 (SPADCALL (SPADCALL |x| (QREFELT $ 11)) |c| (QREFELT $ 70))
                 (QREFELT $ 23))
                (QREFELT $ 18)))))) 

(DEFUN |STTAYLOR;powern;F2S;50| (|rn| |x| $)
  (PROG (|power| #1=#:G2340 #2=#:G2334 |num| |invCo| |co| |ord| #3=#:G2323
         |order| #4=#:G2348 |n|)
    (RETURN
     (SEQ
      (EXIT
       (SEQ (LETT |order| 0 . #5=(|STTAYLOR;powern;F2S;50|))
            (SEQ
             (EXIT
              (SEQ (LETT |n| 0 . #5#) G190 NIL
                   (SEQ
                    (EXIT
                     (COND
                      ((SPADCALL |x| (QREFELT $ 10))
                       (PROGN (LETT #4# (|STTAYLOR;zro| $) . #5#) (GO #4#)))
                      ((NULL
                        (SPADCALL (SPADCALL |x| (QREFELT $ 13))
                                  (QREFELT $ 25)))
                       (SEQ (LETT |order| |n| . #5#)
                            (EXIT (PROGN (LETT #3# |x| . #5#) (GO #3#)))))
                      ('T
                       (SEQ (LETT |x| (SPADCALL |x| (QREFELT $ 11)) . #5#)
                            (EXIT
                             (COND
                              ((EQL |n| 1000)
                               (|error|
                                "^: series with many leading zero coefficients")))))))))
                   (LETT |n| (QSADD1 |n|) . #5#) (GO G190) G191 (EXIT NIL)))
             #3# (EXIT #3#))
            (LETT |ord|
                  (SPADCALL |order| (SPADCALL |rn| (QREFELT $ 122))
                            (QREFELT $ 123))
                  . #5#)
            (EXIT
             (COND
              ((QEQCAR |ord| 1) (|error| "^: rational power does not exist"))
              (#6='T
               (SEQ (LETT |co| (SPADCALL |x| (QREFELT $ 13)) . #5#)
                    (COND
                     ((< 0 (QCDR |ord|))
                      (COND
                       ((SPADCALL |rn| (|spadConstant| $ 124) (QREFELT $ 125))
                        (|error| "^: negative power does not exist")))))
                    (LETT |invCo| (SPADCALL |co| (QREFELT $ 32)) . #5#)
                    (EXIT
                     (COND
                      ((QEQCAR |invCo| 1)
                       (|error| "^ rational power of coefficient undefined"))
                      (#6#
                       (SEQ
                        (LETT |power|
                              (COND
                               ((SPADCALL |co| (|spadConstant| $ 37)
                                          (QREFELT $ 30))
                                (SPADCALL
                                 (CONS #'|STTAYLOR;powern;F2S;50!0|
                                       (VECTOR $ |x| |rn|))
                                 (QREFELT $ 86)))
                               ((EQL (SPADCALL |rn| (QREFELT $ 122)) 1)
                                (COND
                                 ((NULL
                                   (MINUSP
                                    (LETT |num| (SPADCALL |rn| (QREFELT $ 126))
                                          . #5#)))
                                  (SPADCALL
                                   (SPADCALL |co|
                                             (PROG1 (LETT #2# |num| . #5#)
                                               (|check-subtype| (>= #2# 0)
                                                                '(|NonNegativeInteger|)
                                                                #2#))
                                             (QREFELT $ 127))
                                   (SPADCALL
                                    (CONS #'|STTAYLOR;powern;F2S;50!1|
                                          (VECTOR $ |x| |invCo| |rn|))
                                    (QREFELT $ 86))
                                   (QREFELT $ 27)))
                                 ('T
                                  (SPADCALL
                                   (SPADCALL (QCDR |invCo|)
                                             (PROG1 (LETT #1# (- |num|) . #5#)
                                               (|check-subtype| (>= #1# 0)
                                                                '(|NonNegativeInteger|)
                                                                #1#))
                                             (QREFELT $ 127))
                                   (SPADCALL
                                    (CONS #'|STTAYLOR;powern;F2S;50!2|
                                          (VECTOR $ |x| |invCo| |rn|))
                                    (QREFELT $ 86))
                                   (QREFELT $ 27)))))
                               ((QREFELT $ 119)
                                (SPADCALL (SPADCALL |co| |rn| (QREFELT $ 128))
                                          (SPADCALL
                                           (CONS #'|STTAYLOR;powern;F2S;50!3|
                                                 (VECTOR $ |x| |invCo| |rn|))
                                           (QREFELT $ 86))
                                          (QREFELT $ 27)))
                               (#6#
                                (|error|
                                 "^ rational power of coefficient undefined")))
                              . #5#)
                        (EXIT
                         (SPADCALL
                          (SPADCALL (|spadConstant| $ 37)
                                    (* (QCDR |ord|)
                                       (SPADCALL |rn| (QREFELT $ 126)))
                                    (QREFELT $ 44))
                          |power| (QREFELT $ 70)))))))))))))
      #4# (EXIT #4#))))) 

(DEFUN |STTAYLOR;powern;F2S;50!3| (|y| $$)
  (PROG (|rn| |invCo| |x| $)
    (LETT |rn| (QREFELT $$ 3) . #1=(|STTAYLOR;powern;F2S;50|))
    (LETT |invCo| (QREFELT $$ 2) . #1#)
    (LETT |x| (QREFELT $$ 1) . #1#)
    (LETT $ (QREFELT $$ 0) . #1#)
    (RETURN
     (PROGN
      (|STTAYLOR;powerrn| |rn| (SPADCALL (QCDR |invCo|) |x| (QREFELT $ 27)) |y|
       $))))) 

(DEFUN |STTAYLOR;powern;F2S;50!2| (|y| $$)
  (PROG (|rn| |invCo| |x| $)
    (LETT |rn| (QREFELT $$ 3) . #1=(|STTAYLOR;powern;F2S;50|))
    (LETT |invCo| (QREFELT $$ 2) . #1#)
    (LETT |x| (QREFELT $$ 1) . #1#)
    (LETT $ (QREFELT $$ 0) . #1#)
    (RETURN
     (PROGN
      (|STTAYLOR;powerrn| |rn| (SPADCALL (QCDR |invCo|) |x| (QREFELT $ 27)) |y|
       $))))) 

(DEFUN |STTAYLOR;powern;F2S;50!1| (|y| $$)
  (PROG (|rn| |invCo| |x| $)
    (LETT |rn| (QREFELT $$ 3) . #1=(|STTAYLOR;powern;F2S;50|))
    (LETT |invCo| (QREFELT $$ 2) . #1#)
    (LETT |x| (QREFELT $$ 1) . #1#)
    (LETT $ (QREFELT $$ 0) . #1#)
    (RETURN
     (PROGN
      (|STTAYLOR;powerrn| |rn| (SPADCALL (QCDR |invCo|) |x| (QREFELT $ 27)) |y|
       $))))) 

(DEFUN |STTAYLOR;powern;F2S;50!0| (|y| $$)
  (PROG (|rn| |x| $)
    (LETT |rn| (QREFELT $$ 2) . #1=(|STTAYLOR;powern;F2S;50|))
    (LETT |x| (QREFELT $$ 1) . #1#)
    (LETT $ (QREFELT $$ 0) . #1#)
    (RETURN (PROGN (|STTAYLOR;powerrn| |rn| |x| |y| $))))) 

(DEFUN |STTAYLOR;mapdiv;3S;51| (|x| |y| $)
  (PROG ()
    (RETURN
     (SPADCALL (CONS #'|STTAYLOR;mapdiv;3S;51!0| (VECTOR |x| $ |y|))
               (QREFELT $ 20))))) 

(DEFUN |STTAYLOR;mapdiv;3S;51!0| ($$)
  (PROG (|y| $ |x|)
    (LETT |y| (QREFELT $$ 2) . #1=(|STTAYLOR;mapdiv;3S;51|))
    (LETT $ (QREFELT $$ 1) . #1#)
    (LETT |x| (QREFELT $$ 0) . #1#)
    (RETURN
     (PROGN
      (COND ((SPADCALL |y| (QREFELT $ 10)) (|error| "stream division by zero"))
            ((SPADCALL |x| (QREFELT $ 10)) (|STTAYLOR;zro| $))
            ('T
             (SPADCALL
              (SPADCALL (SPADCALL |x| (QREFELT $ 13))
                        (SPADCALL |y| (QREFELT $ 13)) (QREFELT $ 130))
              (SPADCALL (SPADCALL |x| (QREFELT $ 11))
                        (SPADCALL |y| (QREFELT $ 11)) (QREFELT $ 131))
              (QREFELT $ 18)))))))) 

(DEFUN |STTAYLOR;ginteg| (|f| |x| $)
  (SPADCALL |x| (SPADCALL |f| (SPADCALL 1 (QREFELT $ 55)) (QREFELT $ 76))
            (QREFELT $ 131))) 

(DEFUN |STTAYLOR;lazyGintegrate;MAMS;53| (|fntoa| |s| |xf| $)
  (SPADCALL |s| (|STTAYLOR;ginteg| |fntoa| (SPADCALL |xf| (QREFELT $ 20)) $)
            (QREFELT $ 18))) 

(DEFUN |STTAYLOR;finteg| (|x| $)
  (SPADCALL |x| (SPADCALL (|spadConstant| $ 37) (QREFELT $ 58))
            (QREFELT $ 131))) 

(DEFUN |STTAYLOR;powerre| (|s| |x| |c| $)
  (PROG ()
    (RETURN
     (SPADCALL (CONS #'|STTAYLOR;powerre!0| (VECTOR |c| |s| $ |x|))
               (QREFELT $ 20))))) 

(DEFUN |STTAYLOR;powerre!0| ($$)
  (PROG (|x| $ |s| |c|)
    (LETT |x| (QREFELT $$ 3) . #1=(|STTAYLOR;powerre|))
    (LETT $ (QREFELT $$ 2) . #1#)
    (LETT |s| (QREFELT $$ 1) . #1#)
    (LETT |c| (QREFELT $$ 0) . #1#)
    (RETURN
     (PROGN
      (COND ((SPADCALL |x| (QREFELT $ 10)) (|STTAYLOR;zro| $))
            ((NULL
              (SPADCALL (SPADCALL |x| (QREFELT $ 13)) (|spadConstant| $ 37)
                        (QREFELT $ 30)))
             (|error| "^:constant coefficient should be 1"))
            ('T
             (SPADCALL (SPADCALL |x| (QREFELT $ 13))
                       (SPADCALL
                        (|STTAYLOR;finteg|
                         (SPADCALL
                          (SPADCALL |s| (|spadConstant| $ 37) (QREFELT $ 14))
                          (SPADCALL |c| (SPADCALL |x| (QREFELT $ 73))
                                    (QREFELT $ 70))
                          (QREFELT $ 27))
                         $)
                        (SPADCALL (SPADCALL |x| (QREFELT $ 11)) |c|
                                  (QREFELT $ 70))
                        (QREFELT $ 23))
                       (QREFELT $ 18)))))))) 

(DEFUN |STTAYLOR;power;A2S;56| (|s| |x| $)
  (PROG ()
    (RETURN
     (SPADCALL (CONS #'|STTAYLOR;power;A2S;56!0| (VECTOR $ |x| |s|))
               (QREFELT $ 86))))) 

(DEFUN |STTAYLOR;power;A2S;56!0| (|y| $$)
  (PROG (|s| |x| $)
    (LETT |s| (QREFELT $$ 2) . #1=(|STTAYLOR;power;A2S;56|))
    (LETT |x| (QREFELT $$ 1) . #1#)
    (LETT $ (QREFELT $$ 0) . #1#)
    (RETURN (PROGN (|STTAYLOR;powerre| |s| |x| |y| $))))) 

(DEFUN |StreamTaylorSeriesOperations| (#1=#:G2385)
  (PROG ()
    (RETURN
     (PROG (#2=#:G2386)
       (RETURN
        (COND
         ((LETT #2#
                (|lassocShiftWithFunction| (LIST (|devaluate| #1#))
                                           (HGET |$ConstructorCache|
                                                 '|StreamTaylorSeriesOperations|)
                                           '|domainEqualList|)
                . #3=(|StreamTaylorSeriesOperations|))
          (|CDRwithIncrement| #2#))
         ('T
          (UNWIND-PROTECT
              (PROG1 (|StreamTaylorSeriesOperations;| #1#) (LETT #2# T . #3#))
            (COND
             ((NOT #2#)
              (HREM |$ConstructorCache|
                    '|StreamTaylorSeriesOperations|))))))))))) 

(DEFUN |StreamTaylorSeriesOperations;| (|#1|)
  (PROG (|pv$| $ |dv$| DV$1)
    (RETURN
     (PROGN
      (LETT DV$1 (|devaluate| |#1|) . #1=(|StreamTaylorSeriesOperations|))
      (LETT |dv$| (LIST '|StreamTaylorSeriesOperations| DV$1) . #1#)
      (LETT $ (GETREFV 134) . #1#)
      (QSETREFV $ 0 |dv$|)
      (QSETREFV $ 3
                (LETT |pv$|
                      (|buildPredVector| 0 0
                                         (LIST (|HasCategory| |#1| '(|Field|))
                                               (|HasCategory| |#1|
                                                              '(|Algebra|
                                                                (|Fraction|
                                                                 (|Integer|))))))
                      . #1#))
      (|haddProp| |$ConstructorCache| '|StreamTaylorSeriesOperations|
                  (LIST DV$1) (CONS 1 $))
      (|stuffDomainSlots| $)
      (QSETREFV $ 6 |#1|)
      (COND
       ((|testBitVector| |pv$| 2)
        (PROGN
         (QSETREFV $ 115
                   (CONS (|dispatchFunction| |STTAYLOR;integrate;A2S;44|) $))
         (QSETREFV $ 117
                   (CONS (|dispatchFunction| |STTAYLOR;lazyIntegrate;AMS;45|)
                         $))
         NIL
         (QSETREFV $ 118 (CONS (|dispatchFunction| |STTAYLOR;nlde;SS;47|) $))
         (QSETREFV $ 119
                   (|HasSignature| |#1|
                                   (LIST '^
                                         (LIST (|devaluate| |#1|)
                                               (|devaluate| |#1|)
                                               '(|Fraction| (|Integer|))))))
         NIL
         NIL
         (QSETREFV $ 129
                   (CONS (|dispatchFunction| |STTAYLOR;powern;F2S;50|) $)))))
      (COND
       ((|testBitVector| |pv$| 1)
        (PROGN
         (QSETREFV $ 131 (CONS (|dispatchFunction| |STTAYLOR;mapdiv;3S;51|) $))
         NIL
         (QSETREFV $ 132
                   (CONS (|dispatchFunction| |STTAYLOR;lazyGintegrate;MAMS;53|)
                         $))
         NIL
         NIL
         (QSETREFV $ 133
                   (CONS (|dispatchFunction| |STTAYLOR;power;A2S;56|) $)))))
      $)))) 

(MAKEPROP '|StreamTaylorSeriesOperations| '|infovec|
          (LIST
           '#(NIL NIL NIL NIL NIL NIL (|local| |#1|) (|Stream| 6) (0 . |empty|)
              (|Boolean|) (4 . |empty?|) (9 . |rst|) (14 . |eq?|) (20 . |frst|)
              (25 . +) (|Mapping| 6 6) (31 . |map|) |STTAYLOR;+;3S;2|
              (37 . |concat|) (|Mapping| $) (43 . |delay|) |STTAYLOR;-;2S;4|
              (48 . -) |STTAYLOR;-;3S;3| (54 . -) (59 . |zero?|) (64 . *)
              |STTAYLOR;*;A2S;5| |STTAYLOR;*;SAS;6| (70 . |Zero|) (74 . =)
              (|Union| $ '"failed") (80 . |recip|) (|Union| 7 '"failed")
              |STTAYLOR;exquo;2SU;8| |STTAYLOR;/;3S;9| |STTAYLOR;recip;SU;10|
              (85 . |One|) (|Integer|) (89 . |Zero|) (93 . <) (99 . |One|)
              (103 . -) (109 . |concat|) |STTAYLOR;monom;AIS;13|
              (|NonNegativeInteger|) (115 . |One|) (119 . +) (|Mapping| 45 45)
              (|Stream| 45) (125 . |generate|) (131 . +) (|Mapping| 38 38)
              (|Stream| 38) (137 . |generate|) |STTAYLOR;integers;IS;15|
              |STTAYLOR;oddintegers;IS;16| (143 . |generate|)
              |STTAYLOR;int;AS;17| (|List| 6) (149 . |cons|) (|SingleInteger|)
              (155 . |Zero|) (159 . |Zero|) (163 . =) (169 . |first|)
              (174 . |rest|) (179 . |explicitlyEmpty?|) (184 . |One|) (188 . -)
              |STTAYLOR;*;3S;19| |STTAYLOR;mapmult;3S;20| (193 . |rest|)
              |STTAYLOR;deriv;2S;21| (|Mapping| 6 38) (|StreamFunctions2| 38 6)
              (198 . |map|) |STTAYLOR;gderiv;M2S;22| |STTAYLOR;coerce;AS;23|
              (|Mapping| 6 6 6) (|StreamFunctions2| 6 6) (204 . |scan|)
              |STTAYLOR;eval;SAS;24| |STTAYLOR;compose;3S;25| (|Mapping| 7 7)
              (|ParadoxicalCombinatorsForStreams| 6) (211 . Y)
              |STTAYLOR;lagrange;2S;27| |STTAYLOR;revert;2S;28| (|Stream| 7)
              (216 . |empty?|) (221 . |frst|) (226 . |rst|)
              |STTAYLOR;addiag;SS;29| (231 . |repeating|) (236 . |concat|)
              (|Mapping| 7 38 6) (|StreamFunctions3| 38 6 7) (242 . |map|)
              |STTAYLOR;lambert;2S;33| |STTAYLOR;oddlambert;2S;34|
              |STTAYLOR;evenlambert;2S;35| |STTAYLOR;generalLambert;S2IS;36|
              (249 . |zero?|) (254 . |rest|) |STTAYLOR;multisect;2I2S;38|
              |STTAYLOR;invmultisect;2I2S;40| (260 . |empty|) (264 . |concat|)
              (|StreamFunctions2| 7 7) (270 . |map|) (276 . |delay|)
              (|Fraction| 38) (281 . /) (287 . *) (293 . |integrate|)
              (|Mapping| 7) (299 . |lazyIntegrate|) (305 . |nlde|) 'RATPOWERS
              (310 . |One|) (314 . +) (320 . |denom|) (325 . |exquo|)
              (331 . |Zero|) (335 . <) (341 . |numer|) (346 . ^) (352 . ^)
              (358 . |powern|) (364 . /) (370 . |mapdiv|)
              (376 . |lazyGintegrate|) (383 . |power|))
           '#(|revert| 389 |recip| 394 |powern| 399 |power| 405 |oddlambert|
              411 |oddintegers| 416 |nlde| 421 |multisect| 426 |monom| 433
              |mapmult| 439 |mapdiv| 445 |lazyIntegrate| 451 |lazyGintegrate|
              457 |lambert| 464 |lagrange| 469 |invmultisect| 474 |integrate|
              481 |integers| 487 |int| 492 |generalLambert| 497 |gderiv| 504
              |exquo| 510 |evenlambert| 516 |eval| 521 |deriv| 527 |compose|
              532 |coerce| 538 |addiag| 543 / 548 - 554 + 565 * 571)
           'NIL
           (CONS (|makeByteWordVec2| 1 'NIL)
                 (CONS '#()
                       (CONS '#()
                             (|makeByteWordVec2| 133
                                                 '(0 7 0 8 1 7 9 0 10 1 7 0 0
                                                   11 2 7 9 0 0 12 1 7 6 0 13 2
                                                   6 0 0 0 14 2 7 0 15 0 16 2 7
                                                   0 6 0 18 1 7 0 19 20 2 6 0 0
                                                   0 22 1 6 0 0 24 1 6 9 0 25 2
                                                   6 0 0 0 26 0 6 0 29 2 6 9 0
                                                   0 30 1 6 31 0 32 0 6 0 37 0
                                                   38 0 39 2 38 9 0 0 40 0 38 0
                                                   41 2 38 0 0 0 42 2 7 0 0 0
                                                   43 0 45 0 46 2 45 0 0 0 47 2
                                                   49 0 48 45 50 2 38 0 0 0 51
                                                   2 53 0 52 38 54 2 7 0 15 6
                                                   57 2 59 0 6 0 60 0 61 0 62 0
                                                   45 0 63 2 45 9 0 0 64 1 59 6
                                                   0 65 1 59 0 0 66 1 7 9 0 67
                                                   0 61 0 68 1 38 0 0 69 1 7 0
                                                   0 72 2 75 7 74 53 76 3 80 7
                                                   6 79 7 81 1 85 7 84 86 1 89
                                                   9 0 90 1 89 7 0 91 1 89 0 0
                                                   92 1 7 0 59 94 2 59 0 0 0 95
                                                   3 97 89 96 53 7 98 1 38 9 0
                                                   103 2 7 0 0 45 104 0 89 0
                                                   107 2 89 0 7 0 108 2 109 89
                                                   84 89 110 1 89 0 19 111 2
                                                   112 0 38 38 113 2 6 0 112 0
                                                   114 2 0 7 6 7 115 2 0 7 6
                                                   116 117 1 0 7 89 118 0 112 0
                                                   120 2 112 0 0 0 121 1 112 38
                                                   0 122 2 38 31 0 0 123 0 112
                                                   0 124 2 112 9 0 0 125 1 112
                                                   38 0 126 2 6 0 0 45 127 2 6
                                                   0 0 112 128 2 0 7 112 7 129
                                                   2 6 0 0 0 130 2 0 7 7 7 131
                                                   3 0 7 74 6 116 132 2 0 7 6 7
                                                   133 1 0 7 7 88 1 0 33 7 36 2
                                                   2 7 112 7 129 2 1 7 6 7 133
                                                   1 0 7 7 100 1 0 53 38 56 1 2
                                                   7 89 118 3 0 7 38 38 7 105 2
                                                   0 7 6 38 44 2 0 7 7 7 71 2 1
                                                   7 7 7 131 2 2 7 6 116 117 3
                                                   1 7 74 6 116 132 1 0 7 7 99
                                                   1 0 7 7 87 3 0 7 38 38 7 106
                                                   2 2 7 6 7 115 1 0 53 38 55 1
                                                   0 7 6 58 3 0 7 7 38 38 102 2
                                                   0 7 74 7 77 2 0 33 7 7 34 1
                                                   0 7 7 101 2 0 7 7 6 82 1 0 7
                                                   7 73 2 0 7 7 7 83 1 0 7 6 78
                                                   1 0 7 89 93 2 0 7 7 7 35 2 0
                                                   7 7 7 23 1 0 7 7 21 2 0 7 7
                                                   7 17 2 0 7 7 7 70 2 0 7 7 6
                                                   28 2 0 7 6 7 27)))))
           '|lookupComplete|)) 
