
(/VERSIONCHECK 2) 

(DEFUN |INVLAPLA;inverseLaplace;F2SU;1| (|expr| |ivar| |ovar| $)
  (|INVLAPLA;ilt| |expr| |ivar| |ovar| $)) 

(DEFUN |INVLAPLA;freeOf?| (|p| |v| $)
  (PROG (|c| #0=#:G1833 #1=#:G1831 #2=#:G1829 #3=#:G1830)
    (RETURN
      (SEQ (PROGN
             (LETT #3# NIL . #4=(|INVLAPLA;freeOf?|))
             (SEQ (LETT |c| NIL . #4#)
                  (LETT #0# (SPADCALL |p| (QREFELT $ 13)) . #4#) G190
                  (COND
                    ((OR (ATOM #0#)
                         (PROGN (LETT |c| (CAR #0#) . #4#) NIL))
                     (GO G191)))
                  (SEQ (EXIT (PROGN
                               (LETT #1#
                                     (SPADCALL |c| |v| (QREFELT $ 15)) . #4#)
                               (COND
                                 (#3# (LETT #2#
                                       (COND (#2# #1#) ('T 'NIL)) . #4#))
                                 ('T
                                  (PROGN
                                    (LETT #2# #1# . #4#)
                                    (LETT #3# 'T . #4#)))))))
                  (LETT #0# (CDR #0#) . #4#) (GO G190) G191 (EXIT NIL))
             (COND (#3# #2#) ('T 'T))))))) 

(DEFUN |INVLAPLA;ilt| (|expr| |var| |t| $)
  (PROG (|r|)
    (RETURN
      (SEQ (COND
             ((SPADCALL |expr| (|spadConstant| $ 17) (QREFELT $ 18))
              (CONS 0 (|spadConstant| $ 17)))
             ('T
              (SEQ (LETT |r|
                         (SPADCALL |expr|
                             (SPADCALL |var| (QREFELT $ 20))
                             (QREFELT $ 23))
                         |INVLAPLA;ilt|)
                   (COND
                     ((NULL (SPADCALL
                                (SPADCALL (SPADCALL |r| (QREFELT $ 25))
                                    (SPADCALL |r| (QREFELT $ 26))
                                    (QREFELT $ 27))
                                (|spadConstant| $ 28) (QREFELT $ 29)))
                      (EXIT (CONS 1 "failed"))))
                   (COND
                     ((|INVLAPLA;freeOf?| (SPADCALL |r| (QREFELT $ 25))
                          |var| $)
                      (COND
                        ((NULL (|INVLAPLA;freeOf?|
                                   (SPADCALL |r| (QREFELT $ 26)) |var|
                                   $))
                         (EXIT (CONS 1 "failed")))))
                     ('T (EXIT (CONS 1 "failed"))))
                   (EXIT (CONS 0
                               (|INVLAPLA;ilt1| |r|
                                   (SPADCALL |t| (QREFELT $ 30)) $)))))))))) 

(DEFUN |INVLAPLA;ilt1| (|r| |t| $)
  (PROG (|rsplit|)
    (RETURN
      (SEQ (COND
             ((SPADCALL |r| (|spadConstant| $ 32) (QREFELT $ 33))
              (|spadConstant| $ 17))
             ('T
              (SEQ (LETT |rsplit|
                         (SPADCALL |r| (ELT $ 34) (QREFELT $ 37))
                         |INVLAPLA;ilt1|)
                   (EXIT (SPADCALL
                             (SPADCALL
                                 (SPADCALL |t|
                                     (|INVLAPLA;ilt1|
                                      (QVELT |rsplit| 0) |t| $)
                                     (QREFELT $ 38))
                                 (QREFELT $ 39))
                             (|INVLAPLA;iltsqfr| (QVELT |rsplit| 1) |t|
                                 $)
                             (QREFELT $ 40)))))))))) 

(DEFUN |INVLAPLA;iltsqfr| (|r| |t| $)
  (PROG (|p| |q| #0=#:G1863 |qq| #1=#:G1864 |ql| #2=#:G1855 |nl| |b|
             #3=#:G1866 |a| #4=#:G1865 #5=#:G1859 #6=#:G1857
             #7=#:G1858)
    (RETURN
      (SEQ (COND
             ((SPADCALL |r| (|spadConstant| $ 32) (QREFELT $ 33))
              (|spadConstant| $ 17))
             ('T
              (SEQ (LETT |p| (SPADCALL |r| (QREFELT $ 25))
                         . #8=(|INVLAPLA;iltsqfr|))
                   (LETT |q| (SPADCALL |r| (QREFELT $ 26)) . #8#)
                   (LETT |ql|
                         (PROGN
                           (LETT #0# NIL . #8#)
                           (SEQ (LETT |qq| NIL . #8#)
                                (LETT #1#
                                      (SPADCALL
                                       (SPADCALL |q| (QREFELT $ 42))
                                       (QREFELT $ 46)) . #8#)
                                G190
                                (COND
                                  ((OR (ATOM #1#)
                                    (PROGN
                                      (LETT |qq| (CAR #1#) . #8#)
                                      NIL))
                                   #9=(GO G191)))
                                (SEQ (EXIT
                                      (LETT #0#
                                       (CONS (QCAR |qq|) #0#) . #8#)))
                                (LETT #1# (CDR #1#) . #8#)
                                #10=(GO G190) G191
                                (EXIT (NREVERSE0 #0#)))) . #8#)
                   (EXIT (COND
                           ((EQL (LENGTH |ql|) 1)
                            (|INVLAPLA;iltirred| |p| |q| |t| $))
                           ('T
                            (SEQ (LETT |nl|
                                       (PROG2
                                        (LETT #2#
                                         (SPADCALL |ql| |p|
                                          (QREFELT $ 50)) . #8#)
                                        (QCDR #2#)
                                         (|check-union| (QEQCAR #2# 0)
                                          (|List|
                                           (|SparseUnivariatePolynomial|
                                            (QREFELT $ 7)))
                                          #2#)) . #8#)
                                 (EXIT (PROGN
                                         (LETT #7# NIL . #8#)
                                         (SEQ (LETT |b| NIL . #8#)
                                          (LETT #3# |ql| . #8#)
                                          (LETT |a| NIL . #8#)
                                          (LETT #4# |nl| . #8#) G190
                                          (COND
                                            ((OR (ATOM #4#)
                                              (PROGN
                                                (LETT |a|
                                                 (CAR #4#) . #8#)
                                                NIL)
                                              (ATOM #3#)
                                              (PROGN
                                                (LETT |b|
                                                 (CAR #3#) . #8#)
                                                NIL))
                                             #9#))
                                          (SEQ
                                           (EXIT
                                            (PROGN
                                              (LETT #5#
                                               (|INVLAPLA;iltirred| |a|
                                                |b| |t| $) . #8#)
                                              (COND
                                                (#7#
                                                 (LETT #6#
                                                  (SPADCALL #6# #5#
                                                   (QREFELT $ 40)) . #8#))
                                                ('T
                                                 (PROGN
                                                   (LETT #6# #5# . #8#)
                                                   (LETT #7# 'T . #8#)))))))
                                          (LETT #4#
                                           (PROG1 (CDR #4#)
                                             (LETT #3# (CDR #3#) . #8#)) . #8#)
                                          #10# G191 (EXIT NIL))
                                         (COND
                                           (#7# #6#)
                                           ('T (|spadConstant| $ 17)))))))))))))))) 

(DEFUN |INVLAPLA;iltirred| (|p| |q| |t| $)
  (PROG (|cp| |a| |c| |e| |b| |d| |alpha| |roots| |q1| |root|
              #0=#:G1878 #1=#:G1873 #2=#:G1871 #3=#:G1872)
    (RETURN
      (SEQ (COND
             ((EQL (SPADCALL |q| (QREFELT $ 52)) 1)
              (SEQ (LETT |cp| (SPADCALL |p| 0 (QREFELT $ 53))
                         . #4=(|INVLAPLA;iltirred|))
                   (LETT |c| (SPADCALL |q| 0 (QREFELT $ 53)) . #4#)
                   (EXIT (COND
                           ((SPADCALL |c| (|spadConstant| $ 17)
                                      (QREFELT $ 18))
                            |cp|)
                           ('T
                            (SPADCALL |cp|
                                (SPADCALL
                                    (SPADCALL
                                     (SPADCALL |c| |t| (QREFELT $ 38))
                                     (QREFELT $ 39))
                                    (QREFELT $ 54))
                                (QREFELT $ 38)))))))
             ((EQL (SPADCALL |q| (QREFELT $ 52)) 2)
              (SEQ (LETT |a| (SPADCALL |p| 1 (QREFELT $ 53)) . #4#)
                   (LETT |b| (SPADCALL |p| 0 (QREFELT $ 53)) . #4#)
                   (LETT |c|
                         (SPADCALL
                             (SPADCALL (SPADCALL 1 2 (QREFELT $ 61))
                                 (QREFELT $ 62))
                             (SPADCALL |q| 1 (QREFELT $ 53))
                             (QREFELT $ 63)) . #4#)
                   (LETT |d| (SPADCALL |q| 0 (QREFELT $ 53)) . #4#)
                   (LETT |e|
                         (SPADCALL (SPADCALL |c| |t| (QREFELT $ 38))
                             (QREFELT $ 54)) . #4#)
                   (LETT |b|
                         (SPADCALL |b|
                             (SPADCALL |a| |c| (QREFELT $ 38))
                             (QREFELT $ 40)) . #4#)
                   (LETT |d|
                         (SPADCALL |d| (SPADCALL |c| 2 (QREFELT $ 65))
                             (QREFELT $ 66)) . #4#)
                   (EXIT (COND
                           ((SPADCALL (|spadConstant| $ 17) |d|
                                (QREFELT $ 67))
                            (SEQ (LETT |alpha|
                                       (SPADCALL |d| (QREFELT $ 68)) . #4#)
                                 (EXIT (SPADCALL |e|
                                        (SPADCALL
                                         (SPADCALL |a|
                                          (SPADCALL
                                           (SPADCALL |t| |alpha|
                                            (QREFELT $ 38))
                                           (QREFELT $ 69))
                                          (QREFELT $ 38))
                                         (SPADCALL
                                          (SPADCALL |b|
                                           (SPADCALL
                                            (SPADCALL |t| |alpha|
                                             (QREFELT $ 38))
                                            (QREFELT $ 70))
                                           (QREFELT $ 38))
                                          |alpha| (QREFELT $ 71))
                                         (QREFELT $ 40))
                                        (QREFELT $ 38)))))
                           ('T
                            (SEQ (LETT |alpha|
                                       (SPADCALL
                                        (SPADCALL |d| (QREFELT $ 39))
                                        (QREFELT $ 68)) . #4#)
                                 (EXIT (SPADCALL |e|
                                        (SPADCALL
                                         (SPADCALL |a|
                                          (SPADCALL
                                           (SPADCALL |t| |alpha|
                                            (QREFELT $ 38))
                                           (QREFELT $ 72))
                                          (QREFELT $ 38))
                                         (SPADCALL
                                          (SPADCALL |b|
                                           (SPADCALL
                                            (SPADCALL |t| |alpha|
                                             (QREFELT $ 38))
                                            (QREFELT $ 73))
                                           (QREFELT $ 38))
                                          |alpha| (QREFELT $ 71))
                                         (QREFELT $ 40))
                                        (QREFELT $ 38)))))))))
             ('T
              (SEQ (LETT |roots| (SPADCALL |q| (QREFELT $ 75)) . #4#)
                   (LETT |q1| (SPADCALL |q| (QREFELT $ 34)) . #4#)
                   (EXIT (PROGN
                           (LETT #3# NIL . #4#)
                           (SEQ (LETT |root| NIL . #4#)
                                (LETT #0# |roots| . #4#) G190
                                (COND
                                  ((OR (ATOM #0#)
                                    (PROGN
                                      (LETT |root| (CAR #0#) . #4#)
                                      NIL))
                                   (GO G191)))
                                (SEQ (EXIT
                                      (PROGN
                                        (LETT #1#
                                         (SPADCALL
                                          (SPADCALL
                                           (SPADCALL |p| |root|
                                            (QREFELT $ 76))
                                           (SPADCALL |q1| |root|
                                            (QREFELT $ 76))
                                           (QREFELT $ 71))
                                          (SPADCALL
                                           (SPADCALL |root| |t|
                                            (QREFELT $ 38))
                                           (QREFELT $ 54))
                                          (QREFELT $ 38)) . #4#)
                                        (COND
                                          (#3#
                                           (LETT #2#
                                            (SPADCALL #2# #1#
                                             (QREFELT $ 40)) . #4#))
                                          ('T
                                           (PROGN
                                             (LETT #2# #1# . #4#)
                                             (LETT #3# 'T . #4#)))))))
                                (LETT #0# (CDR #0#) . #4#) (GO G190)
                                G191 (EXIT NIL))
                           (COND (#3# #2#) ('T (|spadConstant| $ 17)))))))))))) 

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

(DEFUN |InverseLaplaceTransform;| (|#1| |#2|)
  (PROG (DV$1 DV$2 |dv$| $ |pv$|)
    (RETURN
      (PROGN
        (LETT DV$1 (|devaluate| |#1|) . #0=(|InverseLaplaceTransform|))
        (LETT DV$2 (|devaluate| |#2|) . #0#)
        (LETT |dv$| (LIST '|InverseLaplaceTransform| DV$1 DV$2) . #0#)
        (LETT $ (GETREFV 77) . #0#)
        (QSETREFV $ 0 |dv$|)
        (QSETREFV $ 3 (LETT |pv$| (|buildPredVector| 0 0 NIL) . #0#))
        (|haddProp| |$ConstructorCache| '|InverseLaplaceTransform|
            (LIST DV$1 DV$2) (CONS 1 $))
        (|stuffDomainSlots| $)
        (QSETREFV $ 6 |#1|)
        (QSETREFV $ 7 |#2|)
        (QSETREFV $ 31
            (|TranscendentalHermiteIntegration| |#2|
                (|SparseUnivariatePolynomial| |#2|)))
        $)))) 

(MAKEPROP '|InverseLaplaceTransform| '|infovec|
    (LIST '#(NIL NIL NIL NIL NIL NIL (|local| |#1|) (|local| |#2|)
             (|Union| 7 '"failed") (|Symbol|)
             |INVLAPLA;inverseLaplace;F2SU;1| (|List| 7)
             (|SparseUnivariatePolynomial| 7) (0 . |coefficients|)
             (|Boolean|) (5 . |freeOf?|) (11 . |Zero|) (15 . |Zero|)
             (19 . =) (|Kernel| 7) (25 . |kernel|) (|Fraction| 74)
             (|Kernel| $) (30 . |univariate|) (|Fraction| 12)
             (36 . |numer|) (41 . |denom|) (46 . |quo|) (52 . |Zero|)
             (56 . =) (62 . |coerce|) '|hintpac| (67 . |Zero|) (71 . =)
             (77 . |differentiate|)
             (|Record| (|:| |answer| 24) (|:| |logpart| 24)
                 (|:| |specpart| 24) (|:| |polypart| 12))
             (|Mapping| 12 12) (82 . |HermiteIntegrate|) (88 . *)
             (94 . -) (99 . +) (|Factored| $) (105 . |squareFree|)
             (|Record| (|:| |factor| 12) (|:| |exponent| 59))
             (|List| 43) (|Factored| 12) (110 . |factors|)
             (115 . |One|) (|Union| 49 '"failed") (|List| $)
             (119 . |multiEuclidean|) (|NonNegativeInteger|)
             (125 . |degree|) (130 . |coefficient|) (136 . |exp|)
             (141 . |One|) (|SparseMultivariatePolynomial| 6 19)
             (145 . |One|) (149 . |One|) (|Integer|) (|Fraction| 59)
             (153 . /) (159 . -) (164 . *) (|PositiveInteger|)
             (170 . **) (176 . -) (182 . <) (188 . |sqrt|)
             (193 . |cos|) (198 . |sin|) (203 . /) (209 . |cosh|)
             (214 . |sinh|) (|SparseUnivariatePolynomial| $)
             (219 . |zerosOf|) (224 . |elt|))
          '#(|inverseLaplace| 230) 'NIL
          (CONS (|makeByteWordVec2| 1 'NIL)
                (CONS '#()
                      (CONS '#()
                            (|makeByteWordVec2| 76
                                '(1 12 11 0 13 2 7 14 0 9 15 0 6 0 16 0
                                  7 0 17 2 7 14 0 0 18 1 19 0 9 20 2 7
                                  21 0 22 23 1 24 12 0 25 1 24 12 0 26
                                  2 12 0 0 0 27 0 12 0 28 2 12 14 0 0
                                  29 1 7 0 9 30 0 24 0 32 2 24 14 0 0
                                  33 1 12 0 0 34 2 31 35 24 36 37 2 7 0
                                  0 0 38 1 7 0 0 39 2 7 0 0 0 40 1 12
                                  41 0 42 1 45 44 0 46 0 6 0 47 2 12 48
                                  49 0 50 1 12 51 0 52 2 12 7 0 51 53 1
                                  7 0 0 54 0 7 0 55 0 56 0 57 0 12 0 58
                                  2 60 0 59 59 61 1 60 0 0 62 2 7 0 60
                                  0 63 2 7 0 0 64 65 2 7 0 0 0 66 2 7
                                  14 0 0 67 1 7 0 0 68 1 7 0 0 69 1 7 0
                                  0 70 2 7 0 0 0 71 1 7 0 0 72 1 7 0 0
                                  73 1 7 49 74 75 2 12 7 0 7 76 3 0 8 7
                                  9 9 10)))))
          '|lookupComplete|)) 
