
(/VERSIONCHECK 2) 

(DEFUN |LAPLACE;laplace;F2SF;1| (|f| |t| |s| $)
  (|LAPLACE;locallaplace| (SPADCALL |f| |t| (QREFELT $ 17)) |t|
      (SPADCALL |t| (QREFELT $ 18)) |s| (SPADCALL |s| (QREFELT $ 18))
      $)) 

(DEFUN |LAPLACE;algebraic?| (|f| |t| $)
  (PROG (|l| #0=#:G1861 #1=#:G1862 |m| |k| #2=#:G1863 #3=#:G1860
             #4=#:G1858)
    (RETURN
      (SEQ (EXIT (SEQ (LETT |l|
                            (SPADCALL (SPADCALL |f| (QREFELT $ 21)) |t|
                                (QREFELT $ 24))
                            . #5=(|LAPLACE;algebraic?|))
                      (LETT |m|
                            (SPADCALL (ELT $ 25)
                                (PROGN
                                  (LETT #0# NIL . #5#)
                                  (SEQ (LETT |k| NIL . #5#)
                                       (LETT #1# |l| . #5#) G190
                                       (COND
                                         ((OR (ATOM #1#)
                                           (PROGN
                                             (LETT |k| (CAR #1#) . #5#)
                                             NIL))
                                          #6=(GO G191)))
                                       (SEQ
                                        (EXIT
                                         (LETT #0#
                                          (CONS
                                           (SPADCALL |k|
                                            (QREFELT $ 27))
                                           #0#) . #5#)))
                                       (LETT #1# (CDR #1#) . #5#)
                                       #7=(GO G190) G191
                                       (EXIT (NREVERSE0 #0#))))
                                0 (QREFELT $ 30)) . #5#)
                      (SEQ (EXIT (SEQ (LETT |k| NIL . #5#)
                                      (LETT #2# |l| . #5#) G190
                                      (COND
                                        ((OR (ATOM #2#)
                                          (PROGN
                                            (LETT |k| (CAR #2#) . #5#)
                                            NIL))
                                         #6#))
                                      (SEQ
                                       (EXIT
                                        (COND
                                          ((EQL
                                            (SPADCALL |k|
                                             (QREFELT $ 27))
                                            |m|)
                                           (COND
                                             ((SPADCALL
                                               (SPADCALL |k|
                                                (QREFELT $ 31))
                                               (QREFELT $ 11)
                                               (QREFELT $ 33))
                                              (PROGN
                                                (LETT #4#
                                                 (PROGN
                                                   (LETT #3# 'T . #5#)
                                                   (GO #3#)) . #5#)
                                                (GO #4#))))))))
                                      (LETT #2# (CDR #2#) . #5#) #7#
                                      G191 (EXIT NIL)))
                           #4# (EXIT #4#))
                      (EXIT 'NIL)))
           #3# (EXIT #3#))))) 

(DEFUN |LAPLACE;dvlap| (|l| |x| $)
  (PROG (|l1| |l2| |l3| |v| |e|)
    (RETURN
      (SEQ (LETT |l1| (|SPADfirst| |l|) . #0=(|LAPLACE;dvlap|))
           (LETT |l2| (SPADCALL |l| (QREFELT $ 35)) . #0#)
           (LETT |v|
                 (SPADCALL
                     (LETT |l3| (SPADCALL |l| (QREFELT $ 36)) . #0#)
                     (QREFELT $ 37)) . #0#)
           (EXIT (COND
                   ((EQUAL |x| |v|)
                    (SPADCALL
                        (SPADCALL (QREFELT $ 15)
                            (SPADCALL |l2| |l1| (QREFELT $ 38)) |l2|
                            |l3| (QREFELT $ 39))
                        (QREFELT $ 40)))
                   ('T
                    (SEQ (LETT |e|
                               (SPADCALL
                                   (SPADCALL
                                    (SPADCALL |l3| |l2| (QREFELT $ 38))
                                    (QREFELT $ 40))
                                   (QREFELT $ 41)) . #0#)
                         (EXIT (|LAPLACE;locallaplace|
                                   (SPADCALL
                                    (SPADCALL
                                     (SPADCALL |e| |l1| (QREFELT $ 38))
                                     |x| (QREFELT $ 42))
                                    |e| (QREFELT $ 43))
                                   (SPADCALL |l2| (QREFELT $ 37)) |l2|
                                   |v| |l3| $)))))))))) 

(DEFUN |LAPLACE;isLinear| (|f| |t| $)
  (PROG (|ff| |d| #0=#:G1881 |b| |c|)
    (RETURN
      (SEQ (EXIT (SEQ (LETT |ff|
                            (SPADCALL |f| (SPADCALL |t| (QREFELT $ 44))
                                (QREFELT $ 47))
                            . #1=(|LAPLACE;isLinear|))
                      (SEQ (LETT |d|
                                 (SPADCALL
                                     (SPADCALL |ff| (QREFELT $ 50))
                                     (QREFELT $ 52)) . #1#)
                           (EXIT (COND
                                   ((OR (QEQCAR |d| 1)
                                     (< 1
                                      (SPADCALL
                                       (SPADCALL |ff| (QREFELT $ 55))
                                       (QREFELT $ 58))))
                                    (PROGN
                                      (LETT #0#
                                       (CONS 1 "failed") . #1#)
                                      (GO #0#))))))
                      (COND
                        ((SPADCALL
                             (LETT |b|
                                   (SPADCALL
                                    (SPADCALL
                                     (SPADCALL |ff| (QREFELT $ 55)) 0
                                     (QREFELT $ 59))
                                    (QCDR |d|) (QREFELT $ 43)) . #1#)
                             |t| (QREFELT $ 60))
                         (COND
                           ((SPADCALL
                                (LETT |c|
                                      (SPADCALL
                                       (SPADCALL
                                        (SPADCALL |ff| (QREFELT $ 55))
                                        1 (QREFELT $ 59))
                                       (QCDR |d|) (QREFELT $ 43)) . #1#)
                                |t| (QREFELT $ 60))
                            (EXIT (CONS 0 (CONS |b| |c|)))))))
                      (EXIT (CONS 1 "failed"))))
           #0# (EXIT #0#))))) 

(DEFUN |LAPLACE;atn| (|f| |t| $)
  (PROG (|v| #0=#:G1893 |w| |vv| #1=#:G1901 #2=#:G1917 #3=#:G1902 |u|
             |g| #4=#:G1909 #5=#:G1918 |rec| #6=#:G1885 |r| |d| |c|
             #7=#:G1914)
    (RETURN
      (SEQ (EXIT (SEQ (COND
                        ((QEQCAR (LETT |v|
                                       (SPADCALL |f| (QREFELT $ 63))
                                       . #8=(|LAPLACE;atn|))
                                 0)
                         (SEQ (LETT |w|
                                    (PROG2 (LETT #0# |v| . #8#)
                                     (QCDR #0#)
                                      (|check-union| (QEQCAR #0# 0)
                                       (|Record|
                                        (|:| |var|
                                         (|Kernel| (QREFELT $ 7)))
                                        (|:| |exponent| (|Integer|)))
                                       #0#)) . #8#)
                              (EXIT (COND
                                      ((< 0 (QCDR |w|))
                                       (SEQ
                                        (EXIT
                                         (SEQ
                                          (LETT |vv|
                                           (SPADCALL (QCAR |w|)
                                            (QREFELT $ 67)) . #8#)
                                          (EXIT
                                           (COND
                                             ((QEQCAR |vv| 0)
                                              (COND
                                                ((EQUAL (QCDR |vv|)
                                                  |t|)
                                                 (PROGN
                                                   (LETT #3#
                                                    (PROGN
                                                      (LETT #2#
                                                       (CONS 0
                                                        (CONS
                                                         (|spadConstant|
                                                          $ 54)
                                                         (PROG1
                                                          (LETT #1#
                                                           (QCDR |w|) . #8#)
                                                           (|check-subtype|
                                                            (> #1# 0)
                                                            '(|PositiveInteger|)
                                                            #1#)))) . #8#)
                                                      (GO #2#)) . #8#)
                                                   (GO #3#)))))))))
                                        #3# (EXIT #3#))))))))
                      (EXIT (COND
                              ((QEQCAR (LETT |u|
                                        (SPADCALL |f| (QREFELT $ 69)) . #8#)
                                       0)
                               (SEQ (LETT |c|
                                     (|spadConstant| $ 54) . #8#)
                                    (LETT |d| 0 . #8#)
                                    (SEQ (LETT |g| NIL . #8#)
                                     (LETT #5#
                                      (PROG2 (LETT #4# |u| . #8#)
                                       (QCDR #4#)
                                        (|check-union| (QEQCAR #4# 0)
                                         (|List| (QREFELT $ 7)) #4#)) . #8#)
                                     G190
                                     (COND
                                       ((OR (ATOM #5#)
                                         (PROGN
                                           (LETT |g| (CAR #5#) . #8#)
                                           NIL))
                                        (GO G191)))
                                     (SEQ
                                      (EXIT
                                       (COND
                                         ((QEQCAR
                                           (LETT |rec|
                                            (|LAPLACE;atn| |g| |t| $) . #8#)
                                           0)
                                          (SEQ
                                           (LETT |r|
                                            (PROG2
                                             (LETT #6# |rec| . #8#)
                                             (QCDR #6#)
                                              (|check-union|
                                               (QEQCAR #6# 0)
                                               (|Record|
                                                (|:| |coef|
                                                 (QREFELT $ 7))
                                                (|:| |deg|
                                                 (|PositiveInteger|)))
                                               #6#)) . #8#)
                                           (LETT |c|
                                            (SPADCALL |c| (QCAR |r|)
                                             (QREFELT $ 38)) . #8#)
                                           (EXIT
                                            (LETT |d|
                                             (+ |d| (QCDR |r|)) . #8#))))
                                         ('T
                                          (LETT |c|
                                           (SPADCALL |c| |g|
                                            (QREFELT $ 38)) . #8#)))))
                                     (LETT #5# (CDR #5#) . #8#)
                                     (GO G190) G191 (EXIT NIL))
                                    (EXIT
                                     (COND
                                       ((ZEROP |d|) (CONS 1 "failed"))
                                       ('T
                                        (CONS 0
                                         (CONS |c|
                                          (PROG1 (LETT #7# |d| . #8#)
                                            (|check-subtype| (> #7# 0)
                                             '(|PositiveInteger|) #7#)))))))))
                              ('T (CONS 1 "failed"))))))
           #2# (EXIT #2#))))) 

(DEFUN |LAPLACE;aexp| (|f| |t| $)
  (PROG (|u| |g| #0=#:G1929 #1=#:G1953 |c0| |c1| |c| |v| #2=#:G1943 |w|
             |r| #3=#:G1921 |rec| #4=#:G1952 #5=#:G1946)
    (RETURN
      (SEQ (EXIT (COND
                   ((SPADCALL |f| (SPADCALL "exp" (QREFELT $ 10))
                        (QREFELT $ 70))
                    (SEQ (LETT |v|
                               (|LAPLACE;isLinear|
                                   (|SPADfirst|
                                    (SPADCALL
                                     (SPADCALL |f| (QREFELT $ 71))
                                     (QREFELT $ 72)))
                                   |t| $)
                               . #6=(|LAPLACE;aexp|))
                         (EXIT (COND
                                 ((QEQCAR |v| 1) (CONS 1 "failed"))
                                 ('T
                                  (CONS 0
                                        (VECTOR (|spadConstant| $ 54)
                                         (QCDR (QCDR |v|))
                                         (QCAR (QCDR |v|)))))))))
                   ((QEQCAR (LETT |u|
                                  (SPADCALL |f| (QREFELT $ 69)) . #6#)
                            0)
                    (SEQ (LETT |c| (|spadConstant| $ 54) . #6#)
                         (LETT |c1|
                               (LETT |c0| (|spadConstant| $ 65) . #6#) . #6#)
                         (SEQ (LETT |g| NIL . #6#)
                              (LETT #1#
                                    (PROG2 (LETT #0# |u| . #6#)
                                     (QCDR #0#)
                                      (|check-union| (QEQCAR #0# 0)
                                       (|List| (QREFELT $ 7)) #0#)) . #6#)
                              G190
                              (COND
                                ((OR (ATOM #1#)
                                     (PROGN
                                       (LETT |g| (CAR #1#) . #6#)
                                       NIL))
                                 (GO G191)))
                              (SEQ (EXIT
                                    (COND
                                      ((QEQCAR
                                        (LETT |r|
                                         (|LAPLACE;aexp| |g| |t| $) . #6#)
                                        0)
                                       (SEQ
                                        (LETT |rec|
                                         (PROG2 (LETT #3# |r| . #6#)
                                          (QCDR #3#)
                                           (|check-union|
                                            (QEQCAR #3# 0)
                                            (|Record|
                                             (|:| |coef| (QREFELT $ 7))
                                             (|:| |coef1|
                                              (QREFELT $ 7))
                                             (|:| |coef0|
                                              (QREFELT $ 7)))
                                            #3#)) . #6#)
                                        (LETT |c|
                                         (SPADCALL |c| (QVELT |rec| 0)
                                          (QREFELT $ 38)) . #6#)
                                        (LETT |c0|
                                         (SPADCALL |c0| (QVELT |rec| 2)
                                          (QREFELT $ 73)) . #6#)
                                        (EXIT
                                         (LETT |c1|
                                          (SPADCALL |c1|
                                           (QVELT |rec| 1)
                                           (QREFELT $ 73)) . #6#))))
                                      ('T
                                       (LETT |c|
                                        (SPADCALL |c| |g|
                                         (QREFELT $ 38)) . #6#)))))
                              (LETT #1# (CDR #1#) . #6#) (GO G190) G191
                              (EXIT NIL))
                         (COND
                           ((SPADCALL |c0| (QREFELT $ 74))
                            (COND
                              ((SPADCALL |c1| (QREFELT $ 74))
                               (EXIT (CONS 1 "failed"))))))
                         (EXIT (CONS 0 (VECTOR |c| |c1| |c0|)))))
                   ('T
                    (SEQ (COND
                           ((QEQCAR (LETT |v|
                                     (SPADCALL |f| (QREFELT $ 77)) . #6#)
                                    0)
                            (SEQ (LETT |w|
                                       (PROG2 (LETT #2# |v| . #6#)
                                        (QCDR #2#)
                                         (|check-union| (QEQCAR #2# 0)
                                          (|Record|
                                           (|:| |val| (QREFELT $ 7))
                                           (|:| |exponent| (|Integer|)))
                                          #2#)) . #6#)
                                 (EXIT (COND
                                         ((NULL (EQL (QCDR |w|) 1))
                                          (SEQ
                                           (EXIT
                                            (COND
                                              ((QEQCAR
                                                (LETT |r|
                                                 (|LAPLACE;aexp|
                                                  (QCAR |w|) |t| $) . #6#)
                                                0)
                                               (PROGN
                                                 (LETT #5#
                                                  (SEQ
                                                   (LETT |rec|
                                                    (PROG2
                                                     (LETT #3#
                                                      |r| . #6#)
                                                     (QCDR #3#)
                                                      (|check-union|
                                                       (QEQCAR #3# 0)
                                                       (|Record|
                                                        (|:| |coef|
                                                         (QREFELT $ 7))
                                                        (|:| |coef1|
                                                         (QREFELT $ 7))
                                                        (|:| |coef0|
                                                         (QREFELT $ 7)))
                                                       #3#)) . #6#)
                                                   (EXIT
                                                    (PROGN
                                                      (LETT #4#
                                                       (CONS 0
                                                        (VECTOR
                                                         (SPADCALL
                                                          (QVELT |rec|
                                                           0)
                                                          (QCDR |w|)
                                                          (QREFELT $
                                                           79))
                                                         (SPADCALL
                                                          (QCDR |w|)
                                                          (QVELT |rec|
                                                           1)
                                                          (QREFELT $
                                                           80))
                                                         (SPADCALL
                                                          (QCDR |w|)
                                                          (QVELT |rec|
                                                           2)
                                                          (QREFELT $
                                                           80)))) . #6#)
                                                      (GO #4#)))) . #6#)
                                                 (GO #5#)))))
                                           #5# (EXIT #5#))))))))
                         (EXIT (CONS 1 "failed"))))))
           #4# (EXIT #4#))))) 

(DEFUN |LAPLACE;mkPlus| (|f| $)
  (PROG (|u| |d| #0=#:G1964 |p| #1=#:G1965)
    (RETURN
      (SEQ (LETT |u|
                 (SPADCALL (SPADCALL |f| (QREFELT $ 82))
                     (QREFELT $ 84))
                 . #2=(|LAPLACE;mkPlus|))
           (EXIT (COND
                   ((QEQCAR |u| 1) (CONS 1 "failed"))
                   ('T
                    (SEQ (LETT |d| (SPADCALL |f| (QREFELT $ 85)) . #2#)
                         (EXIT (CONS 0
                                     (PROGN
                                       (LETT #0# NIL . #2#)
                                       (SEQ (LETT |p| NIL . #2#)
                                        (LETT #1# (QCDR |u|) . #2#)
                                        G190
                                        (COND
                                          ((OR (ATOM #1#)
                                            (PROGN
                                              (LETT |p|
                                               (CAR #1#) . #2#)
                                              NIL))
                                           (GO G191)))
                                        (SEQ
                                         (EXIT
                                          (LETT #0#
                                           (CONS
                                            (SPADCALL |p| |d|
                                             (QREFELT $ 86))
                                            #0#) . #2#)))
                                        (LETT #1# (CDR #1#) . #2#)
                                        (GO G190) G191
                                        (EXIT (NREVERSE0 #0#)))))))))))))) 

(DEFUN |LAPLACE;tdenom| (|f| |t| $)
  (COND
    ((QEQCAR (SPADCALL (SPADCALL |f| (QREFELT $ 85))
                 (SPADCALL |t| (QREFELT $ 82)) (QREFELT $ 88))
             1)
     (CONS 1 "failed"))
    ('T (CONS 0 (SPADCALL |t| |f| (QREFELT $ 38)))))) 

(DEFUN |LAPLACE;intlaplace| (|f| |ss| |g| |v| |vv| $)
  (PROG (|i| |u| #0=#:G1984 |l|)
    (RETURN
      (SEQ (COND
             ((OR (SPADCALL |g| (QREFELT $ 15) (QREFELT $ 89))
                  (QEQCAR (LETT |i| (SPADCALL |g| |v| (QREFELT $ 92))
                                . #1=(|LAPLACE;intlaplace|))
                          1))
              (CONS 1 "failed"))
             ('T
              (SEQ (LETT |u|
                         (SPADCALL
                             (PROG2 (LETT #0# |i| . #1#) (QCDR #0#)
                               (|check-union| (QEQCAR #0# 0)
                                   (QREFELT $ 7) #0#))
                             (SPADCALL (SPADCALL |vv| (QREFELT $ 94))
                                 (SPADCALL (QREFELT $ 95))
                                 (QREFELT $ 97))
                             (QREFELT $ 102)) . #1#)
                   (EXIT (COND
                           ((QEQCAR |u| 0)
                            (SEQ (LETT |l|
                                       (SPADCALL
                                        (PROG2 (LETT #0# |i| . #1#)
                                         (QCDR #0#)
                                          (|check-union| (QEQCAR #0# 0)
                                           (QREFELT $ 7) #0#))
                                        (SPADCALL
                                         (SPADCALL |vv| (QREFELT $ 94))
                                         (SPADCALL |ss| (QREFELT $ 94))
                                         (QREFELT $ 97))
                                        (QREFELT $ 102)) . #1#)
                                 (EXIT (COND
                                         ((QEQCAR |l| 0)
                                          (SPADCALL
                                           (SPADCALL (QCDR |u|)
                                            (QCDR |l|) (QREFELT $ 103))
                                           (QREFELT $ 104)))
                                         (#2='T (CONS 1 "failed"))))))
                           (#2# (CONS 1 "failed"))))))))))) 

(DEFUN |LAPLACE;lapkernel| (|f| |t| |tt| |ss| $)
  (PROG (|k| |arg| |fint| |s| |a| |op|)
    (RETURN
      (SEQ (LETT |k| (SPADCALL |f| (QREFELT $ 106))
                 . #0=(|LAPLACE;lapkernel|))
           (EXIT (COND
                   ((OR (QEQCAR |k| 1)
                        (NULL (LETT |arg|
                                    (SPADCALL (QCDR |k|)
                                     (QREFELT $ 72)) . #0#)))
                    (CONS 1 "failed"))
                   ((SPADCALL
                        (LETT |op|
                              (SPADCALL (QCDR |k|) (QREFELT $ 31)) . #0#)
                        (SPADCALL "%diff" (QREFELT $ 10))
                        (QREFELT $ 107))
                    (COND
                      ((OR (NULL (EQL (LENGTH |arg|) 3))
                           (NULL (SPADCALL
                                     (SPADCALL |arg| 3 (QREFELT $ 108))
                                     |t| (QREFELT $ 70))))
                       (CONS 1 "failed"))
                      ('T
                       (SEQ (LETT |fint|
                                  (SPADCALL
                                      (SPADCALL |arg| 1
                                       (QREFELT $ 108))
                                      (SPADCALL |arg| 2
                                       (QREFELT $ 108))
                                      |tt| (QREFELT $ 109)) . #0#)
                            (LETT |s|
                                  (SPADCALL
                                      (SPADCALL
                                       (SPADCALL
                                        (SPADCALL |ss| (QREFELT $ 21))
                                        1 (QREFELT $ 110))
                                       (QREFELT $ 31))
                                      (QREFELT $ 111)) . #0#)
                            (EXIT (CONS 0
                                        (SPADCALL
                                         (SPADCALL |ss|
                                          (|LAPLACE;locallaplace|
                                           |fint| |t| |tt| |s| |ss| $)
                                          (QREFELT $ 38))
                                         (SPADCALL |fint|
                                          (SPADCALL |tt|
                                           (|spadConstant| $ 65)
                                           (QREFELT $ 114))
                                          (QREFELT $ 116))
                                         (QREFELT $ 117))))))))
                   ((NULL (NULL (CDR |arg|))) (CONS 1 "failed"))
                   ('T
                    (COND
                      ((SPADCALL |t|
                           (SPADCALL
                               (LETT |a|
                                     (SPADCALL (|SPADfirst| |arg|) |tt|
                                      (QREFELT $ 43)) . #0#)
                               (QREFELT $ 119))
                           (QREFELT $ 120))
                       (CONS 1 "failed"))
                      ((SPADCALL (LETT |op|
                                       (SPADCALL (QCDR |k|)
                                        (QREFELT $ 31)) . #0#)
                                 (SPADCALL "Si" (QREFELT $ 10))
                                 (QREFELT $ 107))
                       (CONS 0
                             (SPADCALL
                                 (SPADCALL
                                     (SPADCALL |a| |ss| (QREFELT $ 43))
                                     (QREFELT $ 121))
                                 |ss| (QREFELT $ 43))))
                      ((SPADCALL |op| (SPADCALL "Ci" (QREFELT $ 10))
                           (QREFELT $ 107))
                       (CONS 0
                             (SPADCALL
                                 (SPADCALL
                                     (SPADCALL
                                      (SPADCALL
                                       (SPADCALL |ss| 2
                                        (QREFELT $ 123))
                                       (SPADCALL |a| 2 (QREFELT $ 123))
                                       (QREFELT $ 73))
                                      (SPADCALL |a| 2 (QREFELT $ 123))
                                      (QREFELT $ 43))
                                     (QREFELT $ 124))
                                 (SPADCALL 2 |ss| (QREFELT $ 125))
                                 (QREFELT $ 43))))
                      ((SPADCALL |op| (SPADCALL "Ei" (QREFELT $ 10))
                           (QREFELT $ 107))
                       (CONS 0
                             (SPADCALL
                                 (SPADCALL
                                     (SPADCALL
                                      (SPADCALL |ss| |a|
                                       (QREFELT $ 73))
                                      |a| (QREFELT $ 43))
                                     (QREFELT $ 124))
                                 |ss| (QREFELT $ 43))))
                      ('T
                       (SEQ (COND
                              ((|HasCategory| (QREFELT $ 7)
                                   '(|SpecialFunctionCategory|))
                               (COND
                                 ((SPADCALL |op|
                                      (SPADCALL "log" (QREFELT $ 10))
                                      (QREFELT $ 107))
                                  (EXIT (CONS 0
                                         (SPADCALL
                                          (SPADCALL
                                           (SPADCALL
                                            (SPADCALL
                                             (|spadConstant| $ 54)
                                             (QREFELT $ 126))
                                            (SPADCALL |a|
                                             (QREFELT $ 124))
                                            (QREFELT $ 117))
                                           (SPADCALL |ss|
                                            (QREFELT $ 124))
                                           (QREFELT $ 117))
                                          |ss| (QREFELT $ 43))))))))
                            (EXIT (CONS 1 "failed")))))))))))) 

(DEFUN |LAPLACE;locallaplace| (|f| |t| |tt| |s| |ss| $)
  (PROG (|vvv| |u| |g| #0=#:G2032 #1=#:G2057 #2=#:G2036 #3=#:G2034
               #4=#:G2035 |rec| |v| #5=#:G2042 |vv| |la| |w| #6=#:G2047
               |ww| |x|)
    (RETURN
      (SEQ (COND
             ((SPADCALL |f| (QREFELT $ 74)) (|spadConstant| $ 65))
             ((SPADCALL |f| (|spadConstant| $ 54) (QREFELT $ 112))
              (SPADCALL |ss| (QREFELT $ 127)))
             ('T
              (SEQ (LETT |x| (|LAPLACE;tdenom| |f| |tt| $)
                         . #7=(|LAPLACE;locallaplace|))
                   (EXIT (COND
                           ((QEQCAR |x| 0)
                            (SEQ (LETT |g|
                                       (|LAPLACE;locallaplace|
                                        (QCDR |x|) |t| |tt|
                                        (LETT |vv|
                                         (SPADCALL (QREFELT $ 128)) . #7#)
                                        (LETT |vvv|
                                         (SPADCALL |vv| (QREFELT $ 18)) . #7#)
                                        $) . #7#)
                                 (LETT |x|
                                       (|LAPLACE;intlaplace| |f| |ss|
                                        |g| |vv| |vvv| $) . #7#)
                                 (EXIT (COND
                                         ((QEQCAR |x| 0) (QCDR |x|))
                                         ('T
                                          (SPADCALL (QREFELT $ 15) |f|
                                           |tt| |ss| (QREFELT $ 39)))))))
                           ((QEQCAR (LETT |u|
                                     (|LAPLACE;mkPlus| |f| $) . #7#)
                                    0)
                            (PROGN
                              (LETT #4# NIL . #7#)
                              (SEQ (LETT |g| NIL . #7#)
                                   (LETT #1#
                                    (PROG2 (LETT #0# |u| . #7#)
                                     (QCDR #0#)
                                      (|check-union| (QEQCAR #0# 0)
                                       (|List| (QREFELT $ 7)) #0#)) . #7#)
                                   G190
                                   (COND
                                     ((OR (ATOM #1#)
                                       (PROGN
                                         (LETT |g| (CAR #1#) . #7#)
                                         NIL))
                                      (GO G191)))
                                   (SEQ
                                    (EXIT
                                     (PROGN
                                       (LETT #2#
                                        (|LAPLACE;locallaplace| |g| |t|
                                         |tt| |s| |ss| $) . #7#)
                                       (COND
                                         (#4#
                                          (LETT #3#
                                           (SPADCALL #3# #2#
                                            (QREFELT $ 73)) . #7#))
                                         ('T
                                          (PROGN
                                            (LETT #3# #2# . #7#)
                                            (LETT #4# 'T . #7#)))))))
                                   (LETT #1# (CDR #1#) . #7#) (GO G190)
                                   G191 (EXIT NIL))
                              (COND
                                (#4# #3#)
                                ('T (|spadConstant| $ 65)))))
                           ((NULL (SPADCALL
                                      (QCAR
                                       (LETT |rec|
                                        (SPADCALL |f| |t|
                                         (QREFELT $ 131)) . #7#))
                                      (|spadConstant| $ 54)
                                      (QREFELT $ 112)))
                            (SPADCALL (QCAR |rec|)
                                (|LAPLACE;locallaplace| (QCDR |rec|)
                                    |t| |tt| |s| |ss| $)
                                (QREFELT $ 38)))
                           ('T
                            (COND
                              ((QEQCAR (LETT |v|
                                        (|LAPLACE;atn| |f| |t| $) . #7#)
                                       0)
                               (SEQ (LETT |vv|
                                     (PROG2 (LETT #5# |v| . #7#)
                                      (QCDR #5#)
                                       (|check-union| (QEQCAR #5# 0)
                                        (|Record|
                                         (|:| |coef| (QREFELT $ 7))
                                         (|:| |deg|
                                          (|PositiveInteger|)))
                                        #5#)) . #7#)
                                    (EXIT
                                     (COND
                                       ((SPADCALL
                                         (LETT |la|
                                          (|LAPLACE;locallaplace|
                                           (QCAR |vv|) |t| |tt| |s|
                                           |ss| $) . #7#)
                                         (QREFELT $ 15) (QREFELT $ 89))
                                        (SPADCALL (QREFELT $ 15) |f|
                                         |tt| |ss| (QREFELT $ 39)))
                                       ('T
                                        (SPADCALL (EXPT -1 (QCDR |vv|))
                                         (SPADCALL |la| |s| (QCDR |vv|)
                                          (QREFELT $ 132))
                                         (QREFELT $ 80)))))))
                              ((QEQCAR (LETT |w|
                                        (|LAPLACE;aexp| |f| |t| $) . #7#)
                                       0)
                               (SEQ (LETT |ww|
                                     (PROG2 (LETT #6# |w| . #7#)
                                      (QCDR #6#)
                                       (|check-union| (QEQCAR #6# 0)
                                        (|Record|
                                         (|:| |coef| (QREFELT $ 7))
                                         (|:| |coef1| (QREFELT $ 7))
                                         (|:| |coef0| (QREFELT $ 7)))
                                        #6#)) . #7#)
                                    (EXIT
                                     (SPADCALL
                                      (SPADCALL (QVELT |ww| 2)
                                       (QREFELT $ 41))
                                      (|LAPLACE;locallaplace|
                                       (QVELT |ww| 0) |t| |tt| |s|
                                       (SPADCALL |ss| (QVELT |ww| 1)
                                        (QREFELT $ 117))
                                       $)
                                      (QREFELT $ 38)))))
                              ('T
                               (SEQ (LETT |x|
                                     (|LAPLACE;lapkernel| |f| |t| |tt|
                                      |ss| $) . #7#)
                                    (EXIT
                                     (COND
                                       ((QEQCAR |x| 0) (QCDR |x|))
                                       ('T
                                        (SPADCALL (QREFELT $ 15) |f|
                                         |tt| |ss| (QREFELT $ 39)))))))))))))))))) 

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

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

(MAKEPROP '|LaplaceTransform| '|infovec|
    (LIST '#(NIL NIL NIL NIL NIL NIL (|local| |#1|) (|local| |#2|)
             (|String|) (|Symbol|) (0 . |coerce|) 'ALGOP
             (|NonNegativeInteger|) (|BasicOperator|) (5 . |operator|)
             '|oplap| (|TrigonometricManipulations| 6 7)
             (11 . |complexElementary|) (17 . |coerce|)
             |LAPLACE;laplace;F2SF;1| (|List| 46) (22 . |kernels|)
             (|List| 26) (|IntegrationTools| 6 7) (27 . |varselect|)
             (33 . |max|) (|Kernel| 7) (39 . |height|)
             (|Mapping| 12 12 12) (|List| 12) (44 . |reduce|)
             (51 . |operator|) (|Boolean|) (56 . |has?|) (|List| 7)
             (62 . |second|) (67 . |third|) (72 . |retract|) (77 . *)
             (83 . |elt|) (91 . -) (96 . |exp|) (101 . |differentiate|)
             (107 . /) (113 . |kernel|)
             (|Fraction| (|SparseUnivariatePolynomial| $)) (|Kernel| $)
             (118 . |univariate|) (|SparseUnivariatePolynomial| 7)
             (|Fraction| 48) (124 . |denom|) (|Union| 7 '"failed")
             (129 . |retractIfCan|) (134 . |One|) (138 . |One|)
             (142 . |numer|) (147 . |One|) (151 . |One|)
             (155 . |degree|) (160 . |coefficient|) (166 . |freeOf?|)
             (|Record| (|:| |var| 46) (|:| |exponent| 78))
             (|Union| 61 '"failed") (172 . |isExpt|) (177 . |Zero|)
             (181 . |Zero|) (|Union| 9 '"failed") (185 . |symbolIfCan|)
             (|Union| (|List| $) '"failed") (190 . |isTimes|)
             (195 . |is?|) (201 . |retract|) (206 . |argument|)
             (211 . +) (217 . |zero?|)
             (|Record| (|:| |val| $) (|:| |exponent| 78))
             (|Union| 75 '"failed") (222 . |isPower|) (|Integer|)
             (227 . **) (233 . *) (|SparseMultivariatePolynomial| 6 46)
             (239 . |numer|) (|SparseMultivariatePolynomial| 6 26)
             (244 . |isPlus|) (249 . |denom|) (254 . /)
             (|Union| $ '"failed") (260 . |exquo|) (266 . |is?|)
             (|Union| 7 34) (|FunctionSpaceIntegration| 6 7)
             (272 . |integrate|) (|OrderedCompletion| 7)
             (278 . |coerce|) (283 . |plusInfinity|) (|Equation| 93)
             (287 . |equation|) (|Union| 93 '"failed")
             (|Record| (|:| |leftHandLimit| 98)
                 (|:| |rightHandLimit| 98))
             (|Union| 93 99 '"failed") (|PowerSeriesLimitPackage| 6 7)
             (293 . |limit|) (299 . -) (305 . |retractIfCan|)
             (|Union| 46 '"failed") (310 . |retractIfCan|)
             (315 . |is?|) (321 . |elt|) (327 . |eval|) (334 . |elt|)
             (340 . |name|) (345 . =) (|Equation| 7) (351 . =)
             (|Equation| $) (357 . |eval|) (363 . -) (|List| 9)
             (369 . |variables|) (374 . |member?|) (380 . |atan|)
             (|PositiveInteger|) (385 . **) (391 . |log|) (396 . *)
             (402 . |digamma|) (407 . |inv|) (412 . |new|)
             (|Record| (|:| |const| 7) (|:| |nconst| 7))
             (|PatternMatchIntegration| 6 7) (416 . |splitConstant|)
             (422 . |differentiate|) (|None|) (429 . |setProperty|))
          '#(|laplace| 436) 'NIL
          (CONS (|makeByteWordVec2| 1 'NIL)
                (CONS '#()
                      (CONS '#()
                            (|makeByteWordVec2| 134
                                '(1 9 0 8 10 2 13 0 9 12 14 2 16 7 7 9
                                  17 1 7 0 9 18 1 7 20 0 21 2 23 22 22
                                  9 24 2 12 0 0 0 25 1 26 12 0 27 3 29
                                  12 28 0 12 30 1 26 13 0 31 2 13 32 0
                                  9 33 1 34 7 0 35 1 34 7 0 36 1 7 9 0
                                  37 2 7 0 0 0 38 4 7 0 13 0 0 0 39 1 7
                                  0 0 40 1 7 0 0 41 2 7 0 0 9 42 2 7 0
                                  0 0 43 1 26 0 9 44 2 7 45 0 46 47 1
                                  49 48 0 50 1 48 51 0 52 0 6 0 53 0 7
                                  0 54 1 49 48 0 55 0 49 0 56 0 48 0 57
                                  1 48 12 0 58 2 48 7 0 12 59 2 7 32 0
                                  9 60 1 7 62 0 63 0 6 0 64 0 7 0 65 1
                                  26 66 0 67 1 7 68 0 69 2 7 32 0 9 70
                                  1 7 46 0 71 1 26 34 0 72 2 7 0 0 0 73
                                  1 7 32 0 74 1 7 76 0 77 2 7 0 0 78 79
                                  2 7 0 78 0 80 1 7 81 0 82 1 83 68 0
                                  84 1 7 81 0 85 2 7 0 81 81 86 2 83 87
                                  0 0 88 2 7 32 0 13 89 2 91 90 7 9 92
                                  1 93 0 7 94 0 93 0 95 2 96 0 93 93 97
                                  2 101 100 7 96 102 2 93 0 0 0 103 1
                                  93 51 0 104 1 7 105 0 106 2 13 32 0 9
                                  107 2 34 7 0 78 108 3 7 0 0 0 0 109 2
                                  22 26 0 78 110 1 13 9 0 111 2 7 32 0
                                  0 112 2 113 0 7 7 114 2 7 0 0 115 116
                                  2 7 0 0 0 117 1 7 118 0 119 2 118 32
                                  9 0 120 1 7 0 0 121 2 7 0 0 122 123 1
                                  7 0 0 124 2 7 0 122 0 125 1 7 0 0 126
                                  1 7 0 0 127 0 9 0 128 2 130 129 7 9
                                  131 3 7 0 0 9 12 132 3 13 0 0 9 133
                                  134 3 0 7 7 9 9 19)))))
          '|lookupComplete|)) 
