
(/VERSIONCHECK 2) 

(DEFUN |ODEINT;diff;SM;1| (|x| $)
  (CONS #'|ODEINT;diff;SM;1!0| (VECTOR $ |x|))) 

(DEFUN |ODEINT;diff;SM;1!0| (|#1| $$)
  (SPADCALL |#1| (QREFELT $$ 1) (QREFELT (QREFELT $$ 0) 9))) 

(DEFUN |ODEINT;int;FSF;2| (|f| |x| $)
  (PROG (|u|)
    (RETURN
      (SEQ (LETT |u| (SPADCALL |f| |x| (QREFELT $ 14))
                 |ODEINT;int;FSF;2|)
           (EXIT (COND
                   ((QEQCAR |u| 0) (QCDR |u|))
                   ('T (|SPADfirst| (QCDR |u|))))))))) 

(DEFUN |ODEINT;mkprod| (|l| $)
  (PROG (|rec| |d| |ll| |r| #0=#:G1853 #1=#:G1848 #2=#:G1846
               #3=#:G1847)
    (RETURN
      (SEQ (COND
             ((NULL |l|) (|spadConstant| $ 16))
             ('T
              (SEQ (LETT |rec| (|SPADfirst| |l|)
                         . #4=(|ODEINT;mkprod|))
                   (LETT |d|
                         (SPADCALL (QCAR |rec|) (QREFELT $ 19)) . #4#)
                   (LETT |ll|
                         (SPADCALL
                             (CONS #'|ODEINT;mkprod!0| (VECTOR |d| $))
                             |l| (QREFELT $ 25)) . #4#)
                   (EXIT (SPADCALL
                             (SPADCALL
                                 (PROGN
                                   (LETT #3# NIL . #4#)
                                   (SEQ (LETT |r| NIL . #4#)
                                    (LETT #0# |ll| . #4#) G190
                                    (COND
                                      ((OR (ATOM #0#)
                                        (PROGN
                                          (LETT |r| (CAR #0#) . #4#)
                                          NIL))
                                       (GO G191)))
                                    (SEQ
                                     (EXIT
                                      (PROGN
                                        (LETT #1#
                                         (SPADCALL (QCDR |r|)
                                          (SPADCALL (QCAR |r|)
                                           (QREFELT $ 26))
                                          (QREFELT $ 27)) . #4#)
                                        (COND
                                          (#3#
                                           (LETT #2#
                                            (SPADCALL #2# #1#
                                             (QREFELT $ 28)) . #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| $ 16))))
                                 |d| (QREFELT $ 29))
                             (|ODEINT;mkprod|
                                 (SPADCALL |l| |ll| (QREFELT $ 30)) $)
                             (QREFELT $ 28)))))))))) 

(DEFUN |ODEINT;mkprod!0| (|#1| $$)
  (PROG ($)
    (LETT $ (QREFELT $$ 1) |ODEINT;mkprod|)
    (RETURN
      (PROGN
        (SPADCALL (SPADCALL (QCAR |#1|) (QREFELT $ 19)) (QREFELT $$ 0)
            (QREFELT $ 21)))))) 

(DEFUN |ODEINT;expint;FSF;4| (|f| |x| $)
  (PROG (|a| |u| |da| |na| |v| #0=#:G1864 |l| |term| #1=#:G1876 |w|
             |lrec| |exponent|)
    (RETURN
      (SEQ (LETT |a| (SPADCALL |f| |x| (QREFELT $ 15))
                 . #2=(|ODEINT;expint;FSF;4|))
           (LETT |u|
                 (SPADCALL (SPADCALL |a| (QREFELT $ 32)) |a| |x|
                     (QREFELT $ 36)) . #2#)
           (EXIT (COND
                   ((QEQCAR |u| 0) (QCDR |u|))
                   ('T
                    (SEQ (LETT |da|
                               (SPADCALL |a| (QREFELT $ 38)) . #2#)
                         (LETT |l|
                               (COND
                                 ((QEQCAR (LETT |v|
                                           (SPADCALL
                                            (LETT |na|
                                             (SPADCALL |a|
                                              (QREFELT $ 39)) . #2#)
                                            (QREFELT $ 42)) . #2#)
                                          0)
                                  (PROG2 (LETT #0# |v| . #2#)
                                         (QCDR #0#)
                                    (|check-union| (QEQCAR #0# 0)
                                     (|List|
                                      (|SparseMultivariatePolynomial|
                                       (QREFELT $ 6)
                                       (|Kernel| (QREFELT $ 7))))
                                     #0#)))
                                 ('T (LIST |na|))) . #2#)
                         (LETT |exponent| (|spadConstant| $ 43) . #2#)
                         (LETT |lrec| NIL . #2#)
                         (SEQ (LETT |term| NIL . #2#)
                              (LETT #1# |l| . #2#) G190
                              (COND
                                ((OR (ATOM #1#)
                                     (PROGN
                                       (LETT |term| (CAR #1#) . #2#)
                                       NIL))
                                 (GO G191)))
                              (SEQ (LETT |w|
                                    (|ODEINT;isQlog|
                                     (SPADCALL |term| |da|
                                      (QREFELT $ 44))
                                     $) . #2#)
                                   (EXIT
                                    (COND
                                      ((QEQCAR |w| 0)
                                       (LETT |lrec|
                                        (CONS (QCDR |w|) |lrec|) . #2#))
                                      ('T
                                       (LETT |exponent|
                                        (SPADCALL |exponent| |term|
                                         (QREFELT $ 45)) . #2#)))))
                              (LETT #1# (CDR #1#) . #2#) (GO G190) G191
                              (EXIT NIL))
                         (EXIT (SPADCALL (|ODEINT;mkprod| |lrec| $)
                                   (SPADCALL
                                    (SPADCALL |exponent| |da|
                                     (QREFELT $ 44))
                                    (QREFELT $ 46))
                                   (QREFELT $ 28))))))))))) 

(DEFUN |ODEINT;isQ| (|l| $)
  (PROG (|x| #0=#:G1887 |u| #1=#:G1886 |prod|)
    (RETURN
      (SEQ (EXIT (SEQ (LETT |prod| (|spadConstant| $ 48)
                            . #2=(|ODEINT;isQ|))
                      (SEQ (LETT |x| NIL . #2#) (LETT #0# |l| . #2#)
                           G190
                           (COND
                             ((OR (ATOM #0#)
                                  (PROGN
                                    (LETT |x| (CAR #0#) . #2#)
                                    NIL))
                              (GO G191)))
                           (SEQ (LETT |u|
                                      (SPADCALL |x| (QREFELT $ 50)) . #2#)
                                (EXIT (COND
                                        ((QEQCAR |u| 1)
                                         (PROGN
                                           (LETT #1#
                                            (CONS 1 "failed") . #2#)
                                           (GO #1#)))
                                        ('T
                                         (LETT |prod|
                                          (SPADCALL |prod| (QCDR |u|)
                                           (QREFELT $ 51)) . #2#)))))
                           (LETT #0# (CDR #0#) . #2#) (GO G190) G191
                           (EXIT NIL))
                      (EXIT (CONS 0 |prod|))))
           #1# (EXIT #1#))))) 

(DEFUN |ODEINT;isQlog| (|f| $)
  (PROG (|v| #0=#:G1893 |l| |u| #1=#:G1900)
    (RETURN
      (SEQ (COND
             ((SPADCALL |f| (SPADCALL "log" (QREFELT $ 53))
                  (QREFELT $ 54))
              (CONS 0
                    (CONS (|spadConstant| $ 48)
                          (|SPADfirst|
                              (SPADCALL (SPADCALL |f| (QREFELT $ 57))
                                  (QREFELT $ 60))))))
             ('T
              (SEQ (COND
                     ((QEQCAR (LETT |v| (SPADCALL |f| (QREFELT $ 61))
                                    . #2=(|ODEINT;isQlog|))
                              0)
                      (COND
                        ((NULL (< 3
                                  (LENGTH (LETT |l|
                                           (PROG2 (LETT #0# |v| . #2#)
                                            (QCDR #0#)
                                             (|check-union|
                                              (QEQCAR #0# 0)
                                              (|List| (QREFELT $ 7))
                                              #0#)) . #2#))))
                         (EXIT (SEQ (EXIT
                                     (SEQ
                                      (LETT |l|
                                       (NREVERSE
                                        (SPADCALL |l| (QREFELT $ 62))) . #2#)
                                      (COND
                                        ((SPADCALL (|SPADfirst| |l|)
                                          (SPADCALL "log"
                                           (QREFELT $ 53))
                                          (QREFELT $ 54))
                                         (SEQ
                                          (LETT |u|
                                           (|ODEINT;isQ| (CDR |l|) $) . #2#)
                                          (EXIT
                                           (COND
                                             ((QEQCAR |u| 0)
                                              (PROGN
                                                (LETT #1#
                                                 (CONS 0
                                                  (CONS (QCDR |u|)
                                                   (|SPADfirst|
                                                    (SPADCALL
                                                     (SPADCALL
                                                      (|SPADfirst| |l|)
                                                      (QREFELT $ 57))
                                                     (QREFELT $ 60))))) . #2#)
                                                (GO #1#))))))))
                                      (EXIT (CONS 1 "failed"))))
                                    #1# (EXIT #1#)))))))
                   (EXIT (CONS 1 "failed"))))))))) 

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

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

(MAKEPROP '|ODEIntegration| '|infovec|
    (LIST '#(NIL NIL NIL NIL NIL NIL (|local| |#1|) (|local| |#2|)
             (|Symbol|) (0 . |differentiate|) (|Mapping| 7 7)
             |ODEINT;diff;SM;1| (|Union| 7 58)
             (|FunctionSpaceIntegration| 6 7) (6 . |integrate|)
             |ODEINT;int;FSF;2| (12 . |One|) (|Integer|)
             (|Fraction| 17) (16 . |denom|) (|Boolean|) (21 . =)
             (|Record| (|:| |coef| 18) (|:| |logand| 7))
             (|Mapping| 20 22) (|List| 22) (27 . |select|)
             (33 . |numer|) (38 . **) (44 . *) (50 . |nthRoot|)
             (56 . |setDifference|) (|List| 56) (62 . |tower|)
             (|Union| 7 '"failed") (|List| 59)
             (|ElementaryFunctionStructurePackage| 6 7)
             (67 . |validExponential|)
             (|SparseMultivariatePolynomial| 6 56) (74 . |denom|)
             (79 . |numer|) (|Union| (|List| $) '"failed")
             (|SparseMultivariatePolynomial| 6 59) (84 . |isPlus|)
             (89 . |Zero|) (93 . /) (99 . +) (105 . |exp|)
             |ODEINT;expint;FSF;4| (110 . |One|) (|Union| 18 '"failed")
             (114 . |retractIfCan|) (119 . *) (|String|)
             (125 . |coerce|) (130 . |is?|) (136 . |One|) (|Kernel| $)
             (140 . |retract|) (|List| 7) (|Kernel| 7)
             (145 . |argument|) (150 . |isTimes|) (155 . |sort!|))
          '#(|int| 160 |expint| 166 |diff| 172) 'NIL
          (CONS (|makeByteWordVec2| 1 'NIL)
                (CONS '#()
                      (CONS '#()
                            (|makeByteWordVec2| 62
                                '(2 7 0 0 8 9 2 13 12 7 8 14 0 7 0 16 1
                                  18 17 0 19 2 17 20 0 0 21 2 24 0 23 0
                                  25 1 18 17 0 26 2 7 0 0 17 27 2 7 0 0
                                  0 28 2 7 0 0 17 29 2 24 0 0 0 30 1 7
                                  31 0 32 3 35 33 34 7 8 36 1 7 37 0 38
                                  1 7 37 0 39 1 41 40 0 42 0 41 0 43 2
                                  7 0 37 37 44 2 41 0 0 0 45 1 7 0 0 46
                                  0 18 0 48 1 7 49 0 50 2 18 0 0 0 51 1
                                  8 0 52 53 2 7 20 0 8 54 0 6 0 55 1 7
                                  56 0 57 1 59 58 0 60 1 7 40 0 61 1 58
                                  0 0 62 2 0 7 7 8 15 2 0 7 7 8 47 1 0
                                  10 8 11)))))
          '|lookupComplete|)) 
