
(/VERSIONCHECK 2) 

(DEFUN |IR;-;2$;1| (|u| $) (SPADCALL -1 |u| (QREFELT $ 14))) 

(DEFUN |IR;Zero;$;2| ($)
  (SPADCALL (|spadConstant| $ 17) NIL NIL (QREFELT $ 22))) 

(DEFUN |IR;coerce;F$;3| (|x| $) (SPADCALL |x| NIL NIL (QREFELT $ 22))) 

(PUT '|IR;ratpart;$F;4| '|SPADreplace| '(XLAM (|u|) (QVELT |u| 0))) 

(DEFUN |IR;ratpart;$F;4| (|u| $) (QVELT |u| 0)) 

(PUT '|IR;logpart;$L;5| '|SPADreplace| '(XLAM (|u|) (QVELT |u| 1))) 

(DEFUN |IR;logpart;$L;5| (|u| $) (QVELT |u| 1)) 

(PUT '|IR;notelem;$L;6| '|SPADreplace| '(XLAM (|u|) (QVELT |u| 2))) 

(DEFUN |IR;notelem;$L;6| (|u| $) (QVELT |u| 2)) 

(DEFUN |IR;elem?;$B;7| (|u| $) (NULL (SPADCALL |u| (QREFELT $ 26)))) 

(DEFUN |IR;mkAnswer;FLL$;8| (|x| |l| |n| $)
  (VECTOR |x| |l| (|IR;nesimp| |n| $))) 

(DEFUN |IR;timelog| (|r| |lg| $)
  (VECTOR (SPADCALL |r| (QVELT |lg| 0) (QREFELT $ 30)) (QVELT |lg| 1)
          (QVELT |lg| 2))) 

(DEFUN |IR;integral;2F$;10| (|f| |x| $)
  (COND
    ((SPADCALL |f| (QREFELT $ 31)) (|spadConstant| $ 16))
    ('T
     (SPADCALL (|spadConstant| $ 17) NIL (LIST (CONS |f| |x|))
         (QREFELT $ 22))))) 

(DEFUN |IR;timene| (|r| |ne| $)
  (CONS (SPADCALL (|IR;Q2F| |r| $) (QCAR |ne|) (QREFELT $ 33))
        (QCDR |ne|))) 

(DEFUN |IR;*;I2$;12| (|n| |u| $)
  (SPADCALL (SPADCALL |n| (QREFELT $ 34)) |u| (QREFELT $ 35))) 

(DEFUN |IR;Q2F| (|r| $)
  (SPADCALL (SPADCALL (SPADCALL |r| (QREFELT $ 36)) (QREFELT $ 37))
      (SPADCALL (SPADCALL |r| (QREFELT $ 38)) (QREFELT $ 37))
      (QREFELT $ 39))) 

(DEFUN |IR;neselect| (|l| |x| $)
  (PROG (|ne| #0=#:G1866 #1=#:G1864 #2=#:G1862 #3=#:G1863)
    (RETURN
      (SEQ (PROGN
             (LETT #3# NIL . #4=(|IR;neselect|))
             (SEQ (LETT |ne| NIL . #4#) (LETT #0# |l| . #4#) G190
                  (COND
                    ((OR (ATOM #0#)
                         (PROGN (LETT |ne| (CAR #0#) . #4#) NIL))
                     (GO G191)))
                  (SEQ (EXIT (COND
                               ((SPADCALL (QCDR |ne|) |x|
                                    (QREFELT $ 40))
                                (PROGN
                                  (LETT #1# (QCAR |ne|) . #4#)
                                  (COND
                                    (#3#
                                     (LETT #2#
                                      (SPADCALL #2# #1# (QREFELT $ 41)) . #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| $ 17)))))))) 

(DEFUN |IR;integral;FS$;15| (|f| |x| $)
  (SPADCALL |f| (SPADCALL |x| (QREFELT $ 42)) (QREFELT $ 32))) 

(DEFUN |IR;LOG2O| (|rec| $)
  (PROG (|lastc| |lg| |coeffp| |cc| |logandp|)
    (RETURN
      (SEQ (COND
             ((EQL (SPADCALL (QVELT |rec| 1) (QREFELT $ 46)) 1)
              (SEQ (LETT |lastc|
                         (SPADCALL
                             (SPADCALL
                                 (SPADCALL (QVELT |rec| 1) 0
                                     (QREFELT $ 48))
                                 (SPADCALL (QVELT |rec| 1) 1
                                     (QREFELT $ 48))
                                 (QREFELT $ 39))
                             (QREFELT $ 49))
                         . #0=(|IR;LOG2O|))
                   (LETT |lg|
                         (SPADCALL (QVELT |rec| 2) |lastc|
                             (QREFELT $ 50)) . #0#)
                   (LETT |logandp|
                         (SPADCALL
                             (SPADCALL (SPADCALL "log" (QREFELT $ 52))
                                 (QREFELT $ 11))
                             (LIST (SPADCALL |lg| (QREFELT $ 53)))
                             (QREFELT $ 55)) . #0#)
                   (LETT |cc|
                         (SPADCALL (|IR;Q2F| (QVELT |rec| 0) $) |lastc|
                             (QREFELT $ 33)) . #0#)
                   (EXIT (COND
                           ((SPADCALL |cc| (|spadConstant| $ 47)
                                (QREFELT $ 40))
                            |logandp|)
                           ((SPADCALL |cc|
                                (SPADCALL (|spadConstant| $ 47)
                                    (QREFELT $ 49))
                                (QREFELT $ 40))
                            (SPADCALL |logandp| (QREFELT $ 57)))
                           ('T
                            (SPADCALL (SPADCALL |cc| (QREFELT $ 53))
                                |logandp| (QREFELT $ 58)))))))
             ('T
              (SEQ (LETT |coeffp|
                         (SPADCALL
                             (SPADCALL (QVELT |rec| 1) (QREFELT $ 12)
                                 (QREFELT $ 59))
                             (SPADCALL 0 (QREFELT $ 60))
                             (QREFELT $ 61)) . #0#)
                   (LETT |logandp|
                         (SPADCALL (QREFELT $ 12)
                             (SPADCALL
                                 (SPADCALL
                                     (SPADCALL "log" (QREFELT $ 52))
                                     (QREFELT $ 11))
                                 (LIST (SPADCALL (QVELT |rec| 2)
                                        (QREFELT $ 12) (QREFELT $ 59)))
                                 (QREFELT $ 55))
                             (QREFELT $ 58)) . #0#)
                   (SEQ (LETT |cc| (|IR;Q2F| (QVELT |rec| 0) $) . #0#)
                        (EXIT (COND
                                ((NULL (SPADCALL |cc|
                                        (|spadConstant| $ 47)
                                        (QREFELT $ 40)))
                                 (LETT |logandp|
                                       (SPADCALL
                                        (SPADCALL |cc| (QREFELT $ 53))
                                        |logandp| (QREFELT $ 58)) . #0#)))))
                   (EXIT (SPADCALL |logandp| |coeffp| (QREFELT $ 62)))))))))) 

(DEFUN |IR;nesimp| (|l| $)
  (PROG (#0=#:G1882 |x| #1=#:G1884 |ne| #2=#:G1885 #3=#:G1883 |u|)
    (RETURN
      (SEQ (PROGN
             (LETT #0# NIL . #4=(|IR;nesimp|))
             (SEQ (LETT |x| NIL . #4#)
                  (LETT #3#
                        (SPADCALL
                            (PROGN
                              (LETT #1# NIL . #4#)
                              (SEQ (LETT |ne| NIL . #4#)
                                   (LETT #2# |l| . #4#) G190
                                   (COND
                                     ((OR (ATOM #2#)
                                       (PROGN
                                         (LETT |ne| (CAR #2#) . #4#)
                                         NIL))
                                      #5=(GO G191)))
                                   (SEQ
                                    (EXIT
                                     (LETT #1#
                                      (CONS (QCDR |ne|) #1#) . #4#)))
                                   (LETT #2# (CDR #2#) . #4#)
                                   #6=(GO G190) G191
                                   (EXIT (NREVERSE0 #1#))))
                            (QREFELT $ 64)) . #4#)
                  G190
                  (COND
                    ((OR (ATOM #3#)
                         (PROGN (LETT |x| (CAR #3#) . #4#) NIL))
                     #5#))
                  (SEQ (EXIT (COND
                               ((SEQ (LETT |u|
                                      (|IR;neselect| |l| |x| $) . #4#)
                                     (EXIT
                                      (COND
                                        ((SPADCALL |u|
                                          (|spadConstant| $ 17)
                                          (QREFELT $ 40))
                                         'NIL)
                                        ('T 'T))))
                                (LETT #0#
                                      (CONS (CONS |u| |x|) #0#) . #4#)))))
                  (LETT #3# (CDR #3#) . #4#) #6# G191
                  (EXIT (NREVERSE0 #0#)))))))) 

(DEFUN |IR;retractIfCan;$U;18| (|u| $)
  (PROG (|ne| #0=#:G1899 #1=#:G1893 #2=#:G1891 #3=#:G1892)
    (RETURN
      (SEQ (COND
             ((NULL (SPADCALL |u| (QREFELT $ 25)))
              (CONS 0
                    (SPADCALL (SPADCALL |u| (QREFELT $ 24))
                        (PROGN
                          (LETT #3# NIL . #4=(|IR;retractIfCan;$U;18|))
                          (SEQ (LETT |ne| NIL . #4#)
                               (LETT #0#
                                     (SPADCALL |u| (QREFELT $ 26)) . #4#)
                               G190
                               (COND
                                 ((OR (ATOM #0#)
                                      (PROGN
                                        (LETT |ne| (CAR #0#) . #4#)
                                        NIL))
                                  (GO G191)))
                               (SEQ (EXIT
                                     (PROGN
                                       (LETT #1#
                                        (SPADCALL (QCAR |ne|)
                                         (SPADCALL (QCDR |ne|)
                                          (QREFELT $ 65))
                                         (QREFELT $ 66)) . #4#)
                                       (COND
                                         (#3#
                                          (LETT #2#
                                           (SPADCALL #2# #1#
                                            (QREFELT $ 41)) . #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| $ 17))))
                        (QREFELT $ 41))))
             ('T (CONS 1 "failed"))))))) 

(DEFUN |IR;retractIfCan;$U;19| (|u| $)
  (SEQ (COND
         ((SPADCALL |u| (QREFELT $ 28))
          (COND
            ((NULL (SPADCALL |u| (QREFELT $ 25)))
             (EXIT (CONS 0 (SPADCALL |u| (QREFELT $ 24))))))))
       (EXIT (CONS 1 "failed")))) 

(DEFUN |IR;retractIfCan;$U;20| (|u| $)
  (SEQ (COND
         ((SPADCALL |u| (QREFELT $ 28))
          (COND
            ((NULL (SPADCALL |u| (QREFELT $ 25)))
             (EXIT (CONS 0 (SPADCALL |u| (QREFELT $ 24))))))))
       (EXIT (CONS 1 "failed")))) 

(DEFUN |IR;*;F2$;21| (|r| |u| $)
  (COND
    ((SPADCALL |r| (|spadConstant| $ 69) (QREFELT $ 70))
     (|spadConstant| $ 16))
    ('T
     (SPADCALL
         (SPADCALL (|IR;Q2F| |r| $) (SPADCALL |u| (QREFELT $ 24))
             (QREFELT $ 33))
         (SPADCALL (CONS #'|IR;*;F2$;21!0| (VECTOR $ |r|))
             (SPADCALL |u| (QREFELT $ 25)) (QREFELT $ 72))
         (SPADCALL (CONS #'|IR;*;F2$;21!1| (VECTOR $ |r|))
             (SPADCALL |u| (QREFELT $ 26)) (QREFELT $ 74))
         (QREFELT $ 22))))) 

(DEFUN |IR;*;F2$;21!1| (|#1| $$)
  (|IR;timene| (QREFELT $$ 1) |#1| (QREFELT $$ 0))) 

(DEFUN |IR;*;F2$;21!0| (|#1| $$)
  (|IR;timelog| (QREFELT $$ 1) |#1| (QREFELT $$ 0))) 

(DEFUN |IR;+;3$;22| (|u| |v| $)
  (SPADCALL
      (SPADCALL (SPADCALL |u| (QREFELT $ 24))
          (SPADCALL |v| (QREFELT $ 24)) (QREFELT $ 41))
      (SPADCALL (SPADCALL |u| (QREFELT $ 25))
          (SPADCALL |v| (QREFELT $ 25)) (QREFELT $ 75))
      (|IR;nesimp|
          (SPADCALL (SPADCALL |u| (QREFELT $ 26))
              (SPADCALL |v| (QREFELT $ 26)) (QREFELT $ 76))
          $)
      (QREFELT $ 22))) 

(DEFUN |IR;differentiate;$SF;23| (|u| |x| $)
  (SPADCALL |u| (CONS #'|IR;differentiate;$SF;23!0| (VECTOR $ |x|))
      (QREFELT $ 80))) 

(DEFUN |IR;differentiate;$SF;23!0| (|#1| $$)
  (SPADCALL |#1| (QREFELT $$ 1) (QREFELT (QREFELT $$ 0) 78))) 

(DEFUN |IR;differentiate;$MF;24| (|u| |derivation| $)
  (PROG (|log| #0=#:G1935 #1=#:G1929 #2=#:G1927 #3=#:G1928 |ne|
               #4=#:G1936 #5=#:G1933 #6=#:G1931 #7=#:G1932)
    (RETURN
      (SEQ (SPADCALL
               (SPADCALL
                   (SPADCALL (SPADCALL |u| (QREFELT $ 24))
                       |derivation|)
                   (PROGN
                     (LETT #3# NIL . #8=(|IR;differentiate;$MF;24|))
                     (SEQ (LETT |log| NIL . #8#)
                          (LETT #0#
                                (SPADCALL |u| (QREFELT $ 25)) . #8#)
                          G190
                          (COND
                            ((OR (ATOM #0#)
                                 (PROGN
                                   (LETT |log| (CAR #0#) . #8#)
                                   NIL))
                             #9=(GO G191)))
                          (SEQ (EXIT (PROGN
                                       (LETT #1#
                                        (|IR;pLogDeriv| |log|
                                         |derivation| $) . #8#)
                                       (COND
                                         (#3#
                                          (LETT #2#
                                           (SPADCALL #2# #1#
                                            (QREFELT $ 41)) . #8#))
                                         ('T
                                          (PROGN
                                            (LETT #2# #1# . #8#)
                                            (LETT #3# 'T . #8#)))))))
                          (LETT #0# (CDR #0#) . #8#) #10=(GO G190) G191
                          (EXIT NIL))
                     (COND (#3# #2#) (#11='T (|spadConstant| $ 17))))
                   (QREFELT $ 41))
               (PROGN
                 (LETT #7# NIL . #8#)
                 (SEQ (LETT |ne| NIL . #8#)
                      (LETT #4# (SPADCALL |u| (QREFELT $ 26)) . #8#)
                      G190
                      (COND
                        ((OR (ATOM #4#)
                             (PROGN (LETT |ne| (CAR #4#) . #8#) NIL))
                         #9#))
                      (SEQ (EXIT (PROGN
                                   (LETT #5#
                                    (|IR;pNeDeriv| |ne| |derivation| $) . #8#)
                                   (COND
                                     (#7#
                                      (LETT #6#
                                       (SPADCALL #6# #5#
                                        (QREFELT $ 41)) . #8#))
                                     ('T
                                      (PROGN
                                        (LETT #6# #5# . #8#)
                                        (LETT #7# 'T . #8#)))))))
                      (LETT #4# (CDR #4#) . #8#) #10# G191 (EXIT NIL))
                 (COND (#7# #6#) (#11# (|spadConstant| $ 17))))
               (QREFELT $ 41)))))) 

(DEFUN |IR;pNeDeriv| (|ne| |derivation| $)
  (COND
    ((SPADCALL (SPADCALL (QCDR |ne|) |derivation|)
         (|spadConstant| $ 47) (QREFELT $ 40))
     (QCAR |ne|))
    ((SPADCALL (SPADCALL (QCAR |ne|) |derivation|) (QREFELT $ 31))
     (|spadConstant| $ 17))
    ('T
     (|error| "pNeDeriv: cannot differentiate not elementary part into F")))) 

(DEFUN |IR;pLogDeriv| (|log| |derivation| $)
  (PROG (|n| |c| |numlog| #0=#:G1952 |diflog| |i| #1=#:G1959 |algans|
             |ans|)
    (RETURN
      (SEQ (COND
             ((NULL (SPADCALL
                        (SPADCALL |derivation| (QVELT |log| 1)
                            (QREFELT $ 82))
                        (|spadConstant| $ 83) (QREFELT $ 84)))
              (|error| "pLogDeriv: can only handle logs with constant coefficients"))
             ('T
              (SEQ (LETT |n| (SPADCALL (QVELT |log| 1) (QREFELT $ 46))
                         . #2=(|IR;pLogDeriv|))
                   (EXIT (COND
                           ((EQL |n| 1)
                            (SEQ (LETT |c|
                                       (SPADCALL
                                        (SPADCALL
                                         (SPADCALL
                                          (SPADCALL (QVELT |log| 1)
                                           (QREFELT $ 85))
                                          (QREFELT $ 86))
                                         (SPADCALL (QVELT |log| 1)
                                          (QREFELT $ 86))
                                         (QREFELT $ 39))
                                        (QREFELT $ 49)) . #2#)
                                 (LETT |ans|
                                       (SPADCALL (QVELT |log| 2) |c|
                                        (QREFELT $ 50)) . #2#)
                                 (EXIT (SPADCALL
                                        (SPADCALL
                                         (SPADCALL
                                          (|IR;Q2F| (QVELT |log| 0) $)
                                          |c| (QREFELT $ 33))
                                         (SPADCALL |ans| |derivation|)
                                         (QREFELT $ 33))
                                        |ans| (QREFELT $ 39)))))
                           ('T
                            (SEQ (LETT |numlog|
                                       (SPADCALL |derivation|
                                        (QVELT |log| 2) (QREFELT $ 82)) . #2#)
                                 (LETT |diflog|
                                       (PROG2
                                        (LETT #0#
                                         (SPADCALL (QVELT |log| 2)
                                          (QVELT |log| 1) |numlog|
                                          (QREFELT $ 89)) . #2#)
                                        (QCDR #0#)
                                         (|check-union| (QEQCAR #0# 0)
                                          (|Record|
                                           (|:| |coef1|
                                            (|SparseUnivariatePolynomial|
                                             (QREFELT $ 6)))
                                           (|:| |coef2|
                                            (|SparseUnivariatePolynomial|
                                             (QREFELT $ 6))))
                                          #0#)) . #2#)
                                 (LETT |algans| (QCAR |diflog|) . #2#)
                                 (LETT |ans|
                                       (|spadConstant| $ 17) . #2#)
                                 (SEQ (LETT |i| 0 . #2#)
                                      (LETT #1# (- |n| 1) . #2#) G190
                                      (COND
                                        ((QSGREATERP |i| #1#)
                                         (GO G191)))
                                      (SEQ
                                       (LETT |algans|
                                        (SPADCALL
                                         (SPADCALL |algans|
                                          (SPADCALL
                                           (|spadConstant| $ 47) 1
                                           (QREFELT $ 90))
                                          (QREFELT $ 91))
                                         (QVELT |log| 1)
                                         (QREFELT $ 92)) . #2#)
                                       (EXIT
                                        (LETT |ans|
                                         (SPADCALL |ans|
                                          (SPADCALL |algans| |i|
                                           (QREFELT $ 48))
                                          (QREFELT $ 41)) . #2#)))
                                      (LETT |i| (QSADD1 |i|) . #2#)
                                      (GO G190) G191 (EXIT NIL))
                                 (EXIT (SPADCALL
                                        (|IR;Q2F| (QVELT |log| 0) $)
                                        |ans| (QREFELT $ 33)))))))))))))) 

(DEFUN |IR;coerce;$Of;27| (|u| $)
  (PROG (|r| #0=#:G1976 #1=#:G1977 #2=#:G1978 |f| #3=#:G1979 |l|)
    (RETURN
      (SEQ (LETT |r| (SPADCALL |u| (QREFELT $ 68))
                 . #4=(|IR;coerce;$Of;27|))
           (EXIT (COND
                   ((QEQCAR |r| 0)
                    (SPADCALL (QCDR |r|) (QREFELT $ 53)))
                   (#5='T
                    (SEQ (LETT |l|
                               (NREVERSE
                                   (PROGN
                                     (LETT #0# NIL . #4#)
                                     (SEQ (LETT |f| NIL . #4#)
                                      (LETT #1#
                                       (SPADCALL |u| (QREFELT $ 25)) . #4#)
                                      G190
                                      (COND
                                        ((OR (ATOM #1#)
                                          (PROGN
                                            (LETT |f| (CAR #1#) . #4#)
                                            NIL))
                                         #6=(GO G191)))
                                      (SEQ
                                       (EXIT
                                        (LETT #0#
                                         (CONS (|IR;LOG2O| |f| $) #0#) . #4#)))
                                      (LETT #1# (CDR #1#) . #4#)
                                      #7=(GO G190) G191
                                      (EXIT (NREVERSE0 #0#))))) . #4#)
                         (COND
                           ((NULL (SPADCALL
                                      (SPADCALL |u| (QREFELT $ 24))
                                      (|spadConstant| $ 17)
                                      (QREFELT $ 40)))
                            (LETT |l|
                                  (CONS (SPADCALL
                                         (SPADCALL |u| (QREFELT $ 24))
                                         (QREFELT $ 53))
                                        |l|) . #4#)))
                         (COND
                           ((NULL (SPADCALL |u| (QREFELT $ 28)))
                            (LETT |l|
                                  (SPADCALL
                                      (PROGN
                                        (LETT #2# NIL . #4#)
                                        (SEQ (LETT |f| NIL . #4#)
                                         (LETT #3#
                                          (SPADCALL |u| (QREFELT $ 26)) . #4#)
                                         G190
                                         (COND
                                           ((OR (ATOM #3#)
                                             (PROGN
                                               (LETT |f|
                                                (CAR #3#) . #4#)
                                               NIL))
                                            #6#))
                                         (SEQ
                                          (EXIT
                                           (LETT #2#
                                            (CONS (|IR;NE2O| |f| $)
                                             #2#) . #4#)))
                                         (LETT #3# (CDR #3#) . #4#) #7#
                                         G191 (EXIT (NREVERSE0 #2#))))
                                      |l| (QREFELT $ 94)) . #4#)))
                         (EXIT (COND
                                 ((NULL |l|)
                                  (SPADCALL (|spadConstant| $ 16)
                                      (QREFELT $ 95)))
                                 (#5#
                                  (SPADCALL (ELT $ 96) |l|
                                      (QREFELT $ 98))))))))))))) 

(DEFUN |IR;NE2O| (|ne| $)
  (SPADCALL
      (SPADCALL (SPADCALL (QCAR |ne|) (QREFELT $ 53))
          (SPADCALL
              (LIST (SPADCALL (SPADCALL "d" (QREFELT $ 52))
                        (QREFELT $ 11))
                    (SPADCALL (QCDR |ne|) (QREFELT $ 53)))
              (QREFELT $ 99))
          (QREFELT $ 58))
      (QREFELT $ 100))) 

(DEFUN |IntegrationResult| (#0=#:G1985)
  (PROG ()
    (RETURN
      (PROG (#1=#:G1986)
        (RETURN
          (COND
            ((LETT #1#
                   (|lassocShiftWithFunction| (LIST (|devaluate| #0#))
                       (HGET |$ConstructorCache| '|IntegrationResult|)
                       '|domainEqualList|)
                   . #2=(|IntegrationResult|))
             (|CDRwithIncrement| #1#))
            ('T
             (UNWIND-PROTECT
               (PROG1 (|IntegrationResult;| #0#) (LETT #1# T . #2#))
               (COND
                 ((NOT #1#)
                  (HREM |$ConstructorCache| '|IntegrationResult|))))))))))) 

(DEFUN |IntegrationResult;| (|#1|)
  (PROG (DV$1 |dv$| $ |pv$|)
    (RETURN
      (PROGN
        (LETT DV$1 (|devaluate| |#1|) . #0=(|IntegrationResult|))
        (LETT |dv$| (LIST '|IntegrationResult| DV$1) . #0#)
        (LETT $ (GETREFV 104) . #0#)
        (QSETREFV $ 0 |dv$|)
        (QSETREFV $ 3
            (LETT |pv$|
                  (|buildPredVector| 0 0
                      (LIST (|HasCategory| |#1|
                                '(|PartialDifferentialRing| (|Symbol|)))
                            (|HasCategory| |#1|
                                '(|RetractableTo| (|Symbol|))))) . #0#))
        (|haddProp| |$ConstructorCache| '|IntegrationResult|
            (LIST DV$1) (CONS 1 $))
        (|stuffDomainSlots| $)
        (QSETREFV $ 6 |#1|)
        (QSETREFV $ 7
            (|Record| (|:| |ratp| |#1|)
                (|:| |logp|
                     (|List| (|Record|
                                 (|:| |scalar|
                                      (|Fraction| (|Integer|)))
                                 (|:| |coeff|
                                      (|SparseUnivariatePolynomial|
                                       |#1|))
                                 (|:| |logand|
                                      (|SparseUnivariatePolynomial|
                                       |#1|)))))
                (|:| |nelem|
                     (|List| (|Record| (|:| |integrand| |#1|)
                                 (|:| |intvar| |#1|))))))
        (QSETREFV $ 12
            (SPADCALL (SPADCALL (QREFELT $ 9)) (QREFELT $ 11)))
        (COND
          ((|testBitVector| |pv$| 2)
           (QSETREFV $ 43
               (CONS (|dispatchFunction| |IR;integral;FS$;15|) $))))
        (COND
          ((|HasCategory| |#1| '(|LiouvillianFunctionCategory|))
           (COND
             ((|testBitVector| |pv$| 2)
              (QSETREFV $ 68
                  (CONS (|dispatchFunction| |IR;retractIfCan;$U;18|) $)))
             ('T
              (QSETREFV $ 68
                  (CONS (|dispatchFunction| |IR;retractIfCan;$U;19|) $)))))
          ('T
           (QSETREFV $ 68
               (CONS (|dispatchFunction| |IR;retractIfCan;$U;20|) $))))
        (COND
          ((|testBitVector| |pv$| 1)
           (QSETREFV $ 81
               (CONS (|dispatchFunction| |IR;differentiate;$SF;23|) $))))
        $)))) 

(MAKEPROP '|IntegrationResult| '|infovec|
    (LIST '#(NIL NIL NIL NIL NIL NIL (|local| |#1|) '|Rep| (|Symbol|)
             (0 . |new|) (|OutputForm|) (4 . |coerce|) '|alpha|
             (|Integer|) |IR;*;I2$;12| |IR;-;2$;1|
             (CONS IDENTITY
                   (FUNCALL (|dispatchFunction| |IR;Zero;$;2|) $))
             (9 . |Zero|)
             (|Record| (|:| |scalar| 29) (|:| |coeff| 45)
                 (|:| |logand| 45))
             (|List| 18)
             (|Record| (|:| |integrand| 6) (|:| |intvar| 6))
             (|List| 20) |IR;mkAnswer;FLL$;8| |IR;coerce;F$;3|
             |IR;ratpart;$F;4| |IR;logpart;$L;5| |IR;notelem;$L;6|
             (|Boolean|) |IR;elem?;$B;7| (|Fraction| 13) (13 . *)
             (19 . |zero?|) |IR;integral;2F$;10| (24 . *)
             (30 . |coerce|) |IR;*;F2$;21| (35 . |numer|)
             (40 . |coerce|) (45 . |denom|) (50 . /) (56 . =) (62 . +)
             (68 . |coerce|) (73 . |integral|) (|NonNegativeInteger|)
             (|SparseUnivariatePolynomial| 6) (79 . |degree|)
             (84 . |One|) (88 . |coefficient|) (94 . -) (99 . |elt|)
             (|String|) (105 . |coerce|) (110 . |coerce|) (|List| $)
             (115 . |prefix|) (121 . |One|) (125 . -) (130 . *)
             (136 . |outputForm|) (142 . |coerce|) (147 . =)
             (153 . |sum|) (|List| 6) (159 . |removeDuplicates!|)
             (164 . |retract|) (169 . |integral|) (|Union| 6 '"failed")
             (175 . |retractIfCan|) (180 . |Zero|) (184 . =)
             (|Mapping| 18 18) (190 . |map|) (|Mapping| 20 20)
             (196 . |map|) (202 . |concat|) (208 . |concat|)
             |IR;+;3$;22| (214 . |differentiate|) (|Mapping| 6 6)
             |IR;differentiate;$MF;24| (220 . |differentiate|)
             (226 . |map|) (232 . |Zero|) (236 . =) (242 . |reductum|)
             (247 . |leadingCoefficient|)
             (|Record| (|:| |coef1| $) (|:| |coef2| $))
             (|Union| 87 '"failed") (252 . |extendedEuclidean|)
             (259 . |monomial|) (265 . *) (271 . |rem|) (|List| 10)
             (277 . |concat|) |IR;coerce;$Of;27| (283 . +)
             (|Mapping| 10 10 10) (289 . |reduce|) (295 . |hconcat|)
             (300 . |int|) (|Union| $ '"failed") (|PositiveInteger|)
             (|SingleInteger|))
          '#(~= 305 |zero?| 311 |subtractIfCan| 316 |sample| 322
             |retractIfCan| 326 |retract| 331 |ratpart| 336 |notelem|
             341 |mkAnswer| 346 |logpart| 353 |latex| 358 |integral|
             363 |hash| 375 |elem?| 380 |differentiate| 385 |coerce|
             397 |Zero| 407 = 411 - 417 + 428 * 434)
          'NIL
          (CONS (|makeByteWordVec2| 1 '(0 0 0 0 0 0 0 0 0 0 0 0))
                (CONS '#(|Module&| NIL NIL NIL |AbelianGroup&| NIL
                         |AbelianMonoid&| |AbelianSemiGroup&|
                         |SetCategory&| |RetractableTo&| |BasicType&|
                         NIL)
                      (CONS '#((|Module| 29) (|BiModule| 29 29)
                               (|LeftModule| 29) (|RightModule| 29)
                               (|AbelianGroup|)
                               (|CancellationAbelianMonoid|)
                               (|AbelianMonoid|) (|AbelianSemiGroup|)
                               (|SetCategory|) (|RetractableTo| 6)
                               (|BasicType|) (|CoercibleTo| 10))
                            (|makeByteWordVec2| 103
                                '(0 8 0 9 1 8 10 0 11 0 6 0 17 2 29 0 0
                                  0 30 1 6 27 0 31 2 6 0 0 0 33 1 29 0
                                  13 34 1 29 13 0 36 1 6 0 13 37 1 29
                                  13 0 38 2 6 0 0 0 39 2 6 27 0 0 40 2
                                  6 0 0 0 41 1 6 0 8 42 2 0 0 6 8 43 1
                                  45 44 0 46 0 6 0 47 2 45 6 0 44 48 1
                                  6 0 0 49 2 45 6 0 6 50 1 8 0 51 52 1
                                  6 10 0 53 2 10 0 0 54 55 0 45 0 56 1
                                  10 0 0 57 2 10 0 0 0 58 2 45 10 0 10
                                  59 1 13 10 0 60 2 10 0 0 0 61 2 10 0
                                  0 0 62 1 63 0 0 64 1 6 8 0 65 2 6 0 0
                                  8 66 1 0 67 0 68 0 29 0 69 2 29 27 0
                                  0 70 2 19 0 71 0 72 2 21 0 73 0 74 2
                                  19 0 0 0 75 2 21 0 0 0 76 2 6 0 0 8
                                  78 2 0 6 0 8 81 2 45 0 79 0 82 0 45 0
                                  83 2 45 27 0 0 84 1 45 0 0 85 1 45 6
                                  0 86 3 45 88 0 0 0 89 2 45 0 6 44 90
                                  2 45 0 0 0 91 2 45 0 0 0 92 2 93 0 0
                                  0 94 2 10 0 0 0 96 2 93 10 97 0 98 1
                                  10 0 54 99 1 10 0 0 100 2 0 27 0 0 1
                                  1 0 27 0 1 2 0 101 0 0 1 0 0 0 1 1 0
                                  67 0 68 1 0 6 0 1 1 0 6 0 24 1 0 21 0
                                  26 3 0 0 6 19 21 22 1 0 19 0 25 1 0
                                  51 0 1 2 2 0 6 8 43 2 0 0 6 6 32 1 0
                                  103 0 1 1 0 27 0 28 2 1 6 0 8 81 2 0
                                  6 0 79 80 1 0 0 6 23 1 0 10 0 95 0 0
                                  0 16 2 0 27 0 0 1 1 0 0 0 15 2 0 0 0
                                  0 1 2 0 0 0 0 77 2 0 0 29 0 35 2 0 0
                                  0 29 1 2 0 0 13 0 14 2 0 0 44 0 1 2 0
                                  0 102 0 1)))))
          '|lookupComplete|)) 
