
(/VERSIONCHECK 2) 

(DEFUN |RDEEF;RF2GP| (|f| $)
  (PROG (#0=#:G1873)
    (RETURN
      (PROG2 (LETT #0#
                   (SPADCALL
                       (SPADCALL (SPADCALL |f| (QREFELT $ 18))
                           (QREFELT $ 20))
                       (SPADCALL (SPADCALL |f| (QREFELT $ 21))
                           (QREFELT $ 20))
                       (QREFELT $ 23))
                   |RDEEF;RF2GP|)
             (QCDR #0#)
        (|check-union| (QEQCAR #0# 0)
            (|LaurentPolynomial| (QREFELT $ 7)
                (|SparseUnivariatePolynomial| (QREFELT $ 7)))
            #0#))))) 

(DEFUN |RDEEF;logdiff| (|twr| |bad| $)
  (PROG (#0=#:G1880 |u| #1=#:G1881)
    (RETURN
      (SEQ (PROGN
             (LETT #0# NIL . #2=(|RDEEF;logdiff|))
             (SEQ (LETT |u| NIL . #2#) (LETT #1# |twr| . #2#) G190
                  (COND
                    ((OR (ATOM #1#)
                         (PROGN (LETT |u| (CAR #1#) . #2#) NIL))
                     (GO G191)))
                  (SEQ (EXIT (COND
                               ((COND
                                  ((SPADCALL |u|
                                    (SPADCALL "log" (QREFELT $ 10))
                                    (QREFELT $ 26))
                                   (COND
                                     ((SPADCALL |u| |bad|
                                       (QREFELT $ 28))
                                      'NIL)
                                     ('T 'T)))
                                  ('T 'NIL))
                                (LETT #0# (CONS |u| #0#) . #2#)))))
                  (LETT #1# (CDR #1#) . #2#) (GO G190) G191
                  (EXIT (NREVERSE0 #0#)))))))) 

(DEFUN |RDEEF;rischDEalg|
       (|n| |nfp| |f| |g| |k| |l| |x| |limint| |extint| $)
  (PROG (|kx| |u| |rec| |y| |lk| |lv| |rc|)
    (RETURN
      (SEQ (COND
             ((QEQCAR (SPADCALL
                          (LETT |kx|
                                (SPADCALL |k| |l| |x| (QREFELT $ 30))
                                . #0=(|RDEEF;rischDEalg|))
                          (QREFELT $ 32))
                      0)
              (SEQ (LETT |u|
                         (SPADCALL |nfp| |f| |g| |kx| |k|
                             (CONS #'|RDEEF;rischDEalg!0|
                                   (VECTOR $ |n|))
                             (QREFELT $ 36)) . #0#)
                   (EXIT (COND
                           ((QEQCAR |u| 1)
                            (VECTOR (|spadConstant| $ 38)
                                    (|spadConstant| $ 38) 'NIL))
                           ('T (VECTOR (QCDR |u|) |g| 'T))))))
             ((SPADCALL (SPADCALL |kx| (QREFELT $ 40)) (QREFELT $ 11)
                  (QREFELT $ 41))
              (SEQ (LETT |rec|
                         (SPADCALL (SPADCALL |kx| (QREFELT $ 43))
                             (SPADCALL |k| (QREFELT $ 43))
                             (QREFELT $ 46)) . #0#)
                   (LETT |y|
                         (SPADCALL (QVELT |rec| 3) (QREFELT $ 48)) . #0#)
                   (LETT |lk| (LIST |kx| |k|) . #0#)
                   (LETT |lv|
                         (LIST (SPADCALL (QVELT |rec| 1) |y|
                                   (QREFELT $ 49))
                               (SPADCALL (QVELT |rec| 2) |y|
                                   (QREFELT $ 49))) . #0#)
                   (LETT |rc|
                         (SPADCALL |n|
                             (SPADCALL |f| |lk| |lv| (QREFELT $ 52))
                             (SPADCALL |g| |lk| |lv| (QREFELT $ 52))
                             |x| |limint| |extint| (QREFELT $ 62)) . #0#)
                   (EXIT (COND
                           ((QVELT |rc| 2)
                            (VECTOR (SPADCALL (QVELT |rc| 0)
                                     (SPADCALL |y| (QREFELT $ 63))
                                     (QVELT |rec| 0) (QREFELT $ 64))
                                    (QVELT |rc| 1) 'T))
                           ('T
                            (VECTOR (|spadConstant| $ 38)
                                    (|spadConstant| $ 38) 'NIL))))))
             ('T (|error| "Function not supported by Risch d.e."))))))) 

(DEFUN |RDEEF;rischDEalg!0| (|#1| |#2| |#3| $$)
  (|RDEEF;normal0| (QREFELT $$ 1) |#1| |#2| |#3| (QREFELT $$ 0))) 

(DEFUN |RDEEF;rischDE;I2FSMMR;4|
       (|n| |f| |g| |x| |limitedint| |extendedint| $)
  (PROG (|nfp| |u| |y| |vl| |k|)
    (RETURN
      (SEQ (COND
             ((SPADCALL |g| (QREFELT $ 65))
              (VECTOR (|spadConstant| $ 38) |g| 'T))
             ((SPADCALL
                  (LETT |nfp|
                        (SPADCALL |n| (SPADCALL |f| |x| (QREFELT $ 66))
                            (QREFELT $ 67))
                        . #0=(|RDEEF;rischDE;I2FSMMR;4|))
                  (QREFELT $ 65))
              (SEQ (LETT |u| (SPADCALL |g| NIL |limitedint|) . #0#)
                   (EXIT (COND
                           ((QEQCAR |u| 1)
                            (VECTOR (|spadConstant| $ 38)
                                    (|spadConstant| $ 38) 'NIL))
                           ('T (VECTOR (QCAR (QCDR |u|)) |g| 'T))))))
             ((SPADCALL
                  (LETT |y| (SPADCALL |g| |nfp| (QREFELT $ 68)) . #0#)
                  |x| (QREFELT $ 69))
              (VECTOR |y| |g| 'T))
             ('T
              (SEQ (LETT |vl|
                         (SPADCALL
                             (SPADCALL (SPADCALL |nfp| (QREFELT $ 70))
                                 (SPADCALL |g| (QREFELT $ 70))
                                 (QREFELT $ 71))
                             |x| (QREFELT $ 72)) . #0#)
                   (EXIT (COND
                           ((QEQCAR (SPADCALL
                                     (LETT |k|
                                      (SPADCALL |vl| (QREFELT $ 73)) . #0#)
                                     (QREFELT $ 32))
                                    0)
                            (|RDEEF;normalise0| |n| |f| |g| |x| $))
                           ((OR (SPADCALL |k|
                                    (SPADCALL "log" (QREFELT $ 10))
                                    (QREFELT $ 26))
                                (SPADCALL |k|
                                    (SPADCALL "exp" (QREFELT $ 10))
                                    (QREFELT $ 26)))
                            (|RDEEF;normalise| |n| |nfp| |f| |g| |x|
                                |k| |limitedint| |extendedint| $))
                           ('T
                            (COND
                              ((SPADCALL (SPADCALL |k| (QREFELT $ 40))
                                   (QREFELT $ 11) (QREFELT $ 41))
                               (|RDEEF;rischDEalg| |n| |nfp| |f| |g|
                                   |k| |vl| |x| |limitedint|
                                   |extendedint| $))
                              ('T
                               (|error| "Function not supported by Risch d.e."))))))))))))) 

(DEFUN |RDEEF;normal0| (|n| |f| |g| |x| $)
  (PROG (|rec|)
    (RETURN
      (SEQ (LETT |rec| (|RDEEF;normalise0| |n| |f| |g| |x| $)
                 |RDEEF;normal0|)
           (EXIT (COND
                   ((QVELT |rec| 2) (CONS 0 (QVELT |rec| 0)))
                   ('T (CONS 1 "failed")))))))) 

(DEFUN |RDEEF;normalise0| (|n| |f| |g| |x| $)
  (PROG (|k| |data1| |data| |nfprime| |v| #0=#:G1970 |m| #1=#:G1963 |p|
             |f'| |rec| |y|)
    (RETURN
      (SEQ (LETT |k| (SPADCALL |x| (QREFELT $ 74))
                 . #2=(|RDEEF;normalise0|))
           (SEQ (LETT |data1|
                      (SPADCALL |f| (QREFELT $ 15) (QREFELT $ 76)) . #2#)
                (EXIT (COND
                        ((QEQCAR |data1| 1)
                         (SPADCALL (QREFELT $ 15) |f|
                             (LETT |data|
                                   (|RDEEF;makeData| |f| |x| |k| $) . #2#)
                             (QREFELT $ 78)))
                        ('T (LETT |data| (QCDR |data1|) . #2#)))))
           (LETT |f'|
                 (LETT |nfprime|
                       (SPADCALL |n| (SPADCALL |f| |x| (QREFELT $ 66))
                           (QREFELT $ 67)) . #2#) . #2#)
           (LETT |p| (|spadConstant| $ 80) . #2#)
           (SEQ (LETT |v| NIL . #2#) (LETT #0# |data| . #2#) G190
                (COND
                  ((OR (ATOM #0#)
                       (PROGN (LETT |v| (CAR #0#) . #2#) NIL))
                   (GO G191)))
                (SEQ (EXIT (COND
                             ((< 0 (LETT |m| (* |n| (QCAR |v|)) . #2#))
                              (SEQ (LETT |p|
                                    (SPADCALL |p|
                                     (SPADCALL (QCDR |v|)
                                      (PROG1 (LETT #1# |m| . #2#)
                                        (|check-subtype| (>= #1# 0)
                                         '(|NonNegativeInteger|) #1#))
                                      (QREFELT $ 85))
                                     (QREFELT $ 86)) . #2#)
                                   (EXIT
                                    (LETT |f'|
                                     (SPADCALL |f'|
                                      (SPADCALL
                                       (SPADCALL |m|
                                        (SPADCALL
                                         (SPADCALL (QCDR |v|)
                                          (QREFELT $ 88))
                                         |x| (QREFELT $ 66))
                                        (QREFELT $ 67))
                                       (SPADCALL (QCDR |v|)
                                        (QREFELT $ 88))
                                       (QREFELT $ 68))
                                      (QREFELT $ 89)) . #2#)))))))
                (LETT #0# (CDR #0#) . #2#) (GO G190) G191 (EXIT NIL))
           (LETT |rec|
                 (SPADCALL (SPADCALL |f'| |k| (QREFELT $ 91))
                     (SPADCALL (SPADCALL (SPADCALL |p| (QREFELT $ 88))
                                   |g| (QREFELT $ 92))
                               |k| (QREFELT $ 91))
                     (QREFELT $ 95)) . #2#)
           (LETT |y|
                 (SPADCALL (SPADCALL (QCAR |rec|) |k| (QREFELT $ 97))
                     (SPADCALL |p| (QREFELT $ 88)) (QREFELT $ 68)) . #2#)
           (EXIT (COND
                   ((QCDR |rec|)
                    (VECTOR |y|
                            (SPADCALL (SPADCALL |y| |x| (QREFELT $ 66))
                                (SPADCALL |nfprime| |y| (QREFELT $ 92))
                                (QREFELT $ 98))
                            'NIL))
                   ('T (VECTOR |y| |g| 'T)))))))) 

(DEFUN |RDEEF;normalise|
       (|n| |nfp| |f| |g| |x| |k| |limitedint| |extendedint| $)
  (PROG (|data1| |data| |v| #0=#:G1999 |m| #1=#:G1980 |p| |newf| |newg|
                 |twr| #2=#:G1995 |ans1|)
    (RETURN
      (SEQ (SEQ (LETT |data1|
                      (SPADCALL |f| (QREFELT $ 15) (QREFELT $ 76))
                      . #3=(|RDEEF;normalise|))
                (EXIT (COND
                        ((QEQCAR |data1| 1)
                         (SPADCALL (QREFELT $ 15) |f|
                             (LETT |data|
                                   (|RDEEF;makeData| |f| |x| |k| $) . #3#)
                             (QREFELT $ 78)))
                        (#4='T (LETT |data| (QCDR |data1|) . #3#)))))
           (LETT |p| (|spadConstant| $ 80) . #3#)
           (SEQ (LETT |v| NIL . #3#) (LETT #0# |data| . #3#) G190
                (COND
                  ((OR (ATOM #0#)
                       (PROGN (LETT |v| (CAR #0#) . #3#) NIL))
                   (GO G191)))
                (SEQ (EXIT (COND
                             ((< 0 (LETT |m| (* |n| (QCAR |v|)) . #3#))
                              (SEQ (LETT |p|
                                    (SPADCALL |p|
                                     (SPADCALL (QCDR |v|)
                                      (PROG1 (LETT #1# |m| . #3#)
                                        (|check-subtype| (>= #1# 0)
                                         '(|NonNegativeInteger|) #1#))
                                      (QREFELT $ 85))
                                     (QREFELT $ 86)) . #3#)
                                   (LETT |f|
                                    (SPADCALL |f|
                                     (SPADCALL (QCAR |v|)
                                      (SPADCALL
                                       (SPADCALL (QCDR |v|)
                                        (QREFELT $ 88))
                                       (QREFELT $ 99))
                                      (QREFELT $ 67))
                                     (QREFELT $ 89)) . #3#)
                                   (EXIT
                                    (LETT |nfp|
                                     (SPADCALL |nfp|
                                      (SPADCALL
                                       (SPADCALL |m|
                                        (SPADCALL
                                         (SPADCALL (QCDR |v|)
                                          (QREFELT $ 88))
                                         |x| (QREFELT $ 66))
                                        (QREFELT $ 67))
                                       (SPADCALL (QCDR |v|)
                                        (QREFELT $ 88))
                                       (QREFELT $ 68))
                                      (QREFELT $ 89)) . #3#)))))))
                (LETT #0# (CDR #0#) . #3#) (GO G190) G191 (EXIT NIL))
           (LETT |newf| (SPADCALL |nfp| |k| (QREFELT $ 91)) . #3#)
           (LETT |newg|
                 (SPADCALL
                     (SPADCALL (SPADCALL |p| (QREFELT $ 88)) |g|
                         (QREFELT $ 92))
                     |k| (QREFELT $ 91)) . #3#)
           (LETT |twr|
                 (SPADCALL
                     (|RDEEF;logdiff| (SPADCALL |f| (QREFELT $ 100))
                         NIL $)
                     (|RDEEF;logdiff| (SPADCALL |g| (QREFELT $ 100))
                         NIL $)
                     (QREFELT $ 71)) . #3#)
           (LETT |ans1|
                 (COND
                   ((SPADCALL |k| (SPADCALL "log" (QREFELT $ 10))
                        (QREFELT $ 26))
                    (|RDEEF;rischDElog| |twr| |newf| |newg| |x| |k|
                        (CONS #'|RDEEF;normalise!1| (VECTOR |k| |x| $))
                        |limitedint| |extendedint| $))
                   ('T
                    (SEQ (EXIT (COND
                                 ((SPADCALL |k|
                                      (SPADCALL "exp" (QREFELT $ 10))
                                      (QREFELT $ 26))
                                  (PROGN
                                    (LETT #2#
                                     (|RDEEF;rischDEexp| |twr| |newf|
                                      |newg| |x| |k|
                                      (CONS #'|RDEEF;normalise!3|
                                       (VECTOR |k| |x| $))
                                      |limitedint| |extendedint| $) . #3#)
                                    (GO #2#)))))
                         #2# (EXIT #2#)))) . #3#)
           (EXIT (COND
                   ((QEQCAR |ans1| 1)
                    (VECTOR (|spadConstant| $ 38) (|spadConstant| $ 38)
                            'NIL))
                   (#4#
                    (VECTOR (SPADCALL
                                (SPADCALL (QCDR |ans1|) |k|
                                    (QREFELT $ 97))
                                (SPADCALL |p| (QREFELT $ 88))
                                (QREFELT $ 68))
                            |g| 'T)))))))) 

(DEFUN |RDEEF;normalise!3| (|#1| $$)
  (PROG ($ |x|)
    (LETT $ (QREFELT $$ 2) . #0=(|RDEEF;normalise|))
    (LETT |x| (QREFELT $$ 1) . #0#)
    (RETURN
      (PROGN
        (SPADCALL |#1| (CONS #'|RDEEF;normalise!2| (VECTOR $ |x|))
            (SPADCALL
                (SPADCALL
                    (SPADCALL (SPADCALL (QREFELT $$ 0) (QREFELT $ 105))
                        (QREFELT $ 106))
                    |x| (QREFELT $ 66))
                (|spadConstant| $ 108) (QREFELT $ 109))
            (QREFELT $ 103)))))) 

(DEFUN |RDEEF;normalise!2| (|#1| $$)
  (SPADCALL |#1| (QREFELT $$ 1) (QREFELT (QREFELT $$ 0) 66))) 

(DEFUN |RDEEF;normalise!1| (|#1| $$)
  (PROG ($ |x|)
    (LETT $ (QREFELT $$ 2) . #0=(|RDEEF;normalise|))
    (LETT |x| (QREFELT $$ 1) . #0#)
    (RETURN
      (PROGN
        (SPADCALL |#1| (CONS #'|RDEEF;normalise!0| (VECTOR $ |x|))
            (SPADCALL
                (SPADCALL (SPADCALL (QREFELT $$ 0) (QREFELT $ 43)) |x|
                    (QREFELT $ 66))
                (QREFELT $ 101))
            (QREFELT $ 103)))))) 

(DEFUN |RDEEF;normalise!0| (|#1| $$)
  (SPADCALL |#1| (QREFELT $$ 1) (QREFELT (QREFELT $$ 0) 66))) 

(DEFUN |RDEEF;makeData| (|f| |x| |k| $)
  (PROG (|fnum| |fden| |u| #0=#:G2015 |logand| |num| |cf| |n|
                |disasters|)
    (RETURN
      (SEQ (LETT |disasters| NIL . #1=(|RDEEF;makeData|))
           (LETT |fnum| (SPADCALL |f| (QREFELT $ 110)) . #1#)
           (LETT |fden| (SPADCALL |f| (QREFELT $ 111)) . #1#)
           (SEQ (LETT |u| NIL . #1#)
                (LETT #0#
                      (SPADCALL (SPADCALL |f| (QREFELT $ 70)) |x|
                          (QREFELT $ 72)) . #1#)
                G190
                (COND
                  ((OR (ATOM #0#)
                       (PROGN (LETT |u| (CAR #0#) . #1#) NIL))
                   (GO G191)))
                (SEQ (EXIT (COND
                             ((SPADCALL |u|
                                  (SPADCALL "log" (QREFELT $ 10))
                                  (QREFELT $ 26))
                              (SEQ (LETT |logand|
                                    (|SPADfirst|
                                     (SPADCALL |u| (QREFELT $ 105))) . #1#)
                                   (EXIT
                                    (COND
                                      ((ZEROP
                                        (SPADCALL
                                         (SPADCALL |fden| |u|
                                          (QREFELT $ 112))
                                         (QREFELT $ 114)))
                                       (COND
                                         ((EQL
                                           (SPADCALL
                                            (LETT |num|
                                             (SPADCALL |fnum| |u|
                                              (QREFELT $ 112)) . #1#)
                                            (QREFELT $ 114))
                                           1)
                                          (SEQ
                                           (LETT |cf|
                                            (SPADCALL
                                             (SPADCALL |num|
                                              (QREFELT $ 115))
                                             |fden| (QREFELT $ 116)) . #1#)
                                           (LETT |n|
                                            (SPADCALL |cf|
                                             (QREFELT $ 118)) . #1#)
                                           (EXIT
                                            (COND
                                              ((QEQCAR |n| 0)
                                               (SEQ
                                                (COND
                                                  ((< 0
                                                    (SPADCALL
                                                     (SPADCALL |logand|
                                                      (QREFELT $ 110))
                                                     |k|
                                                     (QREFELT $ 120)))
                                                   (LETT |disasters|
                                                    (CONS
                                                     (CONS (QCDR |n|)
                                                      (SPADCALL
                                                       |logand|
                                                       (QREFELT $ 110)))
                                                     |disasters|) . #1#)))
                                                (EXIT
                                                 (COND
                                                   ((< 0
                                                     (SPADCALL
                                                      (SPADCALL
                                                       |logand|
                                                       (QREFELT $ 111))
                                                      |k|
                                                      (QREFELT $ 120)))
                                                    (LETT |disasters|
                                                     (CONS
                                                      (CONS
                                                       (- (QCDR |n|))
                                                       (SPADCALL
                                                        |logand|
                                                        (QREFELT $ 111)))
                                                      |disasters|) . #1#)))))))))))))))))))
                (LETT #0# (CDR #0#) . #1#) (GO G190) G191 (EXIT NIL))
           (EXIT |disasters|))))) 

(DEFUN |RDEEF;rischDElog|
       (|twr| |f| |g| |x| |theta| |driv| |limint| |extint| $)
  (PROG (|u| |v|)
    (RETURN
      (SEQ (LETT |u| (SPADCALL |f| |g| |driv| (QREFELT $ 124))
                 . #0=(|RDEEF;rischDElog|))
           (EXIT (COND
                   ((QEQCAR |u| 1) (CONS 1 "failed"))
                   (#1='T
                    (SEQ (LETT |v|
                               (|RDEEF;polyDElog| |twr|
                                   (QVELT (QCDR |u|) 0)
                                   (SPADCALL (QVELT (QCDR |u|) 1)
                                    (QREFELT $ 125))
                                   (SPADCALL (QVELT (QCDR |u|) 2)
                                    (QREFELT $ 125))
                                   |x| |theta| |driv| |limint| |extint|
                                   $) . #0#)
                         (EXIT (COND
                                 ((QEQCAR |v| 1) (CONS 1 "failed"))
                                 (#1#
                                  (CONS 0
                                        (SPADCALL (QCDR |v|)
                                         (QVELT (QCDR |u|) 3)
                                         (QREFELT $ 126)))))))))))))) 

(DEFUN |RDEEF;rischDEexp|
       (|twr| |f| |g| |x| |theta| |driv| |limint| |extint| $)
  (PROG (|u| |v|)
    (RETURN
      (SEQ (LETT |u| (SPADCALL |f| |g| |driv| (QREFELT $ 124))
                 . #0=(|RDEEF;rischDEexp|))
           (EXIT (COND
                   ((QEQCAR |u| 1) (CONS 1 "failed"))
                   (#1='T
                    (SEQ (LETT |v|
                               (|RDEEF;gpolDEexp| |twr|
                                   (QVELT (QCDR |u|) 0)
                                   (|RDEEF;RF2GP| (QVELT (QCDR |u|) 1)
                                    $)
                                   (|RDEEF;RF2GP| (QVELT (QCDR |u|) 2)
                                    $)
                                   |x| |theta| |driv| |limint| |extint|
                                   $) . #0#)
                         (EXIT (COND
                                 ((QEQCAR |v| 1) (CONS 1 "failed"))
                                 (#1#
                                  (CONS 0
                                        (SPADCALL
                                         (SPADCALL (QCDR |v|)
                                          (QREFELT $ 127))
                                         (SPADCALL (QVELT (QCDR |u|) 3)
                                          (QREFELT $ 128))
                                         (QREFELT $ 129)))))))))))))) 

(DEFUN |RDEEF;polyDElog|
       (|twr| |aa| |bb| |cc| |x| |t| |driv| |limint| |extint| $)
  (PROG (|t'| |db| |da| |f0| |lk0| |lk1| #0=#:G2114 #1=#:G2115 |if0|
              |alph| |ans| #2=#:G2113 #3=#:G2084 |i| |r| |nn| |n| |v|
              #4=#:G2103 |w| |u|)
    (RETURN
      (SEQ (EXIT (COND
                   ((SPADCALL |cc| (QREFELT $ 130))
                    (CONS 0 (|spadConstant| $ 131)))
                   ('T
                    (SEQ (LETT |t'|
                               (SPADCALL (SPADCALL |t| (QREFELT $ 43))
                                   |x| (QREFELT $ 66))
                               . #5=(|RDEEF;polyDElog|))
                         (EXIT (COND
                                 ((SPADCALL |bb| (QREFELT $ 130))
                                  (SEQ (LETT |u|
                                        (SPADCALL |cc| |aa|
                                         (QREFELT $ 132)) . #5#)
                                       (EXIT
                                        (COND
                                          ((QEQCAR |u| 1)
                                           (CONS 1 "failed"))
                                          ('T
                                           (SPADCALL (QCDR |u|)
                                            (CONS #'|RDEEF;polyDElog!0|
                                             (VECTOR |extint| |t'|))
                                            |t'| (QREFELT $ 136)))))))
                                 ('T
                                  (SEQ (LETT |n|
                                        (-
                                         (SPADCALL |cc|
                                          (QREFELT $ 137))
                                         (LETT |db|
                                          (SPADCALL |bb|
                                           (QREFELT $ 137)) . #5#)) . #5#)
                                       (SEQ
                                        (LETT |da|
                                         (SPADCALL |aa|
                                          (QREFELT $ 137)) . #5#)
                                        (EXIT
                                         (COND
                                           ((EQL |da| |db|)
                                            (COND
                                              ((< 0 |da|)
                                               (SEQ
                                                (LETT |lk0|
                                                 (SPADCALL
                                                  (LETT |f0|
                                                   (SPADCALL
                                                    (SPADCALL
                                                     (SPADCALL |bb|
                                                      (QREFELT $ 138))
                                                     (SPADCALL |aa|
                                                      (QREFELT $ 138))
                                                     (QREFELT $ 68))
                                                    (QREFELT $ 139)) . #5#)
                                                  (QREFELT $ 100)) . #5#)
                                                (LETT |lk1|
                                                 (|RDEEF;logdiff| |twr|
                                                  |lk0| $) . #5#)
                                                (LETT |if0|
                                                 (SPADCALL |f0|
                                                  (PROGN
                                                    (LETT #0#
                                                     NIL . #5#)
                                                    (SEQ
                                                     (LETT |u|
                                                      NIL . #5#)
                                                     (LETT #1#
                                                      |lk1| . #5#)
                                                     G190
                                                     (COND
                                                       ((OR (ATOM #1#)
                                                         (PROGN
                                                           (LETT |u|
                                                            (CAR #1#) . #5#)
                                                           NIL))
                                                        (GO G191)))
                                                     (SEQ
                                                      (EXIT
                                                       (LETT #0#
                                                        (CONS
                                                         (|SPADfirst|
                                                          (SPADCALL |u|
                                                           (QREFELT $
                                                            105)))
                                                         #0#) . #5#)))
                                                     (LETT #1#
                                                      (CDR #1#) . #5#)
                                                     (GO G190) G191
                                                     (EXIT
                                                      (NREVERSE0 #0#))))
                                                  |limint|) . #5#)
                                                (EXIT
                                                 (COND
                                                   ((QEQCAR |if0| 1)
                                                    (|error|
                                                     "Risch's theorem violated"))
                                                   ('T
                                                    (SEQ
                                                     (EXIT
                                                      (SEQ
                                                       (LETT |alph|
                                                        (SPADCALL |lk0|
                                                         (|RDEEF;RRF2F|
                                                          (QCDR |if0|)
                                                          $)
                                                         |x|
                                                         (QREFELT $
                                                          141)) . #5#)
                                                       (EXIT
                                                        (COND
                                                          ((QEQCAR
                                                            |alph| 0)
                                                           (PROGN
                                                             (LETT #3#
                                                              (PROGN
                                                                (LETT
                                                                 #2#
                                                                 (SEQ
                                                                  (LETT
                                                                   |ans|
                                                                   (|RDEEF;polyDElog|
                                                                    |twr|
                                                                    (SPADCALL
                                                                     (QCDR
                                                                      |alph|)
                                                                     |aa|
                                                                     (QREFELT
                                                                      $
                                                                      142))
                                                                    (SPADCALL
                                                                     (SPADCALL
                                                                      (SPADCALL
                                                                       (QCDR
                                                                        |alph|)
                                                                       |x|
                                                                       (QREFELT
                                                                        $
                                                                        66))
                                                                      |aa|
                                                                      (QREFELT
                                                                       $
                                                                       142))
                                                                     (SPADCALL
                                                                      (QCDR
                                                                       |alph|)
                                                                      |bb|
                                                                      (QREFELT
                                                                       $
                                                                       142))
                                                                     (QREFELT
                                                                      $
                                                                      143))
                                                                    |cc|
                                                                    |x|
                                                                    |t|
                                                                    |driv|
                                                                    |limint|
                                                                    |extint|
                                                                    $) . #5#)
                                                                  (EXIT
                                                                   (COND
                                                                     ((QEQCAR
                                                                       |ans|
                                                                       1)
                                                                      (CONS
                                                                       1
                                                                       "failed"))
                                                                     ('T
                                                                      (CONS
                                                                       0
                                                                       (SPADCALL
                                                                        (QCDR
                                                                         |alph|)
                                                                        (QCDR
                                                                         |ans|)
                                                                        (QREFELT
                                                                         $
                                                                         142))))))) . #5#)
                                                                (GO
                                                                 #2#)) . #5#)
                                                             (GO #3#)))))))
                                                     #3# (EXIT #3#))))))))))))
                                       (COND
                                         ((< (+ |db| 1) |da|)
                                          (LETT |n|
                                           (MAX 0
                                            (+
                                             (-
                                              (SPADCALL |cc|
                                               (QREFELT $ 137))
                                              |da|)
                                             1)) . #5#)))
                                       (COND
                                         ((EQL |da| (+ |db| 1))
                                          (SEQ
                                           (LETT |i|
                                            (SPADCALL
                                             (SPADCALL
                                              (SPADCALL
                                               (SPADCALL |bb|
                                                (QREFELT $ 138))
                                               (SPADCALL |aa|
                                                (QREFELT $ 138))
                                               (QREFELT $ 68))
                                              (QREFELT $ 139))
                                             (LIST
                                              (|SPADfirst|
                                               (SPADCALL |t|
                                                (QREFELT $ 105))))
                                             |limint|) . #5#)
                                           (EXIT
                                            (COND
                                              ((NULL (QEQCAR |i| 1))
                                               (SEQ
                                                (LETT |r|
                                                 (COND
                                                   ((NULL
                                                     (QCDR (QCDR |i|)))
                                                    (|spadConstant| $
                                                     38))
                                                   ('T
                                                    (QCAR
                                                     (|SPADfirst|
                                                      (QCDR (QCDR |i|)))))) . #5#)
                                                (LETT |nn|
                                                 (SPADCALL |r|
                                                  (QREFELT $ 118)) . #5#)
                                                (EXIT
                                                 (COND
                                                   ((QEQCAR |nn| 0)
                                                    (LETT |n|
                                                     (MAX (QCDR |nn|)
                                                      |n|) . #5#)))))))))))
                                       (LETT |v|
                                        (SPADCALL |aa| |bb| |cc| |n|
                                         |driv| (QREFELT $ 149)) . #5#)
                                       (EXIT
                                        (COND
                                          ((QEQCAR |v| 0)
                                           (COND
                                             ((QCDR (CDR |v|))
                                              (CONS 1 "failed"))
                                             ('T
                                              (CONS 0 (QCAR (CDR |v|))))))
                                          ('T
                                           (SEQ
                                            (LETT |w|
                                             (PROG2
                                              (LETT #4# |v| . #5#)
                                              (QCDR #4#)
                                               (|check-union|
                                                (QEQCAR #4# 1)
                                                (|Record|
                                                 (|:| |b|
                                                  (|SparseUnivariatePolynomial|
                                                   (QREFELT $ 7)))
                                                 (|:| |c|
                                                  (|SparseUnivariatePolynomial|
                                                   (QREFELT $ 7)))
                                                 (|:| |m| (|Integer|))
                                                 (|:| |alpha|
                                                  (|SparseUnivariatePolynomial|
                                                   (QREFELT $ 7)))
                                                 (|:| |beta|
                                                  (|SparseUnivariatePolynomial|
                                                   (QREFELT $ 7))))
                                                #4#)) . #5#)
                                            (EXIT
                                             (COND
                                               ((SPADCALL (QVELT |w| 0)
                                                 (QREFELT $ 130))
                                                (COND
                                                  ((< (QVELT |w| 2)
                                                    (SPADCALL
                                                     (QVELT |w| 1)
                                                     (QREFELT $ 137)))
                                                   (CONS 1 "failed"))
                                                  ('T
                                                   (SEQ
                                                    (LETT |u|
                                                     (SPADCALL
                                                      (QVELT |w| 1)
                                                      (CONS
                                                       #'|RDEEF;polyDElog!1|
                                                       (VECTOR |extint|
                                                        |t'|))
                                                      |t'|
                                                      (QREFELT $ 136)) . #5#)
                                                    (EXIT
                                                     (COND
                                                       ((OR
                                                         (QEQCAR |u| 1)
                                                         (<
                                                          (QVELT |w| 2)
                                                          (SPADCALL
                                                           (QCDR |u|)
                                                           (QREFELT $
                                                            137))))
                                                        (CONS 1
                                                         "failed"))
                                                       ('T
                                                        (CONS 0
                                                         (SPADCALL
                                                          (SPADCALL
                                                           (QVELT |w|
                                                            3)
                                                           (QCDR |u|)
                                                           (QREFELT $
                                                            150))
                                                          (QVELT |w| 4)
                                                          (QREFELT $
                                                           143))))))))))
                                               ('T
                                                (SEQ
                                                 (LETT |u|
                                                  (|RDEEF;logdegrad|
                                                   |twr|
                                                   (SPADCALL
                                                    (QVELT |w| 0)
                                                    (QREFELT $ 151))
                                                   (QVELT |w| 1)
                                                   (QVELT |w| 2) |x|
                                                   |t| |limint|
                                                   |extint| $) . #5#)
                                                 (EXIT
                                                  (COND
                                                    ((QEQCAR |u| 1)
                                                     (CONS 1 "failed"))
                                                    ('T
                                                     (CONS 0
                                                      (SPADCALL
                                                       (SPADCALL
                                                        (QVELT |w| 3)
                                                        (QCDR |u|)
                                                        (QREFELT $ 150))
                                                       (QVELT |w| 4)
                                                       (QREFELT $ 143))))))))))))))))))))))
           #2# (EXIT #2#))))) 

(DEFUN |RDEEF;polyDElog!1| (|#1| $$)
  (SPADCALL |#1| (QREFELT $$ 1) (QREFELT $$ 0))) 

(DEFUN |RDEEF;polyDElog!0| (|#1| $$)
  (SPADCALL |#1| (QREFELT $$ 1) (QREFELT $$ 0))) 

(DEFUN |RDEEF;gpolDEexp|
       (|twr| |a| |b| |c| |x| |t| |driv| |limint| |extint| $)
  (PROG (|u| |nb| |nc| |lb| |m| #0=#:G2133 |tm| |v|)
    (RETURN
      (SEQ (COND
             ((SPADCALL |c| (QREFELT $ 152))
              (CONS 0 (|spadConstant| $ 153)))
             ((SPADCALL |b| (QREFELT $ 152))
              (SEQ (LETT |u|
                         (SPADCALL |c| (SPADCALL |a| (QREFELT $ 20))
                             (QREFELT $ 23))
                         . #1=(|RDEEF;gpolDEexp|))
                   (EXIT (COND
                           ((QEQCAR |u| 1) (CONS 1 "failed"))
                           ('T
                            (SPADCALL (QCDR |u|)
                                (CONS #'|RDEEF;gpolDEexp!0|
                                      (VECTOR |extint| |limint| |x| $
                                       |t|))
                                (QREFELT $ 156)))))))
             ('T
              (SEQ (LETT |lb|
                         (|RDEEF;boundAt0| |twr|
                             (SPADCALL
                                 (SPADCALL
                                     (SPADCALL |b| 0 (QREFELT $ 157))
                                     (SPADCALL |a| 0 (QREFELT $ 158))
                                     (QREFELT $ 68))
                                 (QREFELT $ 139))
                             (LETT |nb|
                                   (SPADCALL |b| (QREFELT $ 159)) . #1#)
                             (LETT |nc|
                                   (SPADCALL |c| (QREFELT $ 159)) . #1#)
                             |x| |t| |limint| $) . #1#)
                   (LETT |tm|
                         (SPADCALL (|spadConstant| $ 145)
                             (PROG1 (LETT #0#
                                     (LETT |m|
                                      (MAX 0
                                       (MAX (- |nb|) (- |lb| |nc|))) . #1#) . #1#)
                               (|check-subtype| (>= #0# 0)
                                   '(|NonNegativeInteger|) #0#))
                             (QREFELT $ 109)) . #1#)
                   (LETT |v|
                         (|RDEEF;polyDEexp| |twr|
                             (SPADCALL |a| |tm| (QREFELT $ 150))
                             (SPADCALL
                                 (SPADCALL
                                     (SPADCALL
                                      (SPADCALL |lb|
                                       (SPADCALL
                                        (|SPADfirst|
                                         (SPADCALL |t| (QREFELT $ 105)))
                                        |x| (QREFELT $ 66))
                                       (QREFELT $ 67))
                                      |a| (QREFELT $ 142))
                                     |tm| (QREFELT $ 150))
                                 (SPADCALL
                                     (SPADCALL |b|
                                      (SPADCALL |tm| (QREFELT $ 20))
                                      (QREFELT $ 160))
                                     (QREFELT $ 161))
                                 (QREFELT $ 143))
                             (SPADCALL
                                 (SPADCALL |c|
                                     (SPADCALL (|spadConstant| $ 145)
                                      (- |m| |lb|) (QREFELT $ 162))
                                     (QREFELT $ 160))
                                 (QREFELT $ 161))
                             |x| |t| |driv| |limint| |extint| $) . #1#)
                   (EXIT (COND
                           ((QEQCAR |v| 1) (CONS 1 "failed"))
                           ('T
                            (CONS 0
                                  (SPADCALL
                                      (SPADCALL (QCDR |v|)
                                       (QREFELT $ 20))
                                      (SPADCALL (|spadConstant| $ 145)
                                       |lb| (QREFELT $ 162))
                                      (QREFELT $ 160))))))))))))) 

(DEFUN |RDEEF;gpolDEexp!0| (|#1| |#2| $$)
  (PROG ($)
    (LETT $ (QREFELT $$ 3) |RDEEF;gpolDEexp|)
    (RETURN
      (PROGN
        (SPADCALL |#1|
            (SPADCALL (SPADCALL (QREFELT $$ 4) (QREFELT $ 105))
                (QREFELT $ 106))
            |#2| (QREFELT $$ 2) (QREFELT $$ 1) (QREFELT $$ 0)
            (QREFELT $ 62)))))) 

(DEFUN |RDEEF;polyDEexp|
       (|twr| |aa| |bb| |cc| |x| |t| |driv| |limint| |extint| $)
  (PROG (|n| |v| #0=#:G2157 |w| |u|)
    (RETURN
      (SEQ (COND
             ((SPADCALL |cc| (QREFELT $ 130))
              (CONS 0 (|spadConstant| $ 131)))
             ((SPADCALL |bb| (QREFELT $ 130))
              (SEQ (LETT |u| (SPADCALL |cc| |aa| (QREFELT $ 132))
                         . #1=(|RDEEF;polyDEexp|))
                   (EXIT (COND
                           ((QEQCAR |u| 1) (CONS 1 "failed"))
                           ('T
                            (|RDEEF;exppolyint| (QCDR |u|)
                                (CONS #'|RDEEF;polyDEexp!0|
                                      (VECTOR |extint| |limint| |x| $
                                       |t|))
                                $))))))
             ('T
              (SEQ (LETT |n|
                         (|RDEEF;boundInf| |twr|
                             (SPADCALL
                                 (SPADCALL
                                     (SPADCALL |bb| (QREFELT $ 138))
                                     (SPADCALL |aa| (QREFELT $ 138))
                                     (QREFELT $ 68))
                                 (QREFELT $ 139))
                             (SPADCALL |aa| (QREFELT $ 137))
                             (SPADCALL |bb| (QREFELT $ 137))
                             (SPADCALL |cc| (QREFELT $ 137)) |x| |t|
                             |limint| $) . #1#)
                   (LETT |v|
                         (SPADCALL |aa| |bb| |cc| |n| |driv|
                             (QREFELT $ 149)) . #1#)
                   (EXIT (COND
                           ((QEQCAR |v| 0)
                            (COND
                              ((QCDR (CDR |v|)) (CONS 1 "failed"))
                              ('T (CONS 0 (QCAR (CDR |v|))))))
                           ('T
                            (SEQ (LETT |w|
                                       (PROG2 (LETT #0# |v| . #1#)
                                        (QCDR #0#)
                                         (|check-union| (QEQCAR #0# 1)
                                          (|Record|
                                           (|:| |b|
                                            (|SparseUnivariatePolynomial|
                                             (QREFELT $ 7)))
                                           (|:| |c|
                                            (|SparseUnivariatePolynomial|
                                             (QREFELT $ 7)))
                                           (|:| |m| (|Integer|))
                                           (|:| |alpha|
                                            (|SparseUnivariatePolynomial|
                                             (QREFELT $ 7)))
                                           (|:| |beta|
                                            (|SparseUnivariatePolynomial|
                                             (QREFELT $ 7))))
                                          #0#)) . #1#)
                                 (EXIT (COND
                                         ((SPADCALL (QVELT |w| 0)
                                           (QREFELT $ 130))
                                          (COND
                                            ((< (QVELT |w| 2)
                                              (SPADCALL (QVELT |w| 1)
                                               (QREFELT $ 137)))
                                             (CONS 1 "failed"))
                                            ('T
                                             (SEQ
                                              (LETT |u|
                                               (|RDEEF;exppolyint|
                                                (QVELT |w| 1)
                                                (CONS
                                                 #'|RDEEF;polyDEexp!1|
                                                 (VECTOR |extint|
                                                  |limint| |x| $ |t|))
                                                $) . #1#)
                                              (EXIT
                                               (COND
                                                 ((QEQCAR |u| 1)
                                                  (CONS 1 "failed"))
                                                 ('T
                                                  (CONS 0
                                                   (SPADCALL
                                                    (SPADCALL
                                                     (QVELT |w| 3)
                                                     (QCDR |u|)
                                                     (QREFELT $ 150))
                                                    (QVELT |w| 4)
                                                    (QREFELT $ 143))))))))))
                                         ('T
                                          (SEQ
                                           (LETT |u|
                                            (|RDEEF;expdegrad| |twr|
                                             (SPADCALL (QVELT |w| 0)
                                              (QREFELT $ 151))
                                             (QVELT |w| 1)
                                             (QVELT |w| 2) |x| |t|
                                             |limint| |extint| $) . #1#)
                                           (EXIT
                                            (COND
                                              ((QEQCAR |u| 1)
                                               (CONS 1 "failed"))
                                              ('T
                                               (CONS 0
                                                (SPADCALL
                                                 (SPADCALL
                                                  (QVELT |w| 3)
                                                  (QCDR |u|)
                                                  (QREFELT $ 150))
                                                 (QVELT |w| 4)
                                                 (QREFELT $ 143))))))))))))))))))))) 

(DEFUN |RDEEF;polyDEexp!1| (|#1| |#2| $$)
  (PROG ($)
    (LETT $ (QREFELT $$ 3) |RDEEF;polyDEexp|)
    (RETURN
      (PROGN
        (SPADCALL |#1|
            (SPADCALL (SPADCALL (QREFELT $$ 4) (QREFELT $ 105))
                (QREFELT $ 106))
            |#2| (QREFELT $$ 2) (QREFELT $$ 1) (QREFELT $$ 0)
            (QREFELT $ 62)))))) 

(DEFUN |RDEEF;polyDEexp!0| (|#1| |#2| $$)
  (PROG ($)
    (LETT $ (QREFELT $$ 3) |RDEEF;polyDEexp|)
    (RETURN
      (PROGN
        (SPADCALL |#1|
            (SPADCALL (SPADCALL (QREFELT $$ 4) (QREFELT $ 105))
                (QREFELT $ 106))
            |#2| (QREFELT $$ 2) (QREFELT $$ 1) (QREFELT $$ 0)
            (QREFELT $ 62)))))) 

(DEFUN |RDEEF;exppolyint| (|p| |rischdiffeq| $)
  (PROG (|u|)
    (RETURN
      (SEQ (LETT |u|
                 (SPADCALL (SPADCALL |p| (QREFELT $ 20)) |rischdiffeq|
                     (QREFELT $ 156))
                 |RDEEF;exppolyint|)
           (EXIT (COND
                   ((QEQCAR |u| 1) (CONS 1 "failed"))
                   ('T (SPADCALL (QCDR |u|) (QREFELT $ 163))))))))) 

(DEFUN |RDEEF;boundInf|
       (|twr| |f0| |da| |db| |dc| |x| |t| |limitedint| $)
  (PROG (|l0| |l1| #0=#:G2192 |u| #1=#:G2193 |if0| |alpha| |al|)
    (RETURN
      (SEQ (COND
             ((< |da| |db|) (- |dc| |db|))
             ((< |db| |da|) (MAX 0 (- |dc| |da|)))
             (#2='T
              (SEQ (LETT |l1|
                         (|RDEEF;logdiff| |twr|
                             (LETT |l0| (SPADCALL |f0| (QREFELT $ 100))
                                   . #3=(|RDEEF;boundInf|))
                             $) . #3#)
                   (LETT |if0|
                         (SPADCALL |f0|
                             (PROGN
                               (LETT #0# NIL . #3#)
                               (SEQ (LETT |u| NIL . #3#)
                                    (LETT #1# |l1| . #3#) G190
                                    (COND
                                      ((OR (ATOM #1#)
                                        (PROGN
                                          (LETT |u| (CAR #1#) . #3#)
                                          NIL))
                                       (GO G191)))
                                    (SEQ
                                     (EXIT
                                      (LETT #0#
                                       (CONS
                                        (|SPADfirst|
                                         (SPADCALL |u| (QREFELT $ 105)))
                                        #0#) . #3#)))
                                    (LETT #1# (CDR #1#) . #3#)
                                    (GO G190) G191
                                    (EXIT (NREVERSE0 #0#))))
                             |limitedint|) . #3#)
                   (EXIT (COND
                           ((QEQCAR |if0| 1)
                            (|error| "Risch's theorem violated"))
                           (#2#
                            (SEQ (LETT |alpha|
                                       (SPADCALL (CONS |t| |l0|)
                                        (|RDEEF;RRF2F| (QCDR |if0|) $)
                                        |x| (QREFELT $ 141)) . #3#)
                                 (EXIT (COND
                                         ((QEQCAR |alpha| 0)
                                          (SEQ
                                           (LETT |al|
                                            (SPADCALL
                                             (SPADCALL (QCDR |alpha|)
                                              |t| (QREFELT $ 91))
                                             (QREFELT $ 165)) . #3#)
                                           (COND
                                             ((SPADCALL (QCDR |al|)
                                               (QREFELT $ 166))
                                              (COND
                                                ((SPADCALL (QCAR |al|)
                                                  (QREFELT $ 167))
                                                 (EXIT
                                                  (MAX 0
                                                   (MAX
                                                    (SPADCALL
                                                     (QCAR |al|)
                                                     (QREFELT $ 168))
                                                    (- |dc| |db|))))))))
                                           (EXIT (- |dc| |db|))))
                                         (#2# (- |dc| |db|))))))))))))))) 

(DEFUN |RDEEF;boundAt0| (|twr| |f0| |nb| |nc| |x| |t| |limitedint| $)
  (PROG (|l0| |l1| #0=#:G2209 |u| #1=#:G2210 |if0| |alpha| |al|)
    (RETURN
      (SEQ (COND
             ((EQL |nb| 0)
              (SEQ (LETT |l1|
                         (|RDEEF;logdiff| |twr|
                             (LETT |l0| (SPADCALL |f0| (QREFELT $ 100))
                                   . #2=(|RDEEF;boundAt0|))
                             $) . #2#)
                   (LETT |if0|
                         (SPADCALL |f0|
                             (PROGN
                               (LETT #0# NIL . #2#)
                               (SEQ (LETT |u| NIL . #2#)
                                    (LETT #1# |l1| . #2#) G190
                                    (COND
                                      ((OR (ATOM #1#)
                                        (PROGN
                                          (LETT |u| (CAR #1#) . #2#)
                                          NIL))
                                       (GO G191)))
                                    (SEQ
                                     (EXIT
                                      (LETT #0#
                                       (CONS
                                        (|SPADfirst|
                                         (SPADCALL |u| (QREFELT $ 105)))
                                        #0#) . #2#)))
                                    (LETT #1# (CDR #1#) . #2#)
                                    (GO G190) G191
                                    (EXIT (NREVERSE0 #0#))))
                             |limitedint|) . #2#)
                   (EXIT (COND
                           ((QEQCAR |if0| 1)
                            (|error| "Risch's theorem violated"))
                           (#3='T
                            (SEQ (LETT |alpha|
                                       (SPADCALL (CONS |t| |l0|)
                                        (|RDEEF;RRF2F| (QCDR |if0|) $)
                                        |x| (QREFELT $ 141)) . #2#)
                                 (EXIT (COND
                                         ((QEQCAR |alpha| 0)
                                          (SEQ
                                           (LETT |al|
                                            (SPADCALL
                                             (SPADCALL (QCDR |alpha|)
                                              |t| (QREFELT $ 91))
                                             (QREFELT $ 165)) . #2#)
                                           (COND
                                             ((SPADCALL (QCDR |al|)
                                               (QREFELT $ 166))
                                              (COND
                                                ((SPADCALL (QCAR |al|)
                                                  (QREFELT $ 167))
                                                 (EXIT
                                                  (MIN 0
                                                   (MIN
                                                    (SPADCALL
                                                     (QCAR |al|)
                                                     (QREFELT $ 168))
                                                    |nc|)))))))
                                           (EXIT (MIN 0 |nc|))))
                                         (#3# (MIN 0 |nc|))))))))))
             (#3# (MIN 0 (- |nc| (MIN 0 |nb|))))))))) 

(DEFUN |RDEEF;logdegrad|
       (|twr| |b| |c| |n| |x| |t| |limitedint| |extint| $)
  (PROG (|t'| |f0| |lk0| |lk1| #0=#:G2235 |u| #1=#:G2236 |if0| |alpha|
              |u1| |v| #2=#:G2237 #3=#:G2231 #4=#:G2229 #5=#:G2230)
    (RETURN
      (SEQ (LETT |t'|
                 (SPADCALL (SPADCALL |t| (QREFELT $ 43)) |x|
                     (QREFELT $ 66))
                 . #6=(|RDEEF;logdegrad|))
           (LETT |lk1|
                 (|RDEEF;logdiff| |twr|
                     (LETT |lk0|
                           (SPADCALL
                               (LETT |f0|
                                     (SPADCALL |b| (QREFELT $ 139)) . #6#)
                               (QREFELT $ 100)) . #6#)
                     $) . #6#)
           (LETT |if0|
                 (SPADCALL |f0|
                     (PROGN
                       (LETT #0# NIL . #6#)
                       (SEQ (LETT |u| NIL . #6#) (LETT #1# |lk1| . #6#)
                            G190
                            (COND
                              ((OR (ATOM #1#)
                                   (PROGN
                                     (LETT |u| (CAR #1#) . #6#)
                                     NIL))
                               #7=(GO G191)))
                            (SEQ (EXIT (LETT #0#
                                        (CONS
                                         (|SPADfirst|
                                          (SPADCALL |u|
                                           (QREFELT $ 105)))
                                         #0#) . #6#)))
                            (LETT #1# (CDR #1#) . #6#) #8=(GO G190)
                            G191 (EXIT (NREVERSE0 #0#))))
                     |limitedint|) . #6#)
           (EXIT (COND
                   ((QEQCAR |if0| 1)
                    (|error| "Risch's theorem violated"))
                   (#9='T
                    (SEQ (LETT |alpha|
                               (SPADCALL |lk0|
                                   (|RDEEF;RRF2F| (QCDR |if0|) $) |x|
                                   (QREFELT $ 141)) . #6#)
                         (EXIT (COND
                                 ((QEQCAR |alpha| 0)
                                  (SEQ (LETT |u1|
                                        (SPADCALL
                                         (SPADCALL
                                          (SPADCALL (QCDR |alpha|)
                                           (QREFELT $ 169))
                                          |c| (QREFELT $ 142))
                                         (CONS #'|RDEEF;logdegrad!0|
                                          (VECTOR |extint| |t'|))
                                         |t'| (QREFELT $ 136)) . #6#)
                                       (EXIT
                                        (COND
                                          ((OR (QEQCAR |u1| 1)
                                            (< |n|
                                             (SPADCALL (QCDR |u1|)
                                              (QREFELT $ 137))))
                                           (CONS 1 "failed"))
                                          ('T
                                           (CONS 0
                                            (SPADCALL (QCDR |alpha|)
                                             (QCDR |u1|)
                                             (QREFELT $ 142))))))))
                                 (#9#
                                  (|RDEEF;logdeg| |c|
                                      (SPADCALL
                                       (SPADCALL (QCAR (QCDR |if0|))
                                        (QREFELT $ 139))
                                       (PROGN
                                         (LETT #5# NIL . #6#)
                                         (SEQ (LETT |v| NIL . #6#)
                                          (LETT #2#
                                           (QCDR (QCDR |if0|)) . #6#)
                                          G190
                                          (COND
                                            ((OR (ATOM #2#)
                                              (PROGN
                                                (LETT |v|
                                                 (CAR #2#) . #6#)
                                                NIL))
                                             #7#))
                                          (SEQ
                                           (EXIT
                                            (PROGN
                                              (LETT #3#
                                               (SPADCALL (QCAR |v|)
                                                (SPADCALL (QCDR |v|)
                                                 (QREFELT $ 99))
                                                (QREFELT $ 92)) . #6#)
                                              (COND
                                                (#5#
                                                 (LETT #4#
                                                  (SPADCALL #4# #3#
                                                   (QREFELT $ 98)) . #6#))
                                                ('T
                                                 (PROGN
                                                   (LETT #4# #3# . #6#)
                                                   (LETT #5# 'T . #6#)))))))
                                          (LETT #2# (CDR #2#) . #6#)
                                          #8# G191 (EXIT NIL))
                                         (COND
                                           (#5# #4#)
                                           (#9# (|spadConstant| $ 38))))
                                       (QREFELT $ 89))
                                      |n| |x| |t'| |limitedint|
                                      |extint| $)))))))))))) 

(DEFUN |RDEEF;logdegrad!0| (|#1| $$)
  (SPADCALL |#1| (QREFELT $$ 1) (QREFELT $$ 0))) 

(DEFUN |RDEEF;logdeg| (|c| |f| |n| |x| |t'| |limitedint| |extint| $)
  (PROG (|m| #0=#:G2254 |u| #1=#:G2258 #2=#:G2251 |answr|)
    (RETURN
      (SEQ (EXIT (SEQ (LETT |answr| (|spadConstant| $ 131)
                            . #3=(|RDEEF;logdeg|))
                      (EXIT (SEQ G190 NIL
                                 (SEQ (EXIT
                                       (COND
                                         ((SPADCALL |c|
                                           (QREFELT $ 130))
                                          (PROGN
                                            (LETT #1#
                                             (CONS 0 |answr|) . #3#)
                                            (GO #1#)))
                                         ('T
                                          (SEQ
                                           (EXIT
                                            (SEQ
                                             (COND
                                               ((< |n| 0)
                                                (EXIT
                                                 (PROGN
                                                   (LETT #1#
                                                    (CONS 1 "failed") . #3#)
                                                   (GO #1#))))
                                               ('T
                                                (SEQ
                                                 (LETT |m|
                                                  (SPADCALL |c|
                                                   (QREFELT $ 137)) . #3#)
                                                 (EXIT
                                                  (COND
                                                    ((< |n| |m|)
                                                     (PROGN
                                                       (LETT #0#
                                                        (PROGN
                                                          (LETT #1#
                                                           (CONS 1
                                                            "failed") . #3#)
                                                          (GO #1#)) . #3#)
                                                       (GO #0#))))))))
                                             (LETT |u|
                                              (SPADCALL 1 |f|
                                               (SPADCALL |c|
                                                (QREFELT $ 138))
                                               |x| |limitedint|
                                               |extint| (QREFELT $ 62)) . #3#)
                                             (EXIT
                                              (COND
                                                ((SPADCALL
                                                  (QVELT |u| 2)
                                                  (QREFELT $ 170))
                                                 (PROGN
                                                   (LETT #1#
                                                    (CONS 1 "failed") . #3#)
                                                   (GO #1#)))
                                                ((ZEROP |m|)
                                                 (PROGN
                                                   (LETT #1#
                                                    (CONS 0
                                                     (SPADCALL |answr|
                                                      (SPADCALL
                                                       (QVELT |u| 0)
                                                       (QREFELT $ 101))
                                                      (QREFELT $ 143))) . #3#)
                                                   (GO #1#)))
                                                ('T
                                                 (SEQ
                                                  (LETT |n|
                                                   (- |m| 1) . #3#)
                                                  (LETT |c|
                                                   (SPADCALL
                                                    (SPADCALL |c|
                                                     (QREFELT $ 171))
                                                    (SPADCALL
                                                     (SPADCALL
                                                      (SPADCALL |m|
                                                       |t'|
                                                       (QREFELT $ 67))
                                                      (QVELT |u| 0)
                                                      (QREFELT $ 92))
                                                     (PROG1
                                                      (LETT #2#
                                                       (- |m| 1) . #3#)
                                                       (|check-subtype|
                                                        (>= #2# 0)
                                                        '(|NonNegativeInteger|)
                                                        #2#))
                                                     (QREFELT $ 109))
                                                    (QREFELT $ 172)) . #3#)
                                                  (EXIT
                                                   (LETT |answr|
                                                    (SPADCALL |answr|
                                                     (SPADCALL
                                                      (QVELT |u| 0) |m|
                                                      (QREFELT $ 109))
                                                     (QREFELT $ 143)) . #3#))))))))
                                           #0# (EXIT #0#))))))
                                 NIL (GO G190) G191 (EXIT NIL)))))
           #1# (EXIT #1#))))) 

(DEFUN |RDEEF;expdegrad|
       (|twr| |b| |c| |n| |x| |t| |limint| |extint| $)
  (PROG (|f0| |lk0| |lk1| #0=#:G2292 |u| #1=#:G2293 |if0| |v|
              #2=#:G2294 #3=#:G2270 #4=#:G2268 #5=#:G2269 |intf0|
              |alpha| |al| #6=#:G2276 |u1|)
    (RETURN
      (SEQ (LETT |lk1|
                 (|RDEEF;logdiff| |twr|
                     (LETT |lk0|
                           (SPADCALL
                               (LETT |f0|
                                     (SPADCALL |b| (QREFELT $ 139))
                                     . #7=(|RDEEF;expdegrad|))
                               (QREFELT $ 100)) . #7#)
                     $) . #7#)
           (LETT |if0|
                 (SPADCALL |f0|
                     (PROGN
                       (LETT #0# NIL . #7#)
                       (SEQ (LETT |u| NIL . #7#) (LETT #1# |lk1| . #7#)
                            G190
                            (COND
                              ((OR (ATOM #1#)
                                   (PROGN
                                     (LETT |u| (CAR #1#) . #7#)
                                     NIL))
                               #8=(GO G191)))
                            (SEQ (EXIT (LETT #0#
                                        (CONS
                                         (|SPADfirst|
                                          (SPADCALL |u|
                                           (QREFELT $ 105)))
                                         #0#) . #7#)))
                            (LETT #1# (CDR #1#) . #7#) #9=(GO G190)
                            G191 (EXIT (NREVERSE0 #0#))))
                     |limint|) . #7#)
           (EXIT (COND
                   ((QEQCAR |if0| 1)
                    (|error| "Risch's theorem violated"))
                   (#10='T
                    (SEQ (LETT |intf0|
                               (SPADCALL
                                   (SPADCALL (QCAR (QCDR |if0|))
                                    (QREFELT $ 139))
                                   (PROGN
                                     (LETT #5# NIL . #7#)
                                     (SEQ (LETT |v| NIL . #7#)
                                      (LETT #2#
                                       (QCDR (QCDR |if0|)) . #7#)
                                      G190
                                      (COND
                                        ((OR (ATOM #2#)
                                          (PROGN
                                            (LETT |v| (CAR #2#) . #7#)
                                            NIL))
                                         #8#))
                                      (SEQ
                                       (EXIT
                                        (PROGN
                                          (LETT #3#
                                           (SPADCALL (QCAR |v|)
                                            (SPADCALL (QCDR |v|)
                                             (QREFELT $ 99))
                                            (QREFELT $ 92)) . #7#)
                                          (COND
                                            (#5#
                                             (LETT #4#
                                              (SPADCALL #4# #3#
                                               (QREFELT $ 98)) . #7#))
                                            ('T
                                             (PROGN
                                               (LETT #4# #3# . #7#)
                                               (LETT #5# 'T . #7#)))))))
                                      (LETT #2# (CDR #2#) . #7#) #9#
                                      G191 (EXIT NIL))
                                     (COND
                                       (#5# #4#)
                                       (#10# (|spadConstant| $ 38))))
                                   (QREFELT $ 89)) . #7#)
                         (LETT |alpha|
                               (SPADCALL (CONS |t| |lk0|)
                                   (|RDEEF;RRF2F| (QCDR |if0|) $) |x|
                                   (QREFELT $ 141)) . #7#)
                         (EXIT (COND
                                 ((QEQCAR |alpha| 0)
                                  (SEQ (LETT |al|
                                        (SPADCALL
                                         (SPADCALL (QCDR |alpha|) |t|
                                          (QREFELT $ 91))
                                         (QREFELT $ 165)) . #7#)
                                       (COND
                                         ((SPADCALL (QCDR |al|)
                                           (QREFELT $ 166))
                                          (COND
                                            ((SPADCALL (QCAR |al|)
                                              (QREFELT $ 167))
                                             (COND
                                               ((NULL
                                                 (<
                                                  (SPADCALL (QCAR |al|)
                                                   (QREFELT $ 168))
                                                  0))
                                                (EXIT
                                                 (SEQ
                                                  (LETT |u1|
                                                   (SPADCALL
                                                    (SPADCALL
                                                     (SPADCALL |c|
                                                      (QREFELT $ 20))
                                                     (PROG2
                                                      (LETT #6#
                                                       (SPADCALL
                                                        (QCAR |al|)
                                                        (QREFELT $ 173)) . #7#)
                                                      (QCDR #6#)
                                                       (|check-union|
                                                        (QEQCAR #6# 0)
                                                        (|LaurentPolynomial|
                                                         (QREFELT $ 7)
                                                         (|SparseUnivariatePolynomial|
                                                          (QREFELT $ 7)))
                                                        #6#))
                                                     (QREFELT $ 160))
                                                    (CONS
                                                     #'|RDEEF;expdegrad!0|
                                                     (VECTOR |extint|
                                                      |limint| |x| $
                                                      |t|))
                                                    (QREFELT $ 156)) . #7#)
                                                  (EXIT
                                                   (COND
                                                     ((OR
                                                       (QEQCAR |u1| 1)
                                                       (< |n|
                                                        (SPADCALL
                                                         (QCDR |u1|)
                                                         (QREFELT $
                                                          168))))
                                                      (CONS 1 "failed"))
                                                     ('T
                                                      (SPADCALL
                                                       (SPADCALL
                                                        (QCAR |al|)
                                                        (QCDR |u1|)
                                                        (QREFELT $ 160))
                                                       (QREFELT $ 163)))))))))))))
                                       (EXIT
                                        (|RDEEF;expdeg| |c| |intf0| |n|
                                         |x|
                                         (|SPADfirst|
                                          (SPADCALL |t|
                                           (QREFELT $ 105)))
                                         |limint| |extint| $))))
                                 (#10#
                                  (|RDEEF;expdeg| |c| |intf0| |n| |x|
                                      (|SPADfirst|
                                       (SPADCALL |t| (QREFELT $ 105)))
                                      |limint| |extint| $)))))))))))) 

(DEFUN |RDEEF;expdegrad!0| (|#1| |#2| $$)
  (PROG ($)
    (LETT $ (QREFELT $$ 3) |RDEEF;expdegrad|)
    (RETURN
      (PROGN
        (SPADCALL |#1|
            (SPADCALL (SPADCALL (QREFELT $$ 4) (QREFELT $ 105))
                (QREFELT $ 106))
            |#2| (QREFELT $$ 2) (QREFELT $$ 1) (QREFELT $$ 0)
            (QREFELT $ 62)))))) 

(DEFUN |RDEEF;expdeg| (|c| |f| |n| |x| |eta| |limitedint| |extint| $)
  (PROG (|m| #0=#:G2310 |u| #1=#:G2314 |answr|)
    (RETURN
      (SEQ (EXIT (SEQ (LETT |answr| (|spadConstant| $ 131)
                            . #2=(|RDEEF;expdeg|))
                      (EXIT (SEQ G190 NIL
                                 (SEQ (EXIT
                                       (COND
                                         ((SPADCALL |c|
                                           (QREFELT $ 130))
                                          (PROGN
                                            (LETT #1#
                                             (CONS 0 |answr|) . #2#)
                                            (GO #1#)))
                                         ('T
                                          (SEQ
                                           (EXIT
                                            (SEQ
                                             (COND
                                               ((< |n| 0)
                                                (EXIT
                                                 (PROGN
                                                   (LETT #1#
                                                    (CONS 1 "failed") . #2#)
                                                   (GO #1#))))
                                               ('T
                                                (SEQ
                                                 (LETT |m|
                                                  (SPADCALL |c|
                                                   (QREFELT $ 137)) . #2#)
                                                 (EXIT
                                                  (COND
                                                    ((< |n| |m|)
                                                     (PROGN
                                                       (LETT #0#
                                                        (PROGN
                                                          (LETT #1#
                                                           (CONS 1
                                                            "failed") . #2#)
                                                          (GO #1#)) . #2#)
                                                       (GO #0#))))))))
                                             (LETT |u|
                                              (SPADCALL 1
                                               (SPADCALL |f|
                                                (SPADCALL |m| |eta|
                                                 (QREFELT $ 174))
                                                (QREFELT $ 98))
                                               (SPADCALL |c|
                                                (QREFELT $ 138))
                                               |x| |limitedint|
                                               |extint| (QREFELT $ 62)) . #2#)
                                             (EXIT
                                              (COND
                                                ((SPADCALL
                                                  (QVELT |u| 2)
                                                  (QREFELT $ 170))
                                                 (PROGN
                                                   (LETT #1#
                                                    (CONS 1 "failed") . #2#)
                                                   (GO #1#)))
                                                ((ZEROP |m|)
                                                 (PROGN
                                                   (LETT #1#
                                                    (CONS 0
                                                     (SPADCALL |answr|
                                                      (SPADCALL
                                                       (QVELT |u| 0)
                                                       (QREFELT $ 101))
                                                      (QREFELT $ 143))) . #2#)
                                                   (GO #1#)))
                                                ('T
                                                 (SEQ
                                                  (LETT |n|
                                                   (- |m| 1) . #2#)
                                                  (LETT |c|
                                                   (SPADCALL |c|
                                                    (QREFELT $ 171)) . #2#)
                                                  (EXIT
                                                   (LETT |answr|
                                                    (SPADCALL |answr|
                                                     (SPADCALL
                                                      (QVELT |u| 0) |m|
                                                      (QREFELT $ 109))
                                                     (QREFELT $ 143)) . #2#))))))))
                                           #0# (EXIT #0#))))))
                                 NIL (GO G190) G191 (EXIT NIL)))))
           #1# (EXIT #1#))))) 

(DEFUN |RDEEF;RRF2F| (|rrf| $)
  (PROG (|v| #0=#:G2321 #1=#:G2319 #2=#:G2317 #3=#:G2318)
    (RETURN
      (SEQ (SPADCALL (QCAR |rrf|)
               (PROGN
                 (LETT #3# NIL . #4=(|RDEEF;RRF2F|))
                 (SEQ (LETT |v| NIL . #4#)
                      (LETT #0# (QCDR |rrf|) . #4#) G190
                      (COND
                        ((OR (ATOM #0#)
                             (PROGN (LETT |v| (CAR #0#) . #4#) NIL))
                         (GO G191)))
                      (SEQ (EXIT (PROGN
                                   (LETT #1#
                                    (SPADCALL (QCAR |v|)
                                     (SPADCALL (QCDR |v|)
                                      (QREFELT $ 99))
                                     (QREFELT $ 92)) . #4#)
                                   (COND
                                     (#3#
                                      (LETT #2#
                                       (SPADCALL #2# #1#
                                        (QREFELT $ 98)) . #4#))
                                     ('T
                                      (PROGN
                                        (LETT #2# #1# . #4#)
                                        (LETT #3# 'T . #4#)))))))
                      (LETT #0# (CDR #0#) . #4#) (GO G190) G191
                      (EXIT NIL))
                 (COND (#3# #2#) ('T (|spadConstant| $ 38))))
               (QREFELT $ 98)))))) 

(DEFUN |ElementaryRischDE| (&REST #0=#:G2322)
  (PROG ()
    (RETURN
      (PROG (#1=#:G2323)
        (RETURN
          (COND
            ((LETT #1#
                   (|lassocShiftWithFunction| (|devaluateList| #0#)
                       (HGET |$ConstructorCache| '|ElementaryRischDE|)
                       '|domainEqualList|)
                   . #2=(|ElementaryRischDE|))
             (|CDRwithIncrement| #1#))
            ('T
             (UNWIND-PROTECT
               (PROG1 (APPLY (|function| |ElementaryRischDE;|) #0#)
                 (LETT #1# T . #2#))
               (COND
                 ((NOT #1#)
                  (HREM |$ConstructorCache| '|ElementaryRischDE|))))))))))) 

(DEFUN |ElementaryRischDE;| (|#1| |#2|)
  (PROG (DV$1 DV$2 |dv$| $ |pv$|)
    (RETURN
      (PROGN
        (LETT DV$1 (|devaluate| |#1|) . #0=(|ElementaryRischDE|))
        (LETT DV$2 (|devaluate| |#2|) . #0#)
        (LETT |dv$| (LIST '|ElementaryRischDE| DV$1 DV$2) . #0#)
        (LETT $ (GETREFV 175) . #0#)
        (QSETREFV $ 0 |dv$|)
        (QSETREFV $ 3 (LETT |pv$| (|buildPredVector| 0 0 NIL) . #0#))
        (|haddProp| |$ConstructorCache| '|ElementaryRischDE|
            (LIST DV$1 DV$2) (CONS 1 $))
        (|stuffDomainSlots| $)
        (QSETREFV $ 6 |#1|)
        (QSETREFV $ 7 |#2|)
        (QSETREFV $ 11 (SPADCALL "%alg" (QREFELT $ 10)))
        (QSETREFV $ 15 (SPADCALL (QREFELT $ 14)))
        $)))) 

(MAKEPROP '|ElementaryRischDE| '|infovec|
    (LIST '#(NIL NIL NIL NIL NIL NIL (|local| |#1|) (|local| |#2|)
             (|String|) (|Symbol|) (0 . |coerce|) 'ALGOP
             (|Record| (|:| |coeff| 54) (|:| |argument| 79))
             (|AssociationList| 7 77) (5 . |table|) '|tab|
             (|SparseUnivariatePolynomial| 7) (|Fraction| 16)
             (9 . |numer|) (|LaurentPolynomial| 7 16) (14 . |coerce|)
             (19 . |denom|) (|Union| $ '"failed") (24 . |exquo|)
             (|Boolean|) (|Kernel| 7) (30 . |is?|) (|List| 25)
             (36 . |member?|) (|IntegrationTools| 6 7) (42 . |ksec|)
             (|Union| 9 '"failed") (49 . |symbolIfCan|)
             (|Union| 7 '"failed") (|Mapping| 33 7 7 9)
             (|PureAlgebraicIntegration| 6 7 7) (54 . |palgRDE|)
             (64 . |Zero|) (68 . |Zero|) (|BasicOperator|)
             (72 . |operator|) (77 . |has?|) (|Kernel| $)
             (83 . |coerce|)
             (|Record| (|:| |primelt| 7) (|:| |pol1| 16)
                 (|:| |pol2| 16) (|:| |prim| 16))
             (|FunctionSpacePrimitiveElement| 6 7)
             (88 . |primitiveElement|) (|SparseUnivariatePolynomial| $)
             (94 . |rootOf|) (99 . |elt|) (|List| 42) (|List| $)
             (105 . |eval|)
             (|Record| (|:| |ans| 7) (|:| |right| 7) (|:| |sol?| 24))
             (|Integer|) (|Record| (|:| |coeff| 7) (|:| |logand| 7))
             (|Record| (|:| |mainpart| 7)
                 (|:| |limitedlogs| (|List| 55)))
             (|Union| 56 '"failed") (|Mapping| 57 7 104)
             (|Record| (|:| |ratpart| 7) (|:| |coeff| 7))
             (|Union| 59 '"failed") (|Mapping| 60 7 7)
             |RDEEF;rischDE;I2FSMMR;4| (112 . |retract|) (117 . |eval|)
             (124 . |zero?|) (129 . |differentiate|) (135 . *)
             (141 . /) (147 . |freeOf?|) (153 . |kernels|)
             (158 . |union|) (164 . |varselect|) (170 . |kmax|)
             (175 . |kernel|) (|Union| 77 '"failed") (180 . |search|)
             (|List| 12) (186 . |setelt|)
             (|SparseMultivariatePolynomial| 6 25) (193 . |One|)
             (197 . |Zero|) (|Fraction| 54) (201 . |Zero|)
             (|NonNegativeInteger|) (205 . **) (211 . *)
             (|SparseMultivariatePolynomial| 6 42) (217 . |coerce|)
             (222 . -) (|Fraction| 47) (228 . |univariate|) (234 . *)
             (|Record| (|:| |ans| 17) (|:| |nosol| 24))
             (|TranscendentalRischDE| 7 16) (240 . |baseRDE|)
             (|PolynomialCategoryQuotientFunctions|
                 (|IndexedExponents| 25) 25 6 79 7)
             (246 . |multivariate|) (252 . +) (258 . |log|)
             (263 . |tower|) (268 . |coerce|) (|Mapping| 7 7)
             (273 . |differentiate|) (|List| 7) (280 . |argument|)
             (285 . |first|) (|PositiveInteger|) (290 . |One|)
             (294 . |monomial|) (300 . |numer|) (305 . |denom|)
             (310 . |univariate|) (|SparseUnivariatePolynomial| 79)
             (316 . |degree|) (321 . |leadingCoefficient|) (326 . /)
             (|Union| 54 '"failed") (332 . |retractIfCan|)
             (337 . |Zero|) (341 . |degree|)
             (|Record| (|:| |a| 16) (|:| |b| 17) (|:| |c| 17)
                 (|:| |t| 16))
             (|Union| 121 '"failed") (|Mapping| 16 16)
             (347 . |monomRDE|) (354 . |retract|) (359 . /)
             (365 . |convert|) (370 . |coerce|) (375 . /)
             (381 . |zero?|) (386 . |Zero|) (390 . |exquo|)
             (|Union| 16 '"failed") (|Mapping| 60 7)
             (|TranscendentalIntegration| 7 16)
             (396 . |primintfldpoly|) (403 . |degree|)
             (408 . |leadingCoefficient|) (413 . -)
             (|ElementaryFunctionStructurePackage| 6 7)
             (418 . |validExponential|) (425 . *) (431 . +)
             (437 . |One|) (441 . |One|)
             (|Record| (|:| |ans| 16) (|:| |nosol| 24))
             (|Record| (|:| |b| 16) (|:| |c| 16) (|:| |m| 54)
                 (|:| |alpha| 16) (|:| |beta| 16))
             (|Union| (|:| |ans| 146) (|:| |eq| 147)) (445 . |polyRDE|)
             (454 . *) (460 . |retract|) (465 . |zero?|) (470 . |Zero|)
             (|Union| 19 '"failed") (|Mapping| 53 54 7)
             (474 . |expintfldpoly|) (480 . |coefficient|)
             (486 . |coefficient|) (492 . |order|) (497 . *)
             (503 . |retract|) (508 . |monomial|)
             (514 . |retractIfCan|)
             (|Record| (|:| |polyPart| $) (|:| |fracPart| 17))
             (519 . |separate|) (524 . |zero?|) (529 . |monomial?|)
             (534 . |degree|) (539 . |inv|) (544 . ~)
             (549 . |reductum|) (554 . -) (560 . |recip|) (565 . *))
          '#(|rischDE| 571) 'NIL
          (CONS (|makeByteWordVec2| 1 'NIL)
                (CONS '#()
                      (CONS '#()
                            (|makeByteWordVec2| 174
                                '(1 9 0 8 10 0 13 0 14 1 17 16 0 18 1
                                  19 0 16 20 1 17 16 0 21 2 19 22 0 0
                                  23 2 25 24 0 9 26 2 27 24 25 0 28 3
                                  29 25 25 27 9 30 1 25 31 0 32 6 35 33
                                  7 7 7 25 25 34 36 0 6 0 37 0 7 0 38 1
                                  25 39 0 40 2 39 24 0 9 41 1 7 0 42 43
                                  2 45 44 7 7 46 1 7 0 47 48 2 16 7 0 7
                                  49 3 7 0 0 50 51 52 1 7 42 0 63 3 7 0
                                  0 42 0 64 1 7 24 0 65 2 7 0 0 9 66 2
                                  7 0 54 0 67 2 7 0 0 0 68 2 7 24 0 9
                                  69 1 7 50 0 70 2 29 27 27 27 71 2 29
                                  27 27 9 72 1 29 25 27 73 1 25 0 9 74
                                  2 13 75 7 0 76 3 13 77 0 7 77 78 0 79
                                  0 80 0 79 0 81 0 82 0 83 2 79 0 0 84
                                  85 2 79 0 0 0 86 1 7 0 87 88 2 7 0 0
                                  0 89 2 7 90 0 42 91 2 7 0 0 0 92 2 94
                                  93 17 17 95 2 96 7 17 25 97 2 7 0 0 0
                                  98 1 7 0 0 99 1 7 50 0 100 1 16 0 7
                                  101 3 16 0 0 102 0 103 1 25 104 0 105
                                  1 104 7 0 106 0 107 0 108 2 16 0 7 84
                                  109 1 7 87 0 110 1 7 87 0 111 2 79 47
                                  0 25 112 1 113 84 0 114 1 113 79 0
                                  115 2 7 0 87 87 116 1 7 117 0 118 0
                                  113 0 119 2 79 84 0 25 120 3 94 122
                                  17 17 123 124 1 17 16 0 125 2 17 0 16
                                  16 126 1 19 17 0 127 1 17 0 16 128 2
                                  17 0 0 0 129 1 16 24 0 130 0 16 0 131
                                  2 16 22 0 0 132 3 135 133 16 134 7
                                  136 1 16 84 0 137 1 16 7 0 138 1 7 0
                                  0 139 3 140 33 27 7 9 141 2 16 0 7 0
                                  142 2 16 0 0 0 143 0 6 0 144 0 7 0
                                  145 5 94 148 16 16 16 54 123 149 2 16
                                  0 0 0 150 1 16 7 0 151 1 19 24 0 152
                                  0 19 0 153 2 135 154 19 155 156 2 19
                                  7 0 54 157 2 16 7 0 84 158 1 19 54 0
                                  159 2 19 0 0 0 160 1 19 16 0 161 2 19
                                  0 7 54 162 1 19 133 0 163 1 19 164 17
                                  165 1 17 24 0 166 1 19 24 0 167 1 19
                                  54 0 168 1 7 0 0 169 1 24 0 0 170 1
                                  16 0 0 171 2 16 0 0 0 172 1 19 22 0
                                  173 2 7 0 84 0 174 6 0 53 54 7 7 9 58
                                  61 62)))))
          '|lookupComplete|)) 
