
(/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;*;3S;5| (|x| |y| $)
  (PROG ()
    (RETURN
     (SPADCALL (CONS #'|STTAYLOR;*;3S;5!0| (VECTOR |x| $ |y|))
               (QREFELT $ 20))))) 

(DEFUN |STTAYLOR;*;3S;5!0| ($$)
  (PROG (|y| $ |x|)
    (LETT |y| (QREFELT $$ 2) . #1=(|STTAYLOR;*;3S;5|))
    (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 $ 25))
         (SPADCALL
          (SPADCALL (SPADCALL |x| (QREFELT $ 13)) (SPADCALL |y| (QREFELT $ 11))
                    (QREFELT $ 26))
          (SPADCALL (SPADCALL |x| (QREFELT $ 11)) |y| (QREFELT $ 27))
          (QREFELT $ 17))
         (QREFELT $ 18)))))))) 

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

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

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

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

(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 $ 25))
                        NIL)
                  (EXIT
                   (SPADCALL |c0|
                             (|STTAYLOR;iDiv|
                              (SPADCALL (SPADCALL |x| (QREFELT $ 11))
                                        (SPADCALL |c0|
                                                  (SPADCALL |y| (QREFELT $ 11))
                                                  (QREFELT $ 26))
                                        (QREFELT $ 23))
                              |y| |ry0| $)
                             (QREFELT $ 18))))))))))))) 

