
(/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 (#1=#:G1859 #2=#:G1858 #3=#:G1860 #4=#:G1862 |ne|)
    (RETURN
     (SEQ
      (PROGN
       (LETT #1# NIL . #5=(|IR;neselect|))
       (SEQ (LETT |ne| NIL . #5#) (LETT #4# |l| . #5#) G190
            (COND
             ((OR (ATOM #4#) (PROGN (LETT |ne| (CAR #4#) . #5#) NIL))
              (GO G191)))
            (SEQ
             (EXIT
              (COND
               ((SPADCALL (QCDR |ne|) |x| (QREFELT $ 40))
                (PROGN
                 (LETT #3# (QCAR |ne|) . #5#)
                 (COND (#1# (LETT #2# (SPADCALL #2# #3# (QREFELT $ 41)) . #5#))
                       ('T
                        (PROGN (LETT #2# #3# . #5#) (LETT #1# 'T . #5#)))))))))
            (LETT #4# (CDR #4#) . #5#) (GO G190) G191 (EXIT NIL))
       (COND (#1# #2#) ('T (|spadConstant| $ 17)))))))) 

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

(DEFUN |IR;LOG2O| (|rec| $)
  (PROG (|logandp| |cc| |coeffp| |lg| |lastc|)
    (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))
               . #1=(|IR;LOG2O|))
         (LETT |lg| (SPADCALL (QVELT |rec| 2) |lastc| (QREFELT $ 50)) . #1#)
         (LETT |logandp|
               (SPADCALL (SPADCALL '|log| (QREFELT $ 11))
                         (LIST (SPADCALL |lg| (QREFELT $ 51))) (QREFELT $ 53))
               . #1#)
         (LETT |cc|
               (SPADCALL (|IR;Q2F| (QVELT |rec| 0) $) |lastc| (QREFELT $ 33))
               . #1#)
         (EXIT
          (COND
           ((SPADCALL |cc| (|spadConstant| $ 47) (QREFELT $ 40)) |logandp|)
           ((SPADCALL |cc| (SPADCALL (|spadConstant| $ 47) (QREFELT $ 49))
                      (QREFELT $ 40))
            (SPADCALL |logandp| (QREFELT $ 55)))
           (#2='T
            (SPADCALL (SPADCALL |cc| (QREFELT $ 51)) |logandp|
                      (QREFELT $ 56)))))))
       (#2#
        (SEQ
         (LETT |coeffp|
               (SPADCALL
                (SPADCALL (QVELT |rec| 1) (QREFELT $ 12) (QREFELT $ 57))
                (SPADCALL 0 (QREFELT $ 58)) (QREFELT $ 59))
               . #1#)
         (LETT |logandp|
               (SPADCALL (QREFELT $ 12)
                         (SPADCALL (SPADCALL '|log| (QREFELT $ 11))
                                   (LIST
                                    (SPADCALL (QVELT |rec| 2) (QREFELT $ 12)
                                              (QREFELT $ 57)))
                                   (QREFELT $ 53))
                         (QREFELT $ 56))
               . #1#)
         (SEQ (LETT |cc| (|IR;Q2F| (QVELT |rec| 0) $) . #1#)
              (EXIT
               (COND
                ((NULL (SPADCALL |cc| (|spadConstant| $ 47) (QREFELT $ 40)))
                 (LETT |logandp|
                       (SPADCALL (SPADCALL |cc| (QREFELT $ 51)) |logandp|
                                 (QREFELT $ 56))
                       . #1#)))))
         (EXIT (SPADCALL |logandp| |coeffp| (QREFELT $ 60)))))))))) 

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

(DEFUN |IR;retractIfCan;$U;18| (|u| $)
  (PROG (#1=#:G1888 #2=#:G1887 #3=#:G1889 #4=#:G1895 |ne|)
    (RETURN
     (SEQ
      (COND
       ((NULL (SPADCALL |u| (QREFELT $ 25)))
        (CONS 0
              (SPADCALL (SPADCALL |u| (QREFELT $ 24))
                        (PROGN
                         (LETT #1# NIL . #5=(|IR;retractIfCan;$U;18|))
                         (SEQ (LETT |ne| NIL . #5#)
                              (LETT #4# (SPADCALL |u| (QREFELT $ 26)) . #5#)
                              G190
                              (COND
                               ((OR (ATOM #4#)
                                    (PROGN (LETT |ne| (CAR #4#) . #5#) NIL))
                                (GO G191)))
                              (SEQ
                               (EXIT
                                (PROGN
                                 (LETT #3#
                                       (SPADCALL (QCAR |ne|)
                                                 (SPADCALL (QCDR |ne|)
                                                           (QREFELT $ 63))
                                                 (QREFELT $ 64))
                                       . #5#)
                                 (COND
                                  (#1#
                                   (LETT #2# (SPADCALL #2# #3# (QREFELT $ 41))
                                         . #5#))
                                  ('T
                                   (PROGN
                                    (LETT #2# #3# . #5#)
                                    (LETT #1# 'T . #5#)))))))
                              (LETT #4# (CDR #4#) . #5#) (GO G190) G191
                              (EXIT NIL))
                         (COND (#1# #2#) (#6='T (|spadConstant| $ 17))))
                        (QREFELT $ 41))))
       (#6# (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| $)
  (PROG ()
    (RETURN
     (COND
      ((SPADCALL |r| (|spadConstant| $ 67) (QREFELT $ 68))
       (|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 $ 70))
        (SPADCALL (CONS #'|IR;*;F2$;21!1| (VECTOR $ |r|))
                  (SPADCALL |u| (QREFELT $ 26)) (QREFELT $ 72))
        (QREFELT $ 22))))))) 

(DEFUN |IR;*;F2$;21!1| (|x1| $$)
  (PROG (|r| $)
    (LETT |r| (QREFELT $$ 1) . #1=(|IR;*;F2$;21|))
    (LETT $ (QREFELT $$ 0) . #1#)
    (RETURN (PROGN (|IR;timene| |r| |x1| $))))) 

(DEFUN |IR;*;F2$;21!0| (|x1| $$)
  (PROG (|r| $)
    (LETT |r| (QREFELT $$ 1) . #1=(|IR;*;F2$;21|))
    (LETT $ (QREFELT $$ 0) . #1#)
    (RETURN (PROGN (|IR;timelog| |r| |x1| $))))) 

(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 $ 73))
   (|IR;nesimp|
    (SPADCALL (SPADCALL |u| (QREFELT $ 26)) (SPADCALL |v| (QREFELT $ 26))
              (QREFELT $ 74))
    $)
   (QREFELT $ 22))) 

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

(DEFUN |IR;differentiate;$SF;23!0| (|x1| $$)
  (PROG (|x| $)
    (LETT |x| (QREFELT $$ 1) . #1=(|IR;differentiate;$SF;23|))
    (LETT $ (QREFELT $$ 0) . #1#)
    (RETURN (PROGN (SPADCALL |x1| |x| (QREFELT $ 76)))))) 

(DEFUN |IR;differentiate;$MF;24| (|u| |derivation| $)
  (PROG (#1=#:G1940 #2=#:G1939 #3=#:G1941 #4=#:G1945 |ne| #5=#:G1935 #6=#:G1934
         #7=#:G1936 #8=#:G1944 |log|)
    (RETURN
     (SEQ
      (SPADCALL
       (SPADCALL (SPADCALL (SPADCALL |u| (QREFELT $ 24)) |derivation|)
                 (PROGN
                  (LETT #5# NIL . #9=(|IR;differentiate;$MF;24|))
                  (SEQ (LETT |log| NIL . #9#)
                       (LETT #8# (SPADCALL |u| (QREFELT $ 25)) . #9#) G190
                       (COND
                        ((OR (ATOM #8#)
                             (PROGN (LETT |log| (CAR #8#) . #9#) NIL))
                         #10=(GO G191)))
                       (SEQ
                        (EXIT
                         (PROGN
                          (LETT #7# (|IR;pLogDeriv| |log| |derivation| $)
                                . #9#)
                          (COND
                           (#5#
                            (LETT #6# (SPADCALL #6# #7# (QREFELT $ 41)) . #9#))
                           ('T
                            (PROGN
                             (LETT #6# #7# . #9#)
                             (LETT #5# 'T . #9#)))))))
                       (LETT #8# (CDR #8#) . #9#) #11=(GO G190) G191
                       (EXIT NIL))
                  (COND (#5# #6#) (#12='T (|spadConstant| $ 17))))
                 (QREFELT $ 41))
       (PROGN
        (LETT #1# NIL . #9#)
        (SEQ (LETT |ne| NIL . #9#)
             (LETT #4# (SPADCALL |u| (QREFELT $ 26)) . #9#) G190
             (COND
              ((OR (ATOM #4#) (PROGN (LETT |ne| (CAR #4#) . #9#) NIL)) #10#))
             (SEQ
              (EXIT
               (PROGN
                (LETT #3# (|IR;pNeDeriv| |ne| |derivation| $) . #9#)
                (COND (#1# (LETT #2# (SPADCALL #2# #3# (QREFELT $ 41)) . #9#))
                      ('T (PROGN (LETT #2# #3# . #9#) (LETT #1# 'T . #9#)))))))
             (LETT #4# (CDR #4#) . #9#) #11# G191 (EXIT NIL))
        (COND (#1# #2#) (#12# (|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 (|ans| |algans| #1=#:G1971 |i| |diflog| #2=#:G1964 |numlog| |c| |n|)
    (RETURN
     (SEQ
      (COND
       ((NULL
         (SPADCALL (SPADCALL |derivation| (QVELT |log| 1) (QREFELT $ 80))
                   (|spadConstant| $ 81) (QREFELT $ 82)))
        (|error| "pLogDeriv: can only handle logs with constant coefficients"))
       ('T
        (SEQ
         (LETT |n| (SPADCALL (QVELT |log| 1) (QREFELT $ 46))
               . #3=(|IR;pLogDeriv|))
         (EXIT
          (COND
           ((EQL |n| 1)
            (SEQ
             (LETT |c|
                   (SPADCALL
                    (SPADCALL
                     (SPADCALL (SPADCALL (QVELT |log| 1) (QREFELT $ 83))
                               (QREFELT $ 84))
                     (SPADCALL (QVELT |log| 1) (QREFELT $ 84)) (QREFELT $ 39))
                    (QREFELT $ 49))
                   . #3#)
             (LETT |ans| (SPADCALL (QVELT |log| 2) |c| (QREFELT $ 50)) . #3#)
             (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 $ 80))
                   . #3#)
             (LETT |diflog|
                   (PROG2
                       (LETT #2#
                             (SPADCALL (QVELT |log| 2) (QVELT |log| 1) |numlog|
                                       (QREFELT $ 87))
                             . #3#)
                       (QCDR #2#)
                     (|check-union| (QEQCAR #2# 0)
                                    (|Record|
                                     (|:| |coef1|
                                          (|SparseUnivariatePolynomial|
                                           (QREFELT $ 6)))
                                     (|:| |coef2|
                                          (|SparseUnivariatePolynomial|
                                           (QREFELT $ 6))))
                                    #2#))
                   . #3#)
             (LETT |algans| (QCAR |diflog|) . #3#)
             (LETT |ans| (|spadConstant| $ 17) . #3#)
             (SEQ (LETT |i| 0 . #3#) (LETT #1# (- |n| 1) . #3#) G190
                  (COND ((QSGREATERP |i| #1#) (GO G191)))
                  (SEQ
                   (LETT |algans|
                         (SPADCALL
                          (SPADCALL |algans|
                                    (SPADCALL (|spadConstant| $ 47) 1
                                              (QREFELT $ 88))
                                    (QREFELT $ 89))
                          (QVELT |log| 1) (QREFELT $ 90))
                         . #3#)
                   (EXIT
                    (LETT |ans|
                          (SPADCALL |ans|
                                    (SPADCALL |algans| |i| (QREFELT $ 48))
                                    (QREFELT $ 41))
                          . #3#)))
                  (LETT |i| (QSADD1 |i|) . #3#) (GO G190) G191 (EXIT NIL))
             (EXIT
              (SPADCALL (|IR;Q2F| (QVELT |log| 0) $) |ans|
                        (QREFELT $ 33)))))))))))))) 

(DEFUN |IR;coerce;$Of;27| (|u| $)
  (PROG (|l| #1=#:G1993 |f| #2=#:G1992 #3=#:G1991 #4=#:G1990 |r|)
    (RETURN
     (SEQ (LETT |r| (SPADCALL |u| (QREFELT $ 66)) . #5=(|IR;coerce;$Of;27|))
          (EXIT
           (COND ((QEQCAR |r| 0) (SPADCALL (QCDR |r|) (QREFELT $ 51)))
                 (#6='T
                  (SEQ
                   (LETT |l|
                         (NREVERSE
                          (PROGN
                           (LETT #4# NIL . #5#)
                           (SEQ (LETT |f| NIL . #5#)
                                (LETT #3# (SPADCALL |u| (QREFELT $ 25)) . #5#)
                                G190
                                (COND
                                 ((OR (ATOM #3#)
                                      (PROGN (LETT |f| (CAR #3#) . #5#) NIL))
                                  #7=(GO G191)))
                                (SEQ
                                 (EXIT
                                  (LETT #4# (CONS (|IR;LOG2O| |f| $) #4#)
                                        . #5#)))
                                (LETT #3# (CDR #3#) . #5#) #8=(GO G190) G191
                                (EXIT (NREVERSE0 #4#)))))
                         . #5#)
                   (COND
                    ((NULL
                      (SPADCALL (SPADCALL |u| (QREFELT $ 24))
                                (|spadConstant| $ 17) (QREFELT $ 40)))
                     (LETT |l|
                           (CONS
                            (SPADCALL (SPADCALL |u| (QREFELT $ 24))
                                      (QREFELT $ 51))
                            |l|)
                           . #5#)))
                   (COND
                    ((NULL (SPADCALL |u| (QREFELT $ 28)))
                     (LETT |l|
                           (SPADCALL
                            (PROGN
                             (LETT #2# NIL . #5#)
                             (SEQ (LETT |f| NIL . #5#)
                                  (LETT #1# (SPADCALL |u| (QREFELT $ 26))
                                        . #5#)
                                  G190
                                  (COND
                                   ((OR (ATOM #1#)
                                        (PROGN (LETT |f| (CAR #1#) . #5#) NIL))
                                    #7#))
                                  (SEQ
                                   (EXIT
                                    (LETT #2# (CONS (|IR;NE2O| |f| $) #2#)
                                          . #5#)))
                                  (LETT #1# (CDR #1#) . #5#) #8# G191
                                  (EXIT (NREVERSE0 #2#))))
                            |l| (QREFELT $ 92))
                           . #5#)))
                   (EXIT
                    (COND
                     ((NULL |l|)
                      (SPADCALL (|spadConstant| $ 16) (QREFELT $ 93)))
                     (#6# (SPADCALL (ELT $ 94) |l| (QREFELT $ 96))))))))))))) 

(DEFUN |IR;NE2O| (|ne| $)
  (SPADCALL
   (SPADCALL (SPADCALL (QCAR |ne|) (QREFELT $ 51))
             (SPADCALL
              (LIST (SPADCALL '|d| (QREFELT $ 11))
                    (SPADCALL (QCDR |ne|) (QREFELT $ 51)))
              (QREFELT $ 97))
             (QREFELT $ 56))
   (QREFELT $ 98))) 

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

(DEFUN |IntegrationResult;| (|#1|)
  (PROG (|pv$| $ |dv$| DV$1)
    (RETURN
     (PROGN
      (LETT DV$1 (|devaluate| |#1|) . #1=(|IntegrationResult|))
      (LETT |dv$| (LIST '|IntegrationResult| DV$1) . #1#)
      (LETT $ (GETREFV 103) . #1#)
      (QSETREFV $ 0 |dv$|)
      (QSETREFV $ 3
                (LETT |pv$|
                      (|buildPredVector| 0 0
                                         (LIST
                                          (|HasCategory| |#1|
                                                         '(|PartialDifferentialRing|
                                                           (|Symbol|)))
                                          (|HasCategory| |#1|
                                                         '(|RetractableTo|
                                                           (|Symbol|)))))
                      . #1#))
      (|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 $ 66
                    (CONS (|dispatchFunction| |IR;retractIfCan;$U;18|) $)))
         ('T
          (QSETREFV $ 66
                    (CONS (|dispatchFunction| |IR;retractIfCan;$U;19|) $)))))
       ('T
        (QSETREFV $ 66 (CONS (|dispatchFunction| |IR;retractIfCan;$U;20|) $))))
      (COND
       ((|testBitVector| |pv$| 1)
        (QSETREFV $ 79
                  (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|) (105 . |coerce|)
              (|List| $) (110 . |prefix|) (116 . |One|) (120 . -) (125 . *)
              (131 . |outputForm|) (137 . |coerce|) (142 . =) (148 . |sum|)
              (|List| 6) (154 . |removeDuplicates!|) (159 . |retract|)
              (164 . |integral|) (|Union| 6 '"failed") (170 . |retractIfCan|)
              (175 . |Zero|) (179 . =) (|Mapping| 18 18) (185 . |map|)
              (|Mapping| 20 20) (191 . |map|) (197 . |concat|) (203 . |concat|)
              |IR;+;3$;22| (209 . |differentiate|) (|Mapping| 6 6)
              |IR;differentiate;$MF;24| (215 . |differentiate|) (221 . |map|)
              (227 . |Zero|) (231 . =) (237 . |reductum|)
              (242 . |leadingCoefficient|)
              (|Record| (|:| |coef1| $) (|:| |coef2| $)) (|Union| 85 '"failed")
              (247 . |extendedEuclidean|) (254 . |monomial|) (260 . *)
              (266 . |rem|) (|List| 10) (272 . |concat|) |IR;coerce;$Of;27|
              (278 . +) (|Mapping| 10 10 10) (284 . |reduce|) (290 . |hconcat|)
              (295 . |int|) (|Union| $ '"failed") (|PositiveInteger|)
              (|String|) (|SingleInteger|))
           '#(~= 300 |zero?| 306 |subtractIfCan| 311 |sample| 317
              |retractIfCan| 321 |retract| 326 |ratpart| 331 |notelem| 336
              |mkAnswer| 341 |logpart| 348 |latex| 353 |integral| 358 |hash|
              370 |elem?| 375 |differentiate| 380 |coerce| 392 |Zero| 402 = 406
              - 412 + 423 * 429)
           '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| 102
                                       '(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 6 10 0 51 2 10 0 0
                                         52 53 0 45 0 54 1 10 0 0 55 2 10 0 0 0
                                         56 2 45 10 0 10 57 1 13 10 0 58 2 10 0
                                         0 0 59 2 10 0 0 0 60 1 61 0 0 62 1 6 8
                                         0 63 2 6 0 0 8 64 1 0 65 0 66 0 29 0
                                         67 2 29 27 0 0 68 2 19 0 69 0 70 2 21
                                         0 71 0 72 2 19 0 0 0 73 2 21 0 0 0 74
                                         2 6 0 0 8 76 2 0 6 0 8 79 2 45 0 77 0
                                         80 0 45 0 81 2 45 27 0 0 82 1 45 0 0
                                         83 1 45 6 0 84 3 45 86 0 0 0 87 2 45 0
                                         6 44 88 2 45 0 0 0 89 2 45 0 0 0 90 2
                                         91 0 0 0 92 2 10 0 0 0 94 2 91 10 95 0
                                         96 1 10 0 52 97 1 10 0 0 98 2 0 27 0 0
                                         1 1 0 27 0 1 2 0 99 0 0 1 0 0 0 1 1 0
                                         65 0 66 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
                                         101 0 1 2 2 0 6 8 43 2 0 0 6 6 32 1 0
                                         102 0 1 1 0 27 0 28 2 1 6 0 8 79 2 0 6
                                         0 77 78 1 0 0 6 23 1 0 10 0 93 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 75 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 100
                                         0 1)))))
           '|lookupComplete|)) 
