
(/VERSIONCHECK 2) 

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

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

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

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

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

(DEFUN |DEFINTEF;checkSMP| (|p| |x| |k| |a| |b| $)
  (PROG (|u| #0=#:G2005 #1=#:G1962 |v| |t| #2=#:G1959 #3=#:G2006
             #4=#:G2004 |n| |z| |kk| |f| #5=#:G1983 #6=#:G1994 |w|
             #7=#:G1996)
    (RETURN
      (SEQ (EXIT (SEQ (LETT |u| (|DEFINTEF;polyIfCan| |p| |k| $)
                            . #8=(|DEFINTEF;checkSMP|))
                      (EXIT (COND
                              ((QEQCAR |u| 0) (CONS 0 'NIL))
                              ((QEQCAR (LETT |v|
                                        (SPADCALL |p| (QREFELT $ 40)) . #8#)
                                       0)
                               (SEQ (SEQ
                                     (EXIT
                                      (SEQ (LETT |t| NIL . #8#)
                                       (LETT #0#
                                        (PROG2 (LETT #2# |v| . #8#)
                                         (QCDR #2#)
                                          (|check-union| (QEQCAR #2# 0)
                                           (|List|
                                            (|SparseMultivariatePolynomial|
                                             (QREFELT $ 6)
                                             (|Kernel| (QREFELT $ 7))))
                                           #2#)) . #8#)
                                       G190
                                       (COND
                                         ((OR (ATOM #0#)
                                           (PROGN
                                             (LETT |t| (CAR #0#) . #8#)
                                             NIL))
                                          #9=(GO G191)))
                                       (SEQ
                                        (LETT |w|
                                         (|DEFINTEF;checkSMP| |t| |x|
                                          |k| |a| |b| $) . #8#)
                                        (EXIT
                                         (COND
                                           ((OR (QEQCAR |w| 1)
                                             (QCDR |w|))
                                            (PROGN
                                              (LETT #1#
                                               (PROGN
                                                 (LETT #4# |w| . #8#)
                                                 (GO #4#)) . #8#)
                                              (GO #1#))))))
                                       (LETT #0# (CDR #0#) . #8#)
                                       #10=(GO G190) G191 (EXIT NIL)))
                                     #1# (EXIT #1#))
                                    (EXIT (CONS 0 'NIL))))
                              ((QEQCAR (LETT |v|
                                        (SPADCALL |p| (QREFELT $ 61)) . #8#)
                                       0)
                               (SEQ (LETT |n|
                                     (|spadConstant| $ 53) . #8#)
                                    (SEQ (LETT |t| NIL . #8#)
                                     (LETT #3#
                                      (PROG2 (LETT #2# |v| . #8#)
                                       (QCDR #2#)
                                        (|check-union| (QEQCAR #2# 0)
                                         (|List|
                                          (|SparseMultivariatePolynomial|
                                           (QREFELT $ 6)
                                           (|Kernel| (QREFELT $ 7))))
                                         #2#)) . #8#)
                                     G190
                                     (COND
                                       ((OR (ATOM #3#)
                                         (PROGN
                                           (LETT |t| (CAR #3#) . #8#)
                                           NIL))
                                        #9#))
                                     (SEQ
                                      (LETT |w|
                                       (|DEFINTEF;checkSMP| |t| |x| |k|
                                        |a| |b| $) . #8#)
                                      (EXIT
                                       (COND
                                         ((QEQCAR |w| 1)
                                          (PROGN
                                            (LETT #4# |w| . #8#)
                                            (GO #4#)))
                                         ((QCDR |w|)
                                          (LETT |n|
                                           (SPADCALL |n|
                                            (|spadConstant| $ 49)
                                            (QREFELT $ 62)) . #8#)))))
                                     (LETT #3# (CDR #3#) . #8#) #10#
                                     G191 (EXIT NIL))
                                    (EXIT
                                     (COND
                                       ((SPADCALL |n| (QREFELT $ 63))
                                        (CONS 0 'NIL))
                                       ((SPADCALL |n|
                                         (|spadConstant| $ 49)
                                         (QREFELT $ 64))
                                        (CONS 0 'T))
                                       ('T (CONS 1 "failed"))))))
                              ('T
                               (SEQ (LETT |z|
                                     (SPADCALL |p| (QREFELT $ 43)) . #8#)
                                    (EXIT
                                     (COND
                                       ((QEQCAR |z| 1)
                                        (CONS 1 "failed"))
                                       ('T
                                        (SEQ
                                         (LETT |kk|
                                          (QCAR (QCDR |z|)) . #8#)
                                         (EXIT
                                          (COND
                                            ((SPADCALL
                                              (SPADCALL |kk|
                                               (QREFELT $ 66))
                                              (QREFELT $ 67))
                                             (CONS 0 'NIL))
                                            ('T
                                             (SEQ
                                              (LETT |f|
                                               (|SPADfirst|
                                                (SPADCALL |kk|
                                                 (QREFELT $ 69))) . #8#)
                                              (COND
                                                ((OR
                                                  (SPADCALL |kk|
                                                   (SPADCALL "exp"
                                                    (QREFELT $ 44))
                                                   (QREFELT $ 45))
                                                  (OR
                                                   (SPADCALL |kk|
                                                    (SPADCALL "sin"
                                                     (QREFELT $ 44))
                                                    (QREFELT $ 45))
                                                   (OR
                                                    (SPADCALL |kk|
                                                     (SPADCALL "cos"
                                                      (QREFELT $ 44))
                                                     (QREFELT $ 45))
                                                    (OR
                                                     (SPADCALL |kk|
                                                      (SPADCALL "sinh"
                                                       (QREFELT $ 44))
                                                      (QREFELT $ 45))
                                                     (OR
                                                      (SPADCALL |kk|
                                                       (SPADCALL "cosh"
                                                        (QREFELT $ 44))
                                                       (QREFELT $ 45))
                                                      (OR
                                                       (SPADCALL |kk|
                                                        (SPADCALL
                                                         "tanh"
                                                         (QREFELT $ 44))
                                                        (QREFELT $ 45))
                                                       (OR
                                                        (SPADCALL |kk|
                                                         (SPADCALL
                                                          "sech"
                                                          (QREFELT $
                                                           44))
                                                         (QREFELT $ 45))
                                                        (OR
                                                         (SPADCALL |kk|
                                                          (SPADCALL
                                                           "atan"
                                                           (QREFELT $
                                                            44))
                                                          (QREFELT $
                                                           45))
                                                         (OR
                                                          (SPADCALL
                                                           |kk|
                                                           (SPADCALL
                                                            "acot"
                                                            (QREFELT $
                                                             44))
                                                           (QREFELT $
                                                            45))
                                                          (SPADCALL
                                                           |kk|
                                                           (SPADCALL
                                                            "asinh"
                                                            (QREFELT $
                                                             44))
                                                           (QREFELT $
                                                            45)))))))))))
                                                 (EXIT
                                                  (|DEFINTEF;checkForPole|
                                                   |f| |x| |k| |a| |b|
                                                   $))))
                                              (COND
                                                ((OR
                                                  (SPADCALL |kk|
                                                   (SPADCALL "asin"
                                                    (QREFELT $ 44))
                                                   (QREFELT $ 45))
                                                  (OR
                                                   (SPADCALL |kk|
                                                    (SPADCALL "acos"
                                                     (QREFELT $ 44))
                                                    (QREFELT $ 45))
                                                   (SPADCALL |kk|
                                                    (SPADCALL "atanh"
                                                     (QREFELT $ 44))
                                                    (QREFELT $ 45))))
                                                 (EXIT
                                                  (SEQ
                                                   (EXIT
                                                    (SEQ
                                                     (SEQ
                                                      (LETT |w|
                                                       (|DEFINTEF;checkForPole|
                                                        |f| |x| |k| |a|
                                                        |b| $) . #8#)
                                                      (EXIT
                                                       (COND
                                                         ((OR
                                                           (QEQCAR |w|
                                                            1)
                                                           (QCDR |w|))
                                                          (PROGN
                                                            (LETT #5#
                                                             |w| . #8#)
                                                            (GO #5#))))))
                                                     (SEQ
                                                      (LETT |w|
                                                       (|DEFINTEF;posit|
                                                        (SPADCALL |f|
                                                         (|spadConstant|
                                                          $ 50)
                                                         (QREFELT $ 70))
                                                        |x| |k| |a| |b|
                                                        $) . #8#)
                                                      (EXIT
                                                       (COND
                                                         ((OR
                                                           (QEQCAR |w|
                                                            1)
                                                           (QCDR |w|))
                                                          (PROGN
                                                            (LETT #5#
                                                             |w| . #8#)
                                                            (GO #5#))))))
                                                     (EXIT
                                                      (|DEFINTEF;negat|
                                                       (SPADCALL |f|
                                                        (|spadConstant|
                                                         $ 50)
                                                        (QREFELT $ 71))
                                                       |x| |k| |a| |b|
                                                       $))))
                                                   #5# (EXIT #5#)))))
                                              (EXIT
                                               (COND
                                                 ((SPADCALL |kk|
                                                   (SPADCALL "acosh"
                                                    (QREFELT $ 44))
                                                   (QREFELT $ 45))
                                                  (SEQ
                                                   (EXIT
                                                    (SEQ
                                                     (SEQ
                                                      (LETT |w|
                                                       (|DEFINTEF;checkForPole|
                                                        |f| |x| |k| |a|
                                                        |b| $) . #8#)
                                                      (EXIT
                                                       (COND
                                                         ((OR
                                                           (QEQCAR |w|
                                                            1)
                                                           (QCDR |w|))
                                                          (PROGN
                                                            (LETT #6#
                                                             |w| . #8#)
                                                            (GO #6#))))))
                                                     (EXIT
                                                      (|DEFINTEF;negat|
                                                       (SPADCALL |f|
                                                        (|spadConstant|
                                                         $ 50)
                                                        (QREFELT $ 70))
                                                       |x| |k| |a| |b|
                                                       $))))
                                                   #6# (EXIT #6#)))
                                                 ((SPADCALL |kk|
                                                   (SPADCALL "log"
                                                    (QREFELT $ 44))
                                                   (QREFELT $ 45))
                                                  (SEQ
                                                   (EXIT
                                                    (SEQ
                                                     (SEQ
                                                      (LETT |w|
                                                       (|DEFINTEF;checkForPole|
                                                        |f| |x| |k| |a|
                                                        |b| $) . #8#)
                                                      (EXIT
                                                       (COND
                                                         ((OR
                                                           (QEQCAR |w|
                                                            1)
                                                           (QCDR |w|))
                                                          (PROGN
                                                            (LETT #7#
                                                             |w| . #8#)
                                                            (GO #7#))))))
                                                     (EXIT
                                                      (|DEFINTEF;negat|
                                                       |f| |x| |k| |a|
                                                       |b| $))))
                                                   #7# (EXIT #7#)))
                                                 ('T (CONS 1 "failed"))))))))))))))))))
           #4# (EXIT #4#))))) 

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

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

(DEFUN |DEFINTEF;polyIfCan| (|p| |x| $)
  (PROG (|c| #0=#:G2051 |ans| |q|)
    (RETURN
      (SEQ (EXIT (SEQ (LETT |q| (SPADCALL |p| |x| (QREFELT $ 77))
                            . #1=(|DEFINTEF;polyIfCan|))
                      (LETT |ans| (|spadConstant| $ 78) . #1#)
                      (SEQ G190
                           (COND
                             ((NULL (COND
                                      ((SPADCALL |q|
                                        (|spadConstant| $ 80)
                                        (QREFELT $ 81))
                                       'NIL)
                                      ('T 'T)))
                              (GO G191)))
                           (SEQ (EXIT (COND
                                        ((SPADCALL |x|
                                          (SPADCALL
                                           (LETT |c|
                                            (SPADCALL
                                             (SPADCALL |q|
                                              (QREFELT $ 82))
                                             (QREFELT $ 83)) . #1#)
                                           (QREFELT $ 85))
                                          (QREFELT $ 87))
                                         (PROGN
                                           (LETT #0#
                                            (CONS 1 "failed") . #1#)
                                           (GO #0#)))
                                        ('T
                                         (SEQ
                                          (LETT |ans|
                                           (SPADCALL |ans|
                                            (SPADCALL |c|
                                             (SPADCALL |q|
                                              (QREFELT $ 89))
                                             (QREFELT $ 90))
                                            (QREFELT $ 91)) . #1#)
                                          (EXIT
                                           (LETT |q|
                                            (SPADCALL |q|
                                             (QREFELT $ 92)) . #1#)))))))
                           NIL (GO G190) G191 (EXIT NIL))
                      (EXIT (CONS 0 |ans|))))
           #0# (EXIT #0#))))) 

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

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

(DEFUN |ElementaryFunctionDefiniteIntegration;| (|#1| |#2|)
  (PROG (DV$1 DV$2 |dv$| $ |pv$|)
    (RETURN
      (PROGN
        (LETT DV$1 (|devaluate| |#1|)
              . #0=(|ElementaryFunctionDefiniteIntegration|))
        (LETT DV$2 (|devaluate| |#2|) . #0#)
        (LETT |dv$|
              (LIST '|ElementaryFunctionDefiniteIntegration| DV$1 DV$2) . #0#)
        (LETT $ (GETREFV 100) . #0#)
        (QSETREFV $ 0 |dv$|)
        (QSETREFV $ 3 (LETT |pv$| (|buildPredVector| 0 0 NIL) . #0#))
        (|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| 98)
                      (|:| |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| $) '"failed")
             (|SparseMultivariatePolynomial| 6 30) (80 . |isTimes|)
             (|Record| (|:| |var| 30) (|:| |exponent| 88))
             (|Union| 41 '"failed") (85 . |isExpt|) (90 . |coerce|)
             (95 . |is?|) (|Fraction| (|Integer|)) (101 . |One|)
             (105 . -) (110 . |One|) (114 . |One|) (118 . -)
             (123 . |retractIfCan|) (128 . |Zero|) (132 . |Zero|)
             (136 . |Zero|) (|SingleInteger|) (140 . |whatInfinity|)
             (|Union| 46 '"failed") (145 . |retractIfCan|) (150 . <)
             (156 . |isPlus|) (161 . +) (167 . |zero?|) (172 . =)
             (|BasicOperator|) (178 . |operator|) (183 . |nullary?|)
             (|List| 7) (188 . |argument|) (193 . -) (199 . +)
             (|Union| (|Integer|) '"failed")
             (|ElementaryFunctionSign| 6 7) (205 . |sign|)
             (212 . |sign|) (|SparseUnivariatePolynomial| $)
             (220 . |univariate|) (226 . |Zero|)
             (|SparseUnivariatePolynomial| 39) (230 . |Zero|) (234 . =)
             (240 . |leadingCoefficient|) (245 . |coerce|)
             (|List| (|Kernel| $)) (250 . |tower|) (|List| 30)
             (255 . |member?|) (|NonNegativeInteger|) (261 . |degree|)
             (266 . |monomial|) (272 . +) (278 . |reductum|)
             (|Union| 7 68) (|FunctionSpaceIntegration| 6 7)
             (283 . |integrate|) (|Union| 10 '"failed")
             (289 . |computeInt|) (|List| 10) (298 . |concat!|))
          '#(|integrate| 304 |innerint| 317) 'NIL
          (CONS (|makeByteWordVec2| 1 'NIL)
                (CONS '#()
                      (CONS '#()
                            (|makeByteWordVec2| 99
                                '(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 1 9 0 24 44 2 30 15 0 9 45
                                  0 46 0 47 1 10 0 0 48 0 6 0 49 0 7 0
                                  50 1 46 0 0 51 1 10 8 0 52 0 6 0 53 0
                                  7 0 54 0 46 0 55 1 10 56 0 57 1 7 58
                                  0 59 2 46 15 0 0 60 1 39 38 0 61 2 6
                                  0 0 0 62 1 6 15 0 63 2 6 15 0 0 64 1
                                  30 65 0 66 1 65 15 0 67 1 30 68 0 69
                                  2 7 0 0 0 70 2 7 0 0 0 71 3 73 72 7 9
                                  10 74 4 73 72 7 9 7 24 75 2 39 76 0
                                  30 77 0 36 0 78 0 79 0 80 2 79 15 0 0
                                  81 1 79 39 0 82 1 7 0 32 83 1 7 84 0
                                  85 2 86 15 30 0 87 1 79 88 0 89 2 36
                                  0 7 88 90 2 36 0 0 0 91 1 79 0 0 92 2
                                  94 93 7 9 95 5 25 96 30 7 10 10 15 97
                                  2 98 0 0 0 99 2 0 14 7 17 23 3 0 14 7
                                  17 24 27 5 0 14 7 9 10 10 15 16)))))
          '|lookupComplete|)) 