(DEFUN |STTAYLOR;exquo;2SU;9| (|x| |y| $)
  (PROG (|ry0| #1=#:G1933 #2=#:G1945 |n|)
    (RETURN
     (SEQ
      (EXIT
       (SEQ
        (SEQ
         (EXIT
          (SEQ (LETT |n| 1 . #3=(|STTAYLOR;exquo;2SU;9|)) 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| $ 30) (QREFELT $ 31))
                   (COND
                    ((SPADCALL (SPADCALL |x| (QREFELT $ 13))
                               (|spadConstant| $ 30) (QREFELT $ 31))
                     (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 $ 33))
              . #3#)
        (EXIT
         (COND ((QEQCAR |ry0| 1) (CONS 1 "failed"))
               ((SPADCALL (SPADCALL |y| (QREFELT $ 11)) (QREFELT $ 10))
                (CONS 0
                      (SPADCALL
                       (CONS #'|STTAYLOR;exquo;2SU;9!0| (VECTOR $ |ry0|)) |x|
                       (QREFELT $ 16))))
               ('T (CONS 0 (|STTAYLOR;iDiv| |x| |y| (QCDR |ry0|) $)))))))
      #2# (EXIT #2#))))) 

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

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

(DEFUN |STTAYLOR;/;3S;10!1| ($$)
  (PROG (|y| $ |x|)
    (LETT |y| (QREFELT $$ 2) . #1=(|STTAYLOR;/;3S;10|))
    (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 $ 33))
                        NIL)
                  (EXIT
                   (COND
                    ((QEQCAR |ry0| 1)
                     (|error| "/: second argument is not invertible"))
                    ((SPADCALL (SPADCALL |y| (QREFELT $ 11)) (QREFELT $ 10))
                     (SPADCALL (CONS #'|STTAYLOR;/;3S;10!0| (VECTOR $ |ry0|))
                               |x| (QREFELT $ 16)))
                    ('T (|STTAYLOR;iDiv| |x| |y| (QCDR |ry0|) $)))))))))))))) 

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

(DEFUN |STTAYLOR;recip;SU;11| (|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 $ 33))
                    . #2=(|STTAYLOR;recip;SU;11|))
              (EXIT
               (COND ((QEQCAR |rh1| 1) (CONS 1 "failed"))
                     (#1#
                      (SEQ (LETT |rh| (QCDR |rh1|) . #2#)
                           (EXIT
                            (CONS 0
                                  (SPADCALL
                                   (CONS #'|STTAYLOR;recip;SU;11!0|
                                         (VECTOR $ |x| |rh|))
                                   (QREFELT $ 20))))))))))))))) 

(DEFUN |STTAYLOR;recip;SU;11!0| ($$)
  (PROG (|rh| |x| $)
    (LETT |rh| (QREFELT $$ 2) . #1=(|STTAYLOR;recip;SU;11|))
    (LETT |x| (QREFELT $$ 1) . #1#)
    (LETT $ (QREFELT $$ 0) . #1#)
    (RETURN
     (PROGN
      (SPADCALL |rh|
                (|STTAYLOR;iDiv|
                 (SPADCALL
                  (SPADCALL |rh| (SPADCALL |x| (QREFELT $ 11)) (QREFELT $ 26))
                  (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| $ 40) |z| (QREFELT $ 41))
        (SPADCALL |s|
                  (|STTAYLOR;rpSt|
                   (SPADCALL |z| (|spadConstant| $ 42) (QREFELT $ 43)) |s| $)
                  (QREFELT $ 18)))
       ('T (SPADCALL (QREFELT $ 8)))))))) 

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

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

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

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

(DEFUN |STTAYLOR;integers;IS;16!0| (|y| $)
  (SPADCALL |y| (|spadConstant| $ 42) (QREFELT $ 52))) 

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

(DEFUN |STTAYLOR;oddintegers;IS;17!0| (|y| $) (SPADCALL |y| 2 (QREFELT $ 52))) 

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

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

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

(DEFUN |STTAYLOR;mapmult;3S;19!0| ($$)
  (PROG (|y| $ |x|)
    (LETT |y| (QREFELT $$ 2) . #1=(|STTAYLOR;mapmult;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
        (SPADCALL
         (SPADCALL (SPADCALL |x| (QREFELT $ 13)) (SPADCALL |y| (QREFELT $ 13))
                   (QREFELT $ 25))
         (SPADCALL (SPADCALL |x| (QREFELT $ 11)) (SPADCALL |y| (QREFELT $ 11))
                   (QREFELT $ 60))
         (QREFELT $ 18)))))))) 

(DEFUN |STTAYLOR;deriv;2S;20| (|x| $)
  (COND ((SPADCALL |x| (QREFELT $ 10)) (|STTAYLOR;zro| $))
        ('T
         (SPADCALL (SPADCALL (|spadConstant| $ 38) (QREFELT $ 59))
                   (SPADCALL |x| (QREFELT $ 61)) (QREFELT $ 60))))) 

(DEFUN |STTAYLOR;gderiv;M2S;21| (|f| |x| $)
  (COND ((SPADCALL |x| (QREFELT $ 10)) (|STTAYLOR;zro| $))
        ('T
         (SPADCALL (SPADCALL |f| (SPADCALL 0 (QREFELT $ 56)) (QREFELT $ 65))
                   |x| (QREFELT $ 60))))) 

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

(DEFUN |STTAYLOR;eval;SAS;23| (|x| |at| $)
  (PROG ()
    (RETURN
     (SPADCALL (|spadConstant| $ 30) (ELT $ 14)
               (SPADCALL |x|
                         (SPADCALL
                          (CONS #'|STTAYLOR;eval;SAS;23!0| (VECTOR $ |at|))
                          (|spadConstant| $ 38) (QREFELT $ 58))
                         (QREFELT $ 60))
               (QREFELT $ 70))))) 

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

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

(DEFUN |STTAYLOR;compose;3S;24!0| ($$)
  (PROG (|y| $ |x|)
    (LETT |y| (QREFELT $$ 2) . #1=(|STTAYLOR;compose;3S;24|))
    (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 $ 28)))
        (|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 $ 72))
                          (SPADCALL |y| (QREFELT $ 11)) (QREFELT $ 27))
                         (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| $ 30) (SPADCALL |x| |c| (QREFELT $ 72))
                (QREFELT $ 18)))))) 

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

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

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

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

(DEFUN |STTAYLOR;addiag;SS;28!0| ($$)
  (PROG (|ststa| $)
    (LETT |ststa| (QREFELT $$ 1) . #1=(|STTAYLOR;addiag;SS;28|))
    (LETT $ (QREFELT $$ 0) . #1#)
    (RETURN
     (PROGN
      (COND ((SPADCALL |ststa| (QREFELT $ 79)) (|STTAYLOR;zro| $))
            ((SPADCALL (SPADCALL |ststa| (QREFELT $ 80)) (QREFELT $ 10))
             (SPADCALL (|spadConstant| $ 30)
                       (SPADCALL (SPADCALL |ststa| (QREFELT $ 81))
                                 (QREFELT $ 82))
                       (QREFELT $ 18)))
            ('T
             (SPADCALL
              (SPADCALL (SPADCALL |ststa| (QREFELT $ 80)) (QREFELT $ 13))
              (SPADCALL
               (SPADCALL (SPADCALL |ststa| (QREFELT $ 80)) (QREFELT $ 11))
               (SPADCALL (SPADCALL |ststa| (QREFELT $ 81)) (QREFELT $ 82))
               (QREFELT $ 17))
              (QREFELT $ 18)))))))) 

(DEFUN |STTAYLOR;rptg1| (|z| |s| $)
  (SPADCALL (CONS |s| (|STTAYLOR;rp| |z| (|spadConstant| $ 30) $))
            (QREFELT $ 84))) 

(DEFUN |STTAYLOR;rptg2| (|z| |s| $)
  (SPADCALL
   (SPADCALL (|STTAYLOR;rp| |z| (|spadConstant| $ 30) $)
             (CONS |s| (|STTAYLOR;rp| (- |z| 1) (|spadConstant| $ 30) $))
             (QREFELT $ 85))
   (QREFELT $ 84))) 

(DEFUN |STTAYLOR;rptg3| (|a| |d| |n| |s| $)
  (SPADCALL (|STTAYLOR;rpSt| (* |n| (- |a| 1)) (|spadConstant| $ 30) $)
            (SPADCALL
             (CONS |s|
                   (|STTAYLOR;rp| (- (* |d| |n|) 1) (|spadConstant| $ 30) $))
             (QREFELT $ 84))
            (QREFELT $ 44))) 

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

(DEFUN |STTAYLOR;lambert;2S;32!0| ($$)
  (PROG (|x| $)
    (LETT |x| (QREFELT $$ 1) . #1=(|STTAYLOR;lambert;2S;32|))
    (LETT $ (QREFELT $$ 0) . #1#)
    (RETURN
     (PROGN
      (COND ((SPADCALL |x| (QREFELT $ 10)) (|STTAYLOR;zro| $))
            ((SPADCALL (SPADCALL |x| (QREFELT $ 13)) (QREFELT $ 28))
             (SPADCALL (|spadConstant| $ 30)
                       (SPADCALL
                        (SPADCALL (CONS (|function| |STTAYLOR;rptg1|) $)
                                  (SPADCALL (|spadConstant| $ 40)
                                            (QREFELT $ 56))
                                  (SPADCALL |x| (QREFELT $ 11)) (QREFELT $ 88))
                        (QREFELT $ 82))
                       (QREFELT $ 18)))
            ('T (|error| "lambert:constant coefficient should be zero"))))))) 

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

(DEFUN |STTAYLOR;oddlambert;2S;33!0| ($$)
  (PROG (|x| $)
    (LETT |x| (QREFELT $$ 1) . #1=(|STTAYLOR;oddlambert;2S;33|))
    (LETT $ (QREFELT $$ 0) . #1#)
    (RETURN
     (PROGN
      (COND ((SPADCALL |x| (QREFELT $ 10)) (|STTAYLOR;zro| $))
            ((SPADCALL (SPADCALL |x| (QREFELT $ 13)) (QREFELT $ 28))
             (SPADCALL (|spadConstant| $ 30)
                       (SPADCALL
                        (SPADCALL (CONS (|function| |STTAYLOR;rptg1|) $)
                                  (SPADCALL (|spadConstant| $ 42)
                                            (QREFELT $ 57))
                                  (SPADCALL |x| (QREFELT $ 11)) (QREFELT $ 88))
                        (QREFELT $ 82))
                       (QREFELT $ 18)))
            ('T
             (|error| "oddlambert: constant coefficient should be zero"))))))) 

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

(DEFUN |STTAYLOR;evenlambert;2S;34!0| ($$)
  (PROG (|x| $)
    (LETT |x| (QREFELT $$ 1) . #1=(|STTAYLOR;evenlambert;2S;34|))
    (LETT $ (QREFELT $$ 0) . #1#)
    (RETURN
     (PROGN
      (COND ((SPADCALL |x| (QREFELT $ 10)) (|STTAYLOR;zro| $))
            ((SPADCALL (SPADCALL |x| (QREFELT $ 13)) (QREFELT $ 28))
             (SPADCALL (|spadConstant| $ 30)
                       (SPADCALL
                        (SPADCALL (CONS (|function| |STTAYLOR;rptg2|) $)
                                  (SPADCALL (|spadConstant| $ 42)
                                            (QREFELT $ 56))
                                  (SPADCALL |x| (QREFELT $ 11)) (QREFELT $ 88))
                        (QREFELT $ 82))
                       (QREFELT $ 18)))
            ('T
             (|error| "evenlambert: constant coefficient should be zero"))))))) 

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

(DEFUN |STTAYLOR;generalLambert;S2IS;35!1| ($$)
  (PROG (|a| $ |d| |st|)
    (LETT |a| (QREFELT $$ 3) . #1=(|STTAYLOR;generalLambert;S2IS;35|))
    (LETT $ (QREFELT $$ 2) . #1#)
    (LETT |d| (QREFELT $$ 1) . #1#)
    (LETT |st| (QREFELT $$ 0) . #1#)
    (RETURN
     (PROGN
      (PROG ()
        (RETURN
         (COND
          ((OR (SPADCALL |a| (|spadConstant| $ 42) (QREFELT $ 41))
               (SPADCALL |d| (|spadConstant| $ 42) (QREFELT $ 41)))
           (|error| "generalLambert: both integer arguments must be positive"))
          ('T
           (COND ((SPADCALL |st| (QREFELT $ 10)) (|STTAYLOR;zro| $))
                 ((SPADCALL (SPADCALL |st| (QREFELT $ 13)) (QREFELT $ 28))
                  (SPADCALL (|spadConstant| $ 30)
                            (SPADCALL
                             (SPADCALL
                              (CONS #'|STTAYLOR;generalLambert;S2IS;35!0|
                                    (VECTOR $ |d| |a|))
                              (SPADCALL (|spadConstant| $ 42) (QREFELT $ 56))
                              (SPADCALL |st| (QREFELT $ 11)) (QREFELT $ 88))
                             (QREFELT $ 82))
                            (QREFELT $ 18)))
                 ('T
                  (|error|
                   "generalLambert: constant coefficient should be zero"))))))))))) 

(DEFUN |STTAYLOR;generalLambert;S2IS;35!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 $ 93))
             (SPADCALL (SPADCALL |s| (QREFELT $ 13))
                       (|STTAYLOR;ms| |m|
                        (SPADCALL |m| (|spadConstant| $ 42) (QREFELT $ 43))
                        (SPADCALL |s| (QREFELT $ 11)) $)
                       (QREFELT $ 18)))
            ('T
             (|STTAYLOR;ms| |m|
              (SPADCALL |n| (|spadConstant| $ 42) (QREFELT $ 43))
              (SPADCALL |s| (QREFELT $ 11)) $))))))) 

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

(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 $ 44))
                       (QREFELT $ 18)))))))) 

(DEFUN |STTAYLOR;invmultisect;2I2S;39| (|a| |b| |x| $)
  (SPADCALL (|STTAYLOR;rpSt| |b| (|spadConstant| $ 30) $)
            (|STTAYLOR;altn|
             (|STTAYLOR;rpSt| (- (+ |a| |b|) 1) (|spadConstant| $ 30) $) |x| $)
            (QREFELT $ 44))) 

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

(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 $ 79)) (SPADCALL (QREFELT $ 97)))
               ((SPADCALL |x| (QREFELT $ 10))
                (SPADCALL (SPADCALL |ststa| (QREFELT $ 80))
                          (SPADCALL (QREFELT $ 97)) (QREFELT $ 98)))
               ('T
                (SPADCALL (SPADCALL |ststa| (QREFELT $ 80))
                          (SPADCALL (CONS #'|STTAYLOR;comps!0| (VECTOR $ |x|))
                                    (|STTAYLOR;comps|
                                     (SPADCALL |ststa| (QREFELT $ 81)) |x| $)
                                    (QREFELT $ 100))
                          (QREFELT $ 98)))))))))) 

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

(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| $ 42) |n| (QREFELT $ 103))
                        (SPADCALL |x| (QREFELT $ 13)) (QREFELT $ 104))
              (|STTAYLOR;integre| (SPADCALL |x| (QREFELT $ 11))
               (SPADCALL |n| (|spadConstant| $ 42) (QREFELT $ 52)) $)
              (QREFELT $ 18)))))))) 

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

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

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

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

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

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

(DEFUN |STTAYLOR;nlde;SS;46!0| (|y| $$)
  (PROG (|lslsa| $)
    (LETT |lslsa| (QREFELT $$ 1) . #1=(|STTAYLOR;nlde;SS;46|))
    (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 $ 104)))))) 

