
(/VERSIONCHECK 2) 

(DEFUN |DEFINTEF;innerint;FS2OcBU;1| (|f| |x| |a| |b| |ignor?| $)
  (PROG (#1=#:G1835 |v| |u|)
    (RETURN
     (SEQ
      (EXIT
       (SEQ
        (SEQ
         (LETT |u| (|DEFINTEF;int| |f| |x| |a| |b| |ignor?| $)
               . #2=(|DEFINTEF;innerint;FS2OcBU;1|))
         (EXIT
          (COND
           ((OR (QEQCAR |u| 0) (QEQCAR |u| 1))
            (PROGN (LETT #1# |u| . #2#) (GO #1#)))
           ('T
            (SEQ (LETT |v| (SPADCALL |f| |x| |a| |b| (QREFELT $ 12)) . #2#)
                 (EXIT
                  (COND
                   ((QEQCAR |v| 1)
                    (PROGN (LETT #1# |u| . #2#) (GO #1#))))))))))
        (EXIT (CONS 0 (SPADCALL (QCDR |v|) (QREFELT $ 13))))))
      #1# (EXIT #1#))))) 

(DEFUN |DEFINTEF;innerint;FS2OcBU;2| (|f| |x| |a| |b| |ignor?| $)
  (|DEFINTEF;int| |f| |x| |a| |b| |ignor?| $)) 

(DEFUN |DEFINTEF;innerint;FS2OcBU;3| (|f| |x| |a| |b| |ignor?| $)
  (|DEFINTEF;int| |f| |x| |a| |b| |ignor?| $)) 

(DEFUN |DEFINTEF;innerint;FS2OcBU;4| (|f| |x| |a| |b| |ignor?| $)
  (|DEFINTEF;int| |f| |x| |a| |b| |ignor?| $)) 

(DEFUN |DEFINTEF;integrate;FSbU;5| (|f| |s| $)
  (SPADCALL |f| (SPADCALL |s| (QREFELT $ 18))
            (SPADCALL (SPADCALL |s| (QREFELT $ 20)) (QREFELT $ 21))
            (SPADCALL (SPADCALL |s| (QREFELT $ 20)) (QREFELT $ 22)) 'NIL
            (QREFELT $ 16))) 

(DEFUN |DEFINTEF;integrate;FSbSU;6| (|f| |s| |str| $)
  (SPADCALL |f| (SPADCALL |s| (QREFELT $ 18))
            (SPADCALL (SPADCALL |s| (QREFELT $ 20)) (QREFELT $ 21))
            (SPADCALL (SPADCALL |s| (QREFELT $ 20)) (QREFELT $ 22))
            (SPADCALL |str| (QREFELT $ 26)) (QREFELT $ 16))) 

(DEFUN |DEFINTEF;int| (|f| |x| |a| |b| |ignor?| $)
  (PROG (|z| |k|)
    (RETURN
     (SEQ
      (COND ((SPADCALL |a| |b| (QREFELT $ 28)) (CONS 0 (|spadConstant| $ 29)))
            (#1='T
             (SEQ
              (LETT |k| (SPADCALL |x| (QREFELT $ 31)) . #2=(|DEFINTEF;int|))
              (LETT |z| (|DEFINTEF;checkForPole| |f| |x| |k| |a| |b| $) . #2#)
              (EXIT
               (COND
                ((QEQCAR |z| 1)
                 (COND (|ignor?| (|DEFINTEF;nopole| |f| |x| |k| |a| |b| $))
                       (#1# (CONS 3 "potentialPole"))))
                ((QCDR |z|) (|error| "integrate: pole in path of integration"))
                (#1# (|DEFINTEF;nopole| |f| |x| |k| |a| |b| $))))))))))) 

(DEFUN |DEFINTEF;checkForPole| (|f| |x| |k| |a| |b| $)
  (PROG (#1=#:G1880 |u| |d|)
    (RETURN
     (SEQ
      (EXIT
       (SEQ
        (SEQ
         (LETT |u|
               (|DEFINTEF;checkFor0|
                (LETT |d| (SPADCALL |f| (QREFELT $ 33))
                      . #2=(|DEFINTEF;checkForPole|))
                |k| |a| |b| $)
               . #2#)
         (EXIT
          (COND
           ((OR (QEQCAR |u| 1) (QCDR |u|))
            (PROGN (LETT #1# |u| . #2#) (GO #1#))))))
        (SEQ (LETT |u| (|DEFINTEF;checkSMP| |d| |x| |k| |a| |b| $) . #2#)
             (EXIT
              (COND
               ((OR (QEQCAR |u| 1) (QCDR |u|))
                (PROGN (LETT #1# |u| . #2#) (GO #1#))))))
        (EXIT
         (|DEFINTEF;checkSMP| (SPADCALL |f| (QREFELT $ 34)) |x| |k| |a| |b|
          $))))
      #1# (EXIT #1#))))) 

(DEFUN |DEFINTEF;checkFor0| (|p| |x| |a| |b| $)
  (PROG (#1=#:G1916 |w| |k| |z| #2=#:G1898 #3=#:G1921 #4=#:G1922 #5=#:G1895 |t|
         |v| |u|)
    (RETURN
     (SEQ
      (EXIT
       (SEQ
        (LETT |u| (|DEFINTEF;polyIfCan| |p| |x| $) . #6=(|DEFINTEF;checkFor0|))
        (EXIT
         (COND
          ((QEQCAR |u| 0) (SPADCALL (QCDR |u|) |a| |b| 'NIL (QREFELT $ 37)))
          ((QEQCAR (LETT |v| (SPADCALL |p| (QREFELT $ 40)) . #6#) 0)
           (SEQ
            (SEQ
             (EXIT
              (SEQ (LETT |t| NIL . #6#)
                   (LETT #4#
                         (PROG2
                             (LETT #5# |v| . #6#)
                             (QCDR #5#)
                           (|check-union| (QEQCAR #5# 0)
                                          (|List|
                                           (|SparseMultivariatePolynomial|
                                            (QREFELT $ 6)
                                            (|Kernel| (QREFELT $ 7))))
                                          #5#))
                         . #6#)
                   G190
                   (COND
                    ((OR (ATOM #4#) (PROGN (LETT |t| (CAR #4#) . #6#) NIL))
                     (GO G191)))
                   (SEQ
                    (LETT |w| (|DEFINTEF;checkFor0| |t| |x| |a| |b| $) . #6#)
                    (EXIT
                     (COND
                      ((OR (QEQCAR |w| 1) (QCDR |w|))
                       (PROGN
                        (LETT #2# (PROGN (LETT #3# |w| . #6#) (GO #3#)) . #6#)
                        (GO #2#))))))
                   (LETT #4# (CDR #4#) . #6#) (GO G190) G191 (EXIT NIL)))
             #2# (EXIT #2#))
            (EXIT (CONS 0 'NIL))))
          (#7='T
           (SEQ (LETT |z| (SPADCALL |p| (QREFELT $ 43)) . #6#)
                (EXIT
                 (COND ((QEQCAR |z| 1) (CONS 1 "failed"))
                       (#7#
                        (SEQ (LETT |k| (QCAR (QCDR |z|)) . #6#)
                             (COND
                              ((OR (SPADCALL |k| '|exp| (QREFELT $ 44))
                                   (OR (SPADCALL |k| '|acot| (QREFELT $ 44))
                                       (SPADCALL |k| '|cosh| (QREFELT $ 44))))
                               (EXIT (CONS 0 'NIL))))
                             (EXIT
                              (COND
                               ((SPADCALL |k| '|log| (QREFELT $ 44))
                                (SEQ
                                 (EXIT
                                  (SEQ
                                   (SEQ
                                    (LETT |w|
                                          (|DEFINTEF;moreThan| |b|
                                           (|spadConstant| $ 46) $)
                                          . #6#)
                                    (EXIT
                                     (COND
                                      ((OR (QEQCAR |w| 1) (NULL (QCDR |w|)))
                                       (PROGN
                                        (LETT #1# |w| . #6#)
                                        (GO #1#))))))
                                   (EXIT
                                    (|DEFINTEF;moreThan|
                                     (SPADCALL |a| (QREFELT $ 47))
                                     (SPADCALL (|spadConstant| $ 46)
                                               (QREFELT $ 50))
                                     $))))
                                 #1# (EXIT #1#)))
                               (#7# (CONS 1 "failed"))))))))))))))
      #3# (EXIT #3#))))) 

(DEFUN |DEFINTEF;moreThan| (|a| |b| $)
  (PROG (|u| |r|)
    (RETURN
     (SEQ (LETT |r| (SPADCALL |a| (QREFELT $ 51)) . #1=(|DEFINTEF;moreThan|))
          (EXIT
           (COND
            ((QEQCAR |r| 1) (CONS 0 (QSLESSP 0 (SPADCALL |a| (QREFELT $ 56)))))
            (#2='T
             (SEQ (LETT |u| (SPADCALL (QCDR |r|) (QREFELT $ 58)) . #1#)
                  (EXIT
                   (COND ((QEQCAR |u| 1) (CONS 1 "failed"))
                         (#2#
                          (CONS 0
                                (SPADCALL |b| (QCDR |u|)
                                          (QREFELT $ 59)))))))))))))) 

(DEFUN |DEFINTEF;checkSMP| (|p| |x| |k| |a| |b| $)
  (PROG (#1=#:G1987 |w| #2=#:G1985 #3=#:G1974 |f| |kk| |z| |n| #4=#:G1995
         #5=#:G1997 #6=#:G1946 |t| |v| #7=#:G1949 #8=#:G1996 |u|)
    (RETURN
     (SEQ
      (EXIT
       (SEQ
        (LETT |u| (|DEFINTEF;polyIfCan| |p| |k| $) . #9=(|DEFINTEF;checkSMP|))
        (EXIT
         (COND ((QEQCAR |u| 0) (CONS 0 'NIL))
               ((QEQCAR (LETT |v| (SPADCALL |p| (QREFELT $ 40)) . #9#) 0)
                (SEQ
                 (SEQ
                  (EXIT
                   (SEQ (LETT |t| NIL . #9#)
                        (LETT #8#
                              (PROG2
                                  (LETT #6# |v| . #9#)
                                  (QCDR #6#)
                                (|check-union| (QEQCAR #6# 0)
                                               (|List|
                                                (|SparseMultivariatePolynomial|
                                                 (QREFELT $ 6)
                                                 (|Kernel| (QREFELT $ 7))))
                                               #6#))
                              . #9#)
                        G190
                        (COND
                         ((OR (ATOM #8#)
                              (PROGN (LETT |t| (CAR #8#) . #9#) NIL))
                          #10=(GO G191)))
                        (SEQ
                         (LETT |w| (|DEFINTEF;checkSMP| |t| |x| |k| |a| |b| $)
                               . #9#)
                         (EXIT
                          (COND
                           ((OR (QEQCAR |w| 1) (QCDR |w|))
                            (PROGN
                             (LETT #7# (PROGN (LETT #4# |w| . #9#) (GO #4#))
                                   . #9#)
                             (GO #7#))))))
                        (LETT #8# (CDR #8#) . #9#) #11=(GO G190) G191
                        (EXIT NIL)))
                  #7# (EXIT #7#))
                 (EXIT (CONS 0 'NIL))))
               ((QEQCAR (LETT |v| (SPADCALL |p| (QREFELT $ 60)) . #9#) 0)
                (SEQ (LETT |n| (|spadConstant| $ 52) . #9#)
                     (SEQ (LETT |t| NIL . #9#)
                          (LETT #5#
                                (PROG2
                                    (LETT #6# |v| . #9#)
                                    (QCDR #6#)
                                  (|check-union| (QEQCAR #6# 0)
                                                 (|List|
                                                  (|SparseMultivariatePolynomial|
                                                   (QREFELT $ 6)
                                                   (|Kernel| (QREFELT $ 7))))
                                                 #6#))
                                . #9#)
                          G190
                          (COND
                           ((OR (ATOM #5#)
                                (PROGN (LETT |t| (CAR #5#) . #9#) NIL))
                            #10#))
                          (SEQ
                           (LETT |w|
                                 (|DEFINTEF;checkSMP| |t| |x| |k| |a| |b| $)
                                 . #9#)
                           (EXIT
                            (COND
                             ((QEQCAR |w| 1)
                              (PROGN (LETT #4# |w| . #9#) (GO #4#)))
                             ((QCDR |w|)
                              (LETT |n|
                                    (SPADCALL |n| (|spadConstant| $ 48)
                                              (QREFELT $ 61))
                                    . #9#)))))
                          (LETT #5# (CDR #5#) . #9#) #11# G191 (EXIT NIL))
                     (EXIT
                      (COND ((SPADCALL |n| (QREFELT $ 62)) (CONS 0 'NIL))
                            ((SPADCALL |n| (|spadConstant| $ 48)
                                       (QREFELT $ 63))
                             (CONS 0 'T))
                            (#12='T (CONS 1 "failed"))))))
               (#12#
                (SEQ (LETT |z| (SPADCALL |p| (QREFELT $ 43)) . #9#)
                     (EXIT
                      (COND ((QEQCAR |z| 1) (CONS 1 "failed"))
                            (#12#
                             (SEQ (LETT |kk| (QCAR (QCDR |z|)) . #9#)
                                  (EXIT
                                   (COND
                                    ((SPADCALL (SPADCALL |kk| (QREFELT $ 65))
                                               (QREFELT $ 66))
                                     (CONS 0 'NIL))
                                    (#12#
                                     (SEQ
                                      (LETT |f|
                                            (|SPADfirst|
                                             (SPADCALL |kk| (QREFELT $ 68)))
                                            . #9#)
                                      (COND
                                       ((OR
                                         (SPADCALL |kk| '|exp| (QREFELT $ 44))
                                         (OR
                                          (SPADCALL |kk| '|sin| (QREFELT $ 44))
                                          (OR
                                           (SPADCALL |kk| '|cos|
                                                     (QREFELT $ 44))
                                           (OR
                                            (SPADCALL |kk| '|sinh|
                                                      (QREFELT $ 44))
                                            (OR
                                             (SPADCALL |kk| '|cosh|
                                                       (QREFELT $ 44))
                                             (OR
                                              (SPADCALL |kk| '|tanh|
                                                        (QREFELT $ 44))
                                              (OR
                                               (SPADCALL |kk| '|sech|
                                                         (QREFELT $ 44))
                                               (OR
                                                (SPADCALL |kk| '|atan|
                                                          (QREFELT $ 44))
                                                (OR
                                                 (SPADCALL |kk| '|acot|
                                                           (QREFELT $ 44))
                                                 (SPADCALL |kk| '|asinh|
                                                           (QREFELT $
                                                                    44)))))))))))
                                        (EXIT
                                         (|DEFINTEF;checkForPole| |f| |x| |k|
                                          |a| |b| $))))
                                      (COND
                                       ((OR
                                         (SPADCALL |kk| '|asin| (QREFELT $ 44))
                                         (OR
                                          (SPADCALL |kk| '|acos|
                                                    (QREFELT $ 44))
                                          (SPADCALL |kk| '|atanh|
                                                    (QREFELT $ 44))))
                                        (EXIT
                                         (SEQ
                                          (EXIT
                                           (SEQ
                                            (SEQ
                                             (LETT |w|
                                                   (|DEFINTEF;checkForPole| |f|
                                                    |x| |k| |a| |b| $)
                                                   . #9#)
                                             (EXIT
                                              (COND
                                               ((OR (QEQCAR |w| 1) (QCDR |w|))
                                                (PROGN
                                                 (LETT #3# |w| . #9#)
                                                 (GO #3#))))))
                                            (SEQ
                                             (LETT |w|
                                                   (|DEFINTEF;posit|
                                                    (SPADCALL |f|
                                                              (|spadConstant| $
                                                                              49)
                                                              (QREFELT $ 69))
                                                    |x| |k| |a| |b| $)
                                                   . #9#)
                                             (EXIT
                                              (COND
                                               ((OR (QEQCAR |w| 1) (QCDR |w|))
                                                (PROGN
                                                 (LETT #3# |w| . #9#)
                                                 (GO #3#))))))
                                            (EXIT
                                             (|DEFINTEF;negat|
                                              (SPADCALL |f|
                                                        (|spadConstant| $ 49)
                                                        (QREFELT $ 70))
                                              |x| |k| |a| |b| $))))
                                          #3# (EXIT #3#)))))
                                      (EXIT
                                       (COND
                                        ((SPADCALL |kk| '|acosh|
                                                   (QREFELT $ 44))
                                         (SEQ
                                          (EXIT
                                           (SEQ
                                            (SEQ
                                             (LETT |w|
                                                   (|DEFINTEF;checkForPole| |f|
                                                    |x| |k| |a| |b| $)
                                                   . #9#)
                                             (EXIT
                                              (COND
                                               ((OR (QEQCAR |w| 1) (QCDR |w|))
                                                (PROGN
                                                 (LETT #2# |w| . #9#)
                                                 (GO #2#))))))
                                            (EXIT
                                             (|DEFINTEF;negat|
                                              (SPADCALL |f|
                                                        (|spadConstant| $ 49)
                                                        (QREFELT $ 69))
                                              |x| |k| |a| |b| $))))
                                          #2# (EXIT #2#)))
                                        ((SPADCALL |kk| '|log| (QREFELT $ 44))
                                         (SEQ
                                          (EXIT
                                           (SEQ
                                            (SEQ
                                             (LETT |w|
                                                   (|DEFINTEF;checkForPole| |f|
                                                    |x| |k| |a| |b| $)
                                                   . #9#)
                                             (EXIT
                                              (COND
                                               ((OR (QEQCAR |w| 1) (QCDR |w|))
                                                (PROGN
                                                 (LETT #1# |w| . #9#)
                                                 (GO #1#))))))
                                            (EXIT
                                             (|DEFINTEF;negat| |f| |x| |k| |a|
                                              |b| $))))
                                          #1# (EXIT #1#)))
                                        (#12#
                                         (CONS 1 "failed"))))))))))))))))))
      #4# (EXIT #4#))))) 

(DEFUN |DEFINTEF;posit| (|f| |x| |k| |a| |b| $)
  (PROG (#1=#:G2015 |w| #2=#:G2016 #3=#:G2008 |b2| |z| |r| |b1|)
    (RETURN
     (SEQ
      (EXIT
       (SEQ
        (LETT |z|
              (SEQ
               (LETT |r| (SPADCALL |a| (QREFELT $ 51)) . #4=(|DEFINTEF;posit|))
               (EXIT
                (COND ((QEQCAR |r| 1) (SPADCALL |f| |x| |a| (QREFELT $ 73)))
                      (#5='T
                       (SPADCALL |f| |x| (QCDR |r|) "right" (QREFELT $ 74))))))
              . #4#)
        (SEQ (LETT |b1| (QEQCAR |z| 0) . #4#)
             (EXIT
              (COND
               (|b1|
                (COND
                 ((< 0
                     (PROG2
                         (LETT #3# |z| . #4#)
                         (QCDR #3#)
                       (|check-union| (QEQCAR #3# 0) (|Integer|) #3#)))
                  (PROGN (LETT #2# (CONS 0 'T) . #4#) (GO #2#))))))))
        (LETT |z|
              (SEQ (LETT |r| (SPADCALL |b| (QREFELT $ 51)) . #4#)
                   (EXIT
                    (COND
                     ((QEQCAR |r| 1) (SPADCALL |f| |x| |b| (QREFELT $ 73)))
                     (#5#
                      (SPADCALL |f| |x| (QCDR |r|) "left" (QREFELT $ 74))))))
              . #4#)
        (SEQ (LETT |b2| (QEQCAR |z| 0) . #4#)
             (EXIT
              (COND
               (|b2|
                (COND
                 ((< 0
                     (PROG2
                         (LETT #3# |z| . #4#)
                         (QCDR #3#)
                       (|check-union| (QEQCAR #3# 0) (|Integer|) #3#)))
                  (PROGN (LETT #2# (CONS 0 'T) . #4#) (GO #2#))))))))
        (COND
         (|b1|
          (COND
           (|b2|
            (EXIT
             (SEQ
              (EXIT
               (SEQ
                (SEQ
                 (LETT |w|
                       (|DEFINTEF;checkFor0| (SPADCALL |f| (QREFELT $ 34)) |k|
                        |a| |b| $)
                       . #4#)
                 (EXIT
                  (COND
                   ((OR (QEQCAR |w| 1) (QCDR |w|))
                    (PROGN (LETT #1# (CONS 1 "failed") . #4#) (GO #1#))))))
                (EXIT (CONS 0 'NIL))))
              #1# (EXIT #1#)))))))
        (EXIT (CONS 1 "failed"))))
      #2# (EXIT #2#))))) 

(DEFUN |DEFINTEF;negat| (|f| |x| |k| |a| |b| $)
  (PROG (#1=#:G2032 |w| #2=#:G2033 #3=#:G2025 |b2| |z| |r| |b1|)
    (RETURN
     (SEQ
      (EXIT
       (SEQ
        (LETT |z|
              (SEQ
               (LETT |r| (SPADCALL |a| (QREFELT $ 51)) . #4=(|DEFINTEF;negat|))
               (EXIT
                (COND ((QEQCAR |r| 1) (SPADCALL |f| |x| |a| (QREFELT $ 73)))
                      (#5='T
                       (SPADCALL |f| |x| (QCDR |r|) "right" (QREFELT $ 74))))))
              . #4#)
        (SEQ (LETT |b1| (QEQCAR |z| 0) . #4#)
             (EXIT
              (COND
               (|b1|
                (COND
                 ((<
                   (PROG2
                       (LETT #3# |z| . #4#)
                       (QCDR #3#)
                     (|check-union| (QEQCAR #3# 0) (|Integer|) #3#))
                   0)
                  (PROGN (LETT #2# (CONS 0 'T) . #4#) (GO #2#))))))))
        (LETT |z|
              (SEQ (LETT |r| (SPADCALL |b| (QREFELT $ 51)) . #4#)
                   (EXIT
                    (COND
                     ((QEQCAR |r| 1) (SPADCALL |f| |x| |b| (QREFELT $ 73)))
                     (#5#
                      (SPADCALL |f| |x| (QCDR |r|) "left" (QREFELT $ 74))))))
              . #4#)
        (SEQ (LETT |b2| (QEQCAR |z| 0) . #4#)
             (EXIT
              (COND
               (|b2|
                (COND
                 ((<
                   (PROG2
                       (LETT #3# |z| . #4#)
                       (QCDR #3#)
                     (|check-union| (QEQCAR #3# 0) (|Integer|) #3#))
                   0)
                  (PROGN (LETT #2# (CONS 0 'T) . #4#) (GO #2#))))))))
        (COND
         (|b1|
          (COND
           (|b2|
            (EXIT
             (SEQ
              (EXIT
               (SEQ
                (SEQ
                 (LETT |w|
                       (|DEFINTEF;checkFor0| (SPADCALL |f| (QREFELT $ 34)) |k|
                        |a| |b| $)
                       . #4#)
                 (EXIT
                  (COND
                   ((OR (QEQCAR |w| 1) (QCDR |w|))
                    (PROGN (LETT #1# (CONS 1 "failed") . #4#) (GO #1#))))))
                (EXIT (CONS 0 'NIL))))
              #1# (EXIT #1#)))))))
        (EXIT (CONS 1 "failed"))))
      #2# (EXIT #2#))))) 

(DEFUN |DEFINTEF;polyIfCan| (|p| |x| $)
  (PROG (|q| |ans| #1=#:G2042 |c|)
    (RETURN
     (SEQ
      (EXIT
       (SEQ
        (LETT |q| (SPADCALL |p| |x| (QREFELT $ 76))
              . #2=(|DEFINTEF;polyIfCan|))
        (LETT |ans| (|spadConstant| $ 77) . #2#)
        (SEQ G190
             (COND
              ((NULL
                (COND
                 ((SPADCALL |q| (|spadConstant| $ 79) (QREFELT $ 80)) 'NIL)
                 ('T 'T)))
               (GO G191)))
             (SEQ
              (EXIT
               (COND
                ((SPADCALL |x|
                           (SPADCALL
                            (LETT |c|
                                  (SPADCALL (SPADCALL |q| (QREFELT $ 81))
                                            (QREFELT $ 82))
                                  . #2#)
                            (QREFELT $ 84))
                           (QREFELT $ 86))
                 (PROGN (LETT #1# (CONS 1 "failed") . #2#) (GO #1#)))
                ('T
                 (SEQ
                  (LETT |ans|
                        (SPADCALL |ans|
                                  (SPADCALL |c| (SPADCALL |q| (QREFELT $ 88))
                                            (QREFELT $ 89))
                                  (QREFELT $ 90))
                        . #2#)
                  (EXIT (LETT |q| (SPADCALL |q| (QREFELT $ 91)) . #2#)))))))
             NIL (GO G190) G191 (EXIT NIL))
        (EXIT (CONS 0 |ans|))))
      #1# (EXIT #1#))))) 

(DEFUN |DEFINTEF;nopole| (|f| |x| |k| |a| |b| $)
  (PROG (|ans| #1=#:G2064 |v| #2=#:G2065 |g| |u|)
    (RETURN
     (SEQ
      (EXIT
       (SEQ
        (LETT |u| (SPADCALL |f| |x| (QREFELT $ 94)) . #3=(|DEFINTEF;nopole|))
        (EXIT
         (COND
          ((QEQCAR |u| 0)
           (SEQ
            (LETT |v| (SPADCALL |k| (QCDR |u|) |a| |b| 'NIL (QREFELT $ 96))
                  . #3#)
            (EXIT
             (COND ((QEQCAR |v| 1) (CONS 2 #4="failed"))
                   (#5='T (CONS 0 (QCDR |v|)))))))
          (#5#
           (SEQ (LETT |ans| NIL . #3#)
                (SEQ (LETT |g| NIL . #3#) (LETT #2# (QCDR |u|) . #3#) G190
                     (COND
                      ((OR (ATOM #2#) (PROGN (LETT |g| (CAR #2#) . #3#) NIL))
                       (GO G191)))
                     (SEQ
                      (LETT |v| (SPADCALL |k| |g| |a| |b| 'NIL (QREFELT $ 96))
                            . #3#)
                      (EXIT
                       (COND
                        ((QEQCAR |v| 1)
                         (PROGN (LETT #1# (CONS 2 #4#) . #3#) (GO #1#)))
                        ('T
                         (LETT |ans|
                               (SPADCALL |ans| (LIST (QCDR |v|))
                                         (QREFELT $ 98))
                               . #3#)))))
                     (LETT #2# (CDR #2#) . #3#) (GO G190) G191 (EXIT NIL))
                (EXIT (CONS 1 |ans|))))))))
      #1# (EXIT #1#))))) 

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

(DEFUN |ElementaryFunctionDefiniteIntegration;| (|#1| |#2|)
  (PROG (|pv$| $ |dv$| DV$2 DV$1)
    (RETURN
     (PROGN
      (LETT DV$1 (|devaluate| |#1|)
            . #1=(|ElementaryFunctionDefiniteIntegration|))
      (LETT DV$2 (|devaluate| |#2|) . #1#)
      (LETT |dv$| (LIST '|ElementaryFunctionDefiniteIntegration| DV$1 DV$2)
            . #1#)
      (LETT $ (GETREFV 99) . #1#)
      (QSETREFV $ 0 |dv$|)
      (QSETREFV $ 3 (LETT |pv$| (|buildPredVector| 0 0 NIL) . #1#))
      (|haddProp| |$ConstructorCache| '|ElementaryFunctionDefiniteIntegration|
                  (LIST DV$1 DV$2) (CONS 1 $))
      (|stuffDomainSlots| $)
      (QSETREFV $ 6 |#1|)
      (QSETREFV $ 7 |#2|)
      (COND
       ((|HasCategory| |#1| '(|ConvertibleTo| (|Pattern| (|Integer|))))
        (COND
         ((|HasCategory| |#1| '(|PatternMatchable| (|Integer|)))
          (COND
           ((|HasCategory| |#2| '(|SpecialFunctionCategory|))
            (PROGN
             (QSETREFV $ 16
                       (CONS (|dispatchFunction| |DEFINTEF;innerint;FS2OcBU;1|)
                             $))))
           ('T
            (QSETREFV $ 16
                      (CONS (|dispatchFunction| |DEFINTEF;innerint;FS2OcBU;2|)
                            $)))))
         ('T
          (QSETREFV $ 16
                    (CONS (|dispatchFunction| |DEFINTEF;innerint;FS2OcBU;3|)
                          $)))))
       ('T
        (QSETREFV $ 16
                  (CONS (|dispatchFunction| |DEFINTEF;innerint;FS2OcBU;4|)
                        $))))
      $)))) 

(MAKEPROP '|ElementaryFunctionDefiniteIntegration| '|infovec|
          (LIST
           '#(NIL NIL NIL NIL NIL NIL (|local| |#1|) (|local| |#2|)
              (|Union| 7 '"failed") (|Symbol|) (|OrderedCompletion| 7)
              (|PatternMatchIntegration| 6 7) (0 . |pmintegrate|)
              (8 . |coerce|)
              (|Union| (|:| |f1| 10) (|:| |f2| 97) (|:| |fail| '"failed")
                       (|:| |pole| '"potentialPole"))
              (|Boolean|) (13 . |innerint|) (|SegmentBinding| 10)
              (22 . |variable|) (|Segment| 10) (27 . |segment|) (32 . |lo|)
              (37 . |hi|) |DEFINTEF;integrate;FSbU;5| (|String|)
              (|DefiniteIntegrationTools| 6 7) (42 . |ignore?|)
              |DEFINTEF;integrate;FSbSU;6| (47 . =) (53 . |Zero|) (|Kernel| 7)
              (57 . |kernel|) (|SparseMultivariatePolynomial| 6 (|Kernel| $))
              (62 . |denom|) (67 . |numer|) (|Union| 15 '"failed")
              (|SparseUnivariatePolynomial| 7) (72 . |checkForZero|)
              (|Union| (|List| $) '#1="failed")
              (|SparseMultivariatePolynomial| 6 30) (80 . |isTimes|)
              (|Record| (|:| |var| 30) (|:| |exponent| 87)) (|Union| 41 '#1#)
              (85 . |isExpt|) (90 . |is?|) (|Fraction| (|Integer|))
              (96 . |One|) (100 . -) (105 . |One|) (109 . |One|) (113 . -)
              (118 . |retractIfCan|) (123 . |Zero|) (127 . |Zero|)
              (131 . |Zero|) (|SingleInteger|) (135 . |whatInfinity|)
              (|Union| 45 '"failed") (140 . |retractIfCan|) (145 . <)
              (151 . |isPlus|) (156 . +) (162 . |zero?|) (167 . =)
              (|BasicOperator|) (173 . |operator|) (178 . |nullary?|)
              (|List| 7) (183 . |argument|) (188 . -) (194 . +)
              (|Union| (|Integer|) '"failed") (|ElementaryFunctionSign| 6 7)
              (200 . |sign|) (207 . |sign|) (|SparseUnivariatePolynomial| $)
              (215 . |univariate|) (221 . |Zero|)
              (|SparseUnivariatePolynomial| 39) (225 . |Zero|) (229 . =)
              (235 . |leadingCoefficient|) (240 . |coerce|)
              (|List| (|Kernel| $)) (245 . |tower|) (|List| 30)
              (250 . |member?|) (|NonNegativeInteger|) (256 . |degree|)
              (261 . |monomial|) (267 . +) (273 . |reductum|) (|Union| 7 67)
              (|FunctionSpaceIntegration| 6 7) (278 . |integrate|)
              (|Union| 10 '"failed") (284 . |computeInt|) (|List| 10)
              (293 . |concat!|))
           '#(|integrate| 299 |innerint| 312) 'NIL
           (CONS (|makeByteWordVec2| 1 'NIL)
                 (CONS '#()
                       (CONS '#()
                             (|makeByteWordVec2| 98
                                                 '(4 11 8 7 9 10 10 12 1 10 0 7
                                                   13 5 0 14 7 9 10 10 15 16 1
                                                   17 9 0 18 1 17 19 0 20 1 19
                                                   10 0 21 1 19 10 0 22 1 25 15
                                                   24 26 2 10 15 0 0 28 0 10 0
                                                   29 1 30 0 9 31 1 7 32 0 33 1
                                                   7 32 0 34 4 25 35 36 10 10
                                                   15 37 1 39 38 0 40 1 39 42 0
                                                   43 2 30 15 0 9 44 0 45 0 46
                                                   1 10 0 0 47 0 6 0 48 0 7 0
                                                   49 1 45 0 0 50 1 10 8 0 51 0
                                                   6 0 52 0 7 0 53 0 45 0 54 1
                                                   10 55 0 56 1 7 57 0 58 2 45
                                                   15 0 0 59 1 39 38 0 60 2 6 0
                                                   0 0 61 1 6 15 0 62 2 6 15 0
                                                   0 63 1 30 64 0 65 1 64 15 0
                                                   66 1 30 67 0 68 2 7 0 0 0 69
                                                   2 7 0 0 0 70 3 72 71 7 9 10
                                                   73 4 72 71 7 9 7 24 74 2 39
                                                   75 0 30 76 0 36 0 77 0 78 0
                                                   79 2 78 15 0 0 80 1 78 39 0
                                                   81 1 7 0 32 82 1 7 83 0 84 2
                                                   85 15 30 0 86 1 78 87 0 88 2
                                                   36 0 7 87 89 2 36 0 0 0 90 1
                                                   78 0 0 91 2 93 92 7 9 94 5
                                                   25 95 30 7 10 10 15 96 2 97
                                                   0 0 0 98 2 0 14 7 17 23 3 0
                                                   14 7 17 24 27 5 0 14 7 9 10
                                                   10 15 16)))))
           '|lookupComplete|)) 