(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| $ 38)
                (SPADCALL
                 (|STTAYLOR;integ|
                  (|STTAYLOR;smult|
                   (SPADCALL |rn| (|spadConstant| $ 110) (QREFELT $ 111))
                   (SPADCALL |c| (SPADCALL |x| (QREFELT $ 62)) (QREFELT $ 27))
                   $)
                  $)
                 (SPADCALL (SPADCALL |x| (QREFELT $ 11)) |c| (QREFELT $ 27))
                 (QREFELT $ 23))
                (QREFELT $ 18)))))) 

(DEFUN |STTAYLOR;powern;F2S;49| (|rn| |x| $)
  (PROG (|power| #1=#:G2178 #2=#:G2173 |num| |invCo| |co| |ord| #3=#:G2163
         |order| #4=#:G2184 |n|)
    (RETURN
     (SEQ
      (EXIT
       (SEQ (LETT |order| 0 . #5=(|STTAYLOR;powern;F2S;49|))
            (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 $ 28)))
                       (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 $ 112))
                            (QREFELT $ 113))
                  . #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| $ 114) (QREFELT $ 115))
                        (|error| "^: negative power does not exist")))))
                    (LETT |invCo| (SPADCALL |co| (QREFELT $ 33)) . #5#)
                    (EXIT
                     (COND
                      ((QEQCAR |invCo| 1)
                       (|error| "^ rational power of coefficient undefined"))
                      (#6#
                       (SEQ
                        (LETT |power|
                              (COND
                               ((SPADCALL |co| (|spadConstant| $ 38)
                                          (QREFELT $ 31))
                                (SPADCALL
                                 (CONS #'|STTAYLOR;powern;F2S;49!0|
                                       (VECTOR $ |x| |rn|))
                                 (QREFELT $ 75)))
                               ((EQL (SPADCALL |rn| (QREFELT $ 112)) 1)
                                (COND
                                 ((NULL
                                   (MINUSP
                                    (LETT |num| (SPADCALL |rn| (QREFELT $ 116))
                                          . #5#)))
                                  (SPADCALL
                                   (SPADCALL |co|
                                             (PROG1 (LETT #2# |num| . #5#)
                                               (|check-subtype| (>= #2# 0)
                                                                '(|NonNegativeInteger|)
                                                                #2#))
                                             (QREFELT $ 117))
                                   (SPADCALL
                                    (CONS #'|STTAYLOR;powern;F2S;49!1|
                                          (VECTOR $ |x| |invCo| |rn|))
                                    (QREFELT $ 75))
                                   (QREFELT $ 26)))
                                 ('T
                                  (SPADCALL
                                   (SPADCALL (QCDR |invCo|)
                                             (PROG1 (LETT #1# (- |num|) . #5#)
                                               (|check-subtype| (>= #1# 0)
                                                                '(|NonNegativeInteger|)
                                                                #1#))
                                             (QREFELT $ 117))
                                   (SPADCALL
                                    (CONS #'|STTAYLOR;powern;F2S;49!2|
                                          (VECTOR $ |x| |invCo| |rn|))
                                    (QREFELT $ 75))
                                   (QREFELT $ 26)))))
                               ((QREFELT $ 109)
                                (SPADCALL (SPADCALL |co| |rn| (QREFELT $ 118))
                                          (SPADCALL
                                           (CONS #'|STTAYLOR;powern;F2S;49!3|
                                                 (VECTOR $ |x| |invCo| |rn|))
                                           (QREFELT $ 75))
                                          (QREFELT $ 26)))
                               (#6#
                                (|error|
                                 "^ rational power of coefficient undefined")))
                              . #5#)
                        (EXIT
                         (SPADCALL
                          (SPADCALL (|spadConstant| $ 38)
                                    (* (QCDR |ord|)
                                       (SPADCALL |rn| (QREFELT $ 116)))
                                    (QREFELT $ 45))
                          |power| (QREFELT $ 27)))))))))))))
      #4# (EXIT #4#))))) 

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

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

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

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

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

(DEFUN |STTAYLOR;mapdiv;3S;50!0| ($$)
  (PROG (|y| $ |x|)
    (LETT |y| (QREFELT $$ 2) . #1=(|STTAYLOR;mapdiv;3S;50|))
    (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 $ 120))
              (SPADCALL (SPADCALL |x| (QREFELT $ 11))
                        (SPADCALL |y| (QREFELT $ 11)) (QREFELT $ 121))
              (QREFELT $ 18)))))))) 

(DEFUN |STTAYLOR;ginteg| (|f| |x| $)
  (SPADCALL |x| (SPADCALL |f| (SPADCALL 1 (QREFELT $ 56)) (QREFELT $ 65))
            (QREFELT $ 121))) 

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

(DEFUN |STTAYLOR;finteg| (|x| $)
  (SPADCALL |x| (SPADCALL (|spadConstant| $ 38) (QREFELT $ 59))
            (QREFELT $ 121))) 

(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| $ 38)
                        (QREFELT $ 31)))
             (|error| "^:constant coefficient should be 1"))
            ('T
             (SPADCALL (SPADCALL |x| (QREFELT $ 13))
                       (SPADCALL
                        (|STTAYLOR;finteg|
                         (SPADCALL
                          (SPADCALL |s| (|spadConstant| $ 38) (QREFELT $ 14))
                          (SPADCALL |c| (SPADCALL |x| (QREFELT $ 62))
                                    (QREFELT $ 27))
                          (QREFELT $ 26))
                         $)
                        (SPADCALL (SPADCALL |x| (QREFELT $ 11)) |c|
                                  (QREFELT $ 27))
                        (QREFELT $ 23))
                       (QREFELT $ 18)))))))) 

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

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

(DEFUN |StreamTaylorSeriesOperations| (#1=#:G2216)
  (PROG ()
    (RETURN
     (PROG (#2=#:G2217)
       (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 124) . #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 $ 105
                   (CONS (|dispatchFunction| |STTAYLOR;integrate;A2S;43|) $))
         (QSETREFV $ 107
                   (CONS (|dispatchFunction| |STTAYLOR;lazyIntegrate;AMS;44|)
                         $))
         NIL
         (QSETREFV $ 108 (CONS (|dispatchFunction| |STTAYLOR;nlde;SS;46|) $))
         (QSETREFV $ 109
                   (|HasSignature| |#1|
                                   (LIST '^
                                         (LIST (|devaluate| |#1|)
                                               (|devaluate| |#1|)
                                               '(|Fraction| (|Integer|))))))
         NIL
         NIL
         (QSETREFV $ 119
                   (CONS (|dispatchFunction| |STTAYLOR;powern;F2S;49|) $)))))
      (COND
       ((|testBitVector| |pv$| 1)
        (PROGN
         (QSETREFV $ 121 (CONS (|dispatchFunction| |STTAYLOR;mapdiv;3S;50|) $))
         NIL
         (QSETREFV $ 122
                   (CONS (|dispatchFunction| |STTAYLOR;lazyGintegrate;MAMS;52|)
                         $))
         NIL
         NIL
         (QSETREFV $ 123
                   (CONS (|dispatchFunction| |STTAYLOR;power;A2S;55|) $)))))
      $)))) 

(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 . *) |STTAYLOR;*;A2S;6|
              |STTAYLOR;*;3S;5| (65 . |zero?|) |STTAYLOR;*;SAS;7| (70 . |Zero|)
              (74 . =) (|Union| $ '"failed") (80 . |recip|)
              (|Union| 7 '"failed") |STTAYLOR;exquo;2SU;9| |STTAYLOR;/;3S;10|
              |STTAYLOR;recip;SU;11| (85 . |One|) (|Integer|) (89 . |Zero|)
              (93 . <) (99 . |One|) (103 . -) (109 . |concat|)
              |STTAYLOR;monom;AIS;14| (|NonNegativeInteger|) (115 . |One|)
              (119 . +) (|Mapping| 46 46) (|Stream| 46) (125 . |generate|)
              (131 . +) (|Mapping| 39 39) (|Stream| 39) (137 . |generate|)
              |STTAYLOR;integers;IS;16| |STTAYLOR;oddintegers;IS;17|
              (143 . |generate|) |STTAYLOR;int;AS;18| |STTAYLOR;mapmult;3S;19|
              (149 . |rest|) |STTAYLOR;deriv;2S;20| (|Mapping| 6 39)
              (|StreamFunctions2| 39 6) (154 . |map|) |STTAYLOR;gderiv;M2S;21|
              |STTAYLOR;coerce;AS;22| (|Mapping| 6 6 6)
              (|StreamFunctions2| 6 6) (160 . |scan|) |STTAYLOR;eval;SAS;23|
              |STTAYLOR;compose;3S;24| (|Mapping| 7 7)
              (|ParadoxicalCombinatorsForStreams| 6) (167 . Y)
              |STTAYLOR;lagrange;2S;26| |STTAYLOR;revert;2S;27| (|Stream| 7)
              (172 . |empty?|) (177 . |frst|) (182 . |rst|)
              |STTAYLOR;addiag;SS;28| (|List| 6) (187 . |repeating|)
              (192 . |concat|) (|Mapping| 7 39 6) (|StreamFunctions3| 39 6 7)
              (198 . |map|) |STTAYLOR;lambert;2S;32|
              |STTAYLOR;oddlambert;2S;33| |STTAYLOR;evenlambert;2S;34|
              |STTAYLOR;generalLambert;S2IS;35| (205 . |zero?|) (210 . |rest|)
              |STTAYLOR;multisect;2I2S;37| |STTAYLOR;invmultisect;2I2S;39|
              (216 . |empty|) (220 . |concat|) (|StreamFunctions2| 7 7)
              (226 . |map|) (232 . |delay|) (|Fraction| 39) (237 . /) (243 . *)
              (249 . |integrate|) (|Mapping| 7) (255 . |lazyIntegrate|)
              (261 . |nlde|) 'RATPOWERS (266 . |One|) (270 . +) (276 . |denom|)
              (281 . |exquo|) (287 . |Zero|) (291 . <) (297 . |numer|)
              (302 . ^) (308 . ^) (314 . |powern|) (320 . /) (326 . |mapdiv|)
              (332 . |lazyGintegrate|) (339 . |power|))
           '#(|revert| 345 |recip| 350 |powern| 355 |power| 361 |oddlambert|
              367 |oddintegers| 372 |nlde| 377 |multisect| 382 |monom| 389
              |mapmult| 395 |mapdiv| 401 |lazyIntegrate| 407 |lazyGintegrate|
              413 |lambert| 420 |lagrange| 425 |invmultisect| 430 |integrate|
              437 |integers| 443 |int| 448 |generalLambert| 453 |gderiv| 460
              |exquo| 466 |evenlambert| 472 |eval| 477 |deriv| 483 |compose|
              488 |coerce| 494 |addiag| 499 / 504 - 510 + 521 * 527)
           'NIL
           (CONS (|makeByteWordVec2| 1 'NIL)
                 (CONS '#()
                       (CONS '#()
                             (|makeByteWordVec2| 123
                                                 '(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 2 6 0 0 0 25
                                                   1 6 9 0 28 0 6 0 30 2 6 9 0
                                                   0 31 1 6 32 0 33 0 6 0 38 0
                                                   39 0 40 2 39 9 0 0 41 0 39 0
                                                   42 2 39 0 0 0 43 2 7 0 0 0
                                                   44 0 46 0 47 2 46 0 0 0 48 2
                                                   50 0 49 46 51 2 39 0 0 0 52
                                                   2 54 0 53 39 55 2 7 0 15 6
                                                   58 1 7 0 0 61 2 64 7 63 54
                                                   65 3 69 7 6 68 7 70 1 74 7
                                                   73 75 1 78 9 0 79 1 78 7 0
                                                   80 1 78 0 0 81 1 7 0 83 84 2
                                                   83 0 0 0 85 3 87 78 86 54 7
                                                   88 1 39 9 0 93 2 7 0 0 46 94
                                                   0 78 0 97 2 78 0 7 0 98 2 99
                                                   78 73 78 100 1 78 0 19 101 2
                                                   102 0 39 39 103 2 6 0 102 0
                                                   104 2 0 7 6 7 105 2 0 7 6
                                                   106 107 1 0 7 78 108 0 102 0
                                                   110 2 102 0 0 0 111 1 102 39
                                                   0 112 2 39 32 0 0 113 0 102
                                                   0 114 2 102 9 0 0 115 1 102
                                                   39 0 116 2 6 0 0 46 117 2 6
                                                   0 0 102 118 2 0 7 102 7 119
                                                   2 6 0 0 0 120 2 0 7 7 7 121
                                                   3 0 7 63 6 106 122 2 0 7 6 7
                                                   123 1 0 7 7 77 1 0 34 7 37 2
                                                   2 7 102 7 119 2 1 7 6 7 123
                                                   1 0 7 7 90 1 0 54 39 57 1 2
                                                   7 78 108 3 0 7 39 39 7 95 2
                                                   0 7 6 39 45 2 0 7 7 7 60 2 1
                                                   7 7 7 121 2 2 7 6 106 107 3
                                                   1 7 63 6 106 122 1 0 7 7 89
                                                   1 0 7 7 76 3 0 7 39 39 7 96
                                                   2 2 7 6 7 105 1 0 54 39 56 1
                                                   0 7 6 59 3 0 7 7 39 39 92 2
                                                   0 7 63 7 66 2 0 34 7 7 35 1
                                                   0 7 7 91 2 0 7 7 6 71 1 0 7
                                                   7 62 2 0 7 7 7 72 1 0 7 6 67
                                                   1 0 7 78 82 2 0 7 7 7 36 2 0
                                                   7 7 7 23 1 0 7 7 21 2 0 7 7
                                                   7 17 2 0 7 7 7 27 2 0 7 7 6
                                                   29 2 0 7 6 7 26)))))
           '|lookupComplete|)) 
