
(/VERSIONCHECK 2) 

(DEFUN |ODEEF;solve;EBoSU;1| (|diffeq| |y| |x| $)
  (SPADCALL
      (SPADCALL (SPADCALL |diffeq| (QREFELT $ 9))
          (SPADCALL |diffeq| (QREFELT $ 10)) (QREFELT $ 11))
      |y| |x| (QREFELT $ 16))) 

(DEFUN |ODEEF;solve;LLSU;2| (|leq| |lop| |x| $)
  (PROG (#0=#:G1854 |eq| #1=#:G1855)
    (RETURN
      (SEQ (SPADCALL (PROGN
                       (LETT #0# NIL . #2=(|ODEEF;solve;LLSU;2|))
                       (SEQ (LETT |eq| NIL . #2#)
                            (LETT #1# |leq| . #2#) G190
                            (COND
                              ((OR (ATOM #1#)
                                   (PROGN
                                     (LETT |eq| (CAR #1#) . #2#)
                                     NIL))
                               (GO G191)))
                            (SEQ (EXIT (LETT #0#
                                        (CONS
                                         (SPADCALL
                                          (SPADCALL |eq| (QREFELT $ 9))
                                          (SPADCALL |eq|
                                           (QREFELT $ 10))
                                          (QREFELT $ 11))
                                         #0#) . #2#)))
                            (LETT #1# (CDR #1#) . #2#) (GO G190) G191
                            (EXIT (NREVERSE0 #0#))))
                     |lop| |x| (QREFELT $ 22)))))) 

(DEFUN |ODEEF;solve;EBoELU;3| (|diffeq| |y| |center| |y0| $)
  (SPADCALL
      (SPADCALL (SPADCALL |diffeq| (QREFELT $ 9))
          (SPADCALL |diffeq| (QREFELT $ 10)) (QREFELT $ 11))
      |y| |center| |y0| (QREFELT $ 26))) 

(DEFUN |ODEEF;solve;MSU;4| (|m| |x| $)
  (PROG (|u|)
    (RETURN
      (SEQ (LETT |u|
                 (SPADCALL |m|
                     (SPADCALL (SPADCALL |m| (QREFELT $ 30))
                         (|spadConstant| $ 31) (QREFELT $ 33))
                     |x| (QREFELT $ 34))
                 |ODEEF;solve;MSU;4|)
           (EXIT (COND
                   ((QEQCAR |u| 1) (CONS 1 "failed"))
                   ('T (CONS 0 (QCDR (QCDR |u|)))))))))) 

(DEFUN |ODEEF;solve;MVSU;5| (|m| |v| |x| $)
  (PROG (|Lx| |uu| |rec| #0=#:G1892 |i| #1=#:G1893)
    (RETURN
      (SEQ (LETT |Lx|
                 (|LinearOrdinaryDifferentialOperator| (QREFELT $ 7)
                     (SPADCALL |x| (QREFELT $ 39)))
                 . #2=(|ODEEF;solve;MVSU;5|))
           (LETT |uu|
                 (SPADCALL |m| |v|
                     (CONS #'|ODEEF;solve;MVSU;5!0|
                           (VECTOR |Lx| $ |x|))
                     (|compiledLookupCheck| '|solve|
                         (LIST (LIST '|Union|
                                     (LIST '|Record|
                                      (LIST '|:| '|particular|
                                       (LIST '|Vector|
                                        (|devaluate| (ELT $ 7))))
                                      (LIST '|:| '|basis|
                                       (LIST '|Matrix|
                                        (|devaluate| (ELT $ 7)))))
                                     '"failed")
                               (LIST '|Matrix| (|devaluate| (ELT $ 7)))
                               (LIST '|Vector| (|devaluate| (ELT $ 7)))
                               (LIST '|Mapping|
                                     (LIST '|Union|
                                      (LIST '|Record|
                                       (LIST '|:| '|particular|
                                        (|devaluate| (ELT $ 7)))
                                       (LIST '|:| '|basis|
                                        (LIST '|List|
                                         (|devaluate| (ELT $ 7)))))
                                      '"failed")
                                     (|devaluate| |Lx|)
                                     (|devaluate| (ELT $ 7))))
                         (|SystemODESolver| (ELT $ 7) |Lx|))) . #2#)
           (EXIT (COND
                   ((QEQCAR |uu| 1) (CONS 1 "failed"))
                   ('T
                    (SEQ (LETT |rec| (QCDR |uu|) . #2#)
                         (EXIT (CONS 0
                                     (CONS (QCAR |rec|)
                                      (PROGN
                                        (LETT #0# NIL . #2#)
                                        (SEQ (LETT |i| 1 . #2#)
                                         (LETT #1#
                                          (SPADCALL (QCDR |rec|)
                                           (QREFELT $ 40)) . #2#)
                                         G190
                                         (COND
                                           ((QSGREATERP |i| #1#)
                                            (GO G191)))
                                         (SEQ
                                          (EXIT
                                           (LETT #0#
                                            (CONS
                                             (SPADCALL (QCDR |rec|) |i|
                                              (QREFELT $ 42))
                                             #0#) . #2#)))
                                         (LETT |i| (QSADD1 |i|) . #2#)
                                         (GO G190) G191
                                         (EXIT (NREVERSE0 #0#))))))))))))))) 

(DEFUN |ODEEF;solve;MVSU;5!0| (|#1| |#2| $$)
  (PROG ($ |Lx|)
    (LETT $ (QREFELT $$ 1) . #0=(|ODEEF;solve;MVSU;5|))
    (LETT |Lx| (QREFELT $$ 0) . #0#)
    (RETURN
      (PROGN
        (SPADCALL |#1| |#2| (QREFELT $$ 2)
            (|compiledLookupCheck| '|solve|
                (LIST (LIST '|Union|
                            (LIST '|Record|
                                  (LIST '|:| '|particular|
                                        (|devaluate| (ELT $ 7)))
                                  (LIST '|:| '|basis|
                                        (LIST '|List|
                                         (|devaluate| (ELT $ 7)))))
                            '"failed")
                      (|devaluate| |Lx|) (|devaluate| (ELT $ 7))
                      (LIST '|Symbol|))
                (|ElementaryFunctionLODESolver| (ELT $ 6) (ELT $ 7)
                    |Lx|))))))) 

(DEFUN |ODEEF;solve;FBoELU;6| (|diffeq| |y| |center| |y0| $)
  (PROG (|a| |x| |kx| |ur| |rc| |u| |rec| |Lx| |op| |p|)
    (RETURN
      (SEQ (LETT |a| (SPADCALL |center| (QREFELT $ 10))
                 . #0=(|ODEEF;solve;FBoELU;6|))
           (LETT |kx|
                 (SPADCALL
                     (LETT |x|
                           (SPADCALL (SPADCALL |center| (QREFELT $ 9))
                               (QREFELT $ 43)) . #0#)
                     (QREFELT $ 45)) . #0#)
           (LETT |ur| (|ODEEF;parseODE| |diffeq| |y| |x| $) . #0#)
           (EXIT (COND
                   ((QEQCAR |ur| 1)
                    (COND
                      ((NULL (EQL (LENGTH |y0|) 1))
                       (|error| "solve: more than one initial condition!"))
                      ('T
                       (SEQ (LETT |rc| (QCDR |ur|) . #0#)
                            (LETT |u|
                                  (SPADCALL (QCAR |rc|) (QCDR |rc|) |y|
                                      |x| (QREFELT $ 48)) . #0#)
                            (EXIT (COND
                                    ((QEQCAR |u| 1) (CONS 1 "failed"))
                                    (#1='T
                                     (CONS 0
                                      (SPADCALL (QCDR |u|)
                                       (SPADCALL (QCDR |u|)
                                        (LIST |kx|
                                         (SPADCALL
                                          (SPADCALL |y|
                                           (SPADCALL |x|
                                            (QREFELT $ 49))
                                           (QREFELT $ 50))
                                          (QREFELT $ 52)))
                                        (LIST |a| (|SPADfirst| |y0|))
                                        (QREFELT $ 55))
                                       (QREFELT $ 11))))))))))
                   (#1#
                    (SEQ (LETT |rec| (QCDR |ur|) . #0#)
                         (LETT |p| (QCAR |rec|) . #0#)
                         (LETT |Lx|
                               (|LinearOrdinaryDifferentialOperator|
                                   (QREFELT $ 7)
                                   (SPADCALL |x| (QREFELT $ 39))) . #0#)
                         (LETT |op|
                               (SPADCALL
                                   (|compiledLookupCheck| '|Zero|
                                    (LIST '$) |Lx|)) . #0#)
                         (SEQ G190
                              (COND
                                ((NULL (COND
                                         ((SPADCALL |p|
                                           (|spadConstant| $ 58)
                                           (QREFELT $ 60))
                                          'NIL)
                                         ('T 'T)))
                                 (GO G191)))
                              (SEQ (LETT |op|
                                    (SPADCALL |op|
                                     (SPADCALL
                                      (SPADCALL |p| (QREFELT $ 61))
                                      (SPADCALL |p| (QREFELT $ 62))
                                      (|compiledLookupCheck|
                                       '|monomial|
                                       (LIST '$ (|devaluate| (ELT $ 7))
                                        (LIST '|NonNegativeInteger|))
                                       |Lx|))
                                     (|compiledLookupCheck| '+
                                      (LIST '$ '$ '$) |Lx|)) . #0#)
                                   (EXIT
                                    (LETT |p|
                                     (SPADCALL |p| (QREFELT $ 63)) . #0#)))
                              NIL (GO G190) G191 (EXIT NIL))
                         (EXIT (SPADCALL |op| (QCDR |rec|) |x| |a| |y0|
                                   (|compiledLookupCheck| '|solve|
                                    (LIST
                                     (LIST '|Union|
                                      (|devaluate| (ELT $ 7))
                                      '"failed")
                                     (|devaluate| |Lx|)
                                     (|devaluate| (ELT $ 7))
                                     (LIST '|Symbol|)
                                     (|devaluate| (ELT $ 7))
                                     (LIST '|List|
                                      (|devaluate| (ELT $ 7))))
                                    (|ElementaryFunctionLODESolver|
                                     (ELT $ 6) (ELT $ 7) |Lx|)))))))))))) 

(DEFUN |ODEEF;solve;LLSU;7| (|leq| |lop| |x| $)
  (PROG (|u| |rec|)
    (RETURN
      (SEQ (LETT |u| (|ODEEF;parseSYS| |leq| |lop| |x| $)
                 . #0=(|ODEEF;solve;LLSU;7|))
           (EXIT (COND
                   ((QEQCAR |u| 0)
                    (SEQ (LETT |rec| (QCDR |u|) . #0#)
                         (EXIT (SPADCALL (QCAR |rec|) (QCDR |rec|) |x|
                                   (QREFELT $ 34)))))
                   ('T
                    (|error| "solve: not a first order linear system")))))))) 

(DEFUN |ODEEF;solve;FBoSU;8| (|diffeq| |y| |x| $)
  (PROG (|u| |rc| |uu| |rec| |Lx| |op| |p| |uuu|)
    (RETURN
      (SEQ (LETT |u| (|ODEEF;parseODE| |diffeq| |y| |x| $)
                 . #0=(|ODEEF;solve;FBoSU;8|))
           (EXIT (COND
                   ((QEQCAR |u| 1)
                    (SEQ (LETT |rc| (QCDR |u|) . #0#)
                         (LETT |uu|
                               (SPADCALL (QCAR |rc|) (QCDR |rc|) |y|
                                   |x| (QREFELT $ 48)) . #0#)
                         (EXIT (COND
                                 ((QEQCAR |uu| 1) (CONS 2 "failed"))
                                 (#1='T (CONS 1 (QCDR |uu|)))))))
                   (#1#
                    (SEQ (LETT |rec| (QCDR |u|) . #0#)
                         (LETT |p| (QCAR |rec|) . #0#)
                         (LETT |Lx|
                               (|LinearOrdinaryDifferentialOperator|
                                   (QREFELT $ 7)
                                   (SPADCALL |x| (QREFELT $ 39))) . #0#)
                         (LETT |op|
                               (SPADCALL
                                   (|compiledLookupCheck| '|Zero|
                                    (LIST '$) |Lx|)) . #0#)
                         (SEQ G190
                              (COND
                                ((NULL (COND
                                         ((SPADCALL |p|
                                           (|spadConstant| $ 58)
                                           (QREFELT $ 60))
                                          'NIL)
                                         ('T 'T)))
                                 (GO G191)))
                              (SEQ (LETT |op|
                                    (SPADCALL |op|
                                     (SPADCALL
                                      (SPADCALL |p| (QREFELT $ 61))
                                      (SPADCALL |p| (QREFELT $ 62))
                                      (|compiledLookupCheck|
                                       '|monomial|
                                       (LIST '$ (|devaluate| (ELT $ 7))
                                        (LIST '|NonNegativeInteger|))
                                       |Lx|))
                                     (|compiledLookupCheck| '+
                                      (LIST '$ '$ '$) |Lx|)) . #0#)
                                   (EXIT
                                    (LETT |p|
                                     (SPADCALL |p| (QREFELT $ 63)) . #0#)))
                              NIL (GO G190) G191 (EXIT NIL))
                         (LETT |uuu|
                               (SPADCALL |op| (QCDR |rec|) |x|
                                   (|compiledLookupCheck| '|solve|
                                    (LIST
                                     (LIST '|Union|
                                      (LIST '|Record|
                                       (LIST '|:| '|particular|
                                        (|devaluate| (ELT $ 7)))
                                       (LIST '|:| '|basis|
                                        (LIST '|List|
                                         (|devaluate| (ELT $ 7)))))
                                      '"failed")
                                     (|devaluate| |Lx|)
                                     (|devaluate| (ELT $ 7))
                                     (LIST '|Symbol|))
                                    (|ElementaryFunctionLODESolver|
                                     (ELT $ 6) (ELT $ 7) |Lx|))) . #0#)
                         (EXIT (COND
                                 ((QEQCAR |uuu| 1) (CONS 2 "failed"))
                                 (#1# (CONS 0 (QCDR |uuu|))))))))))))) 

(DEFUN |ODEEF;parseSYS| (|eqs| |ly| |x| $)
  (PROG (|n| |m| |v| |xx| #0=#:G1959 |y| #1=#:G1960 |lf| #2=#:G1961
             #3=#:G1962 |lk0| #4=#:G1963 |f| #5=#:G1964 |lk1| |eq|
             #6=#:G1965 |u| #7=#:G1958 |rec|)
    (RETURN
      (SEQ (EXIT (COND
                   ((NULL (EQL (LETT |n| (LENGTH |eqs|)
                                     . #8=(|ODEEF;parseSYS|))
                               (LENGTH |ly|)))
                    (CONS 1 "failed"))
                   ('T
                    (SEQ (LETT |m|
                               (SPADCALL |n| |n| (|spadConstant| $ 31)
                                   (QREFELT $ 64)) . #8#)
                         (LETT |v|
                               (SPADCALL |n| (|spadConstant| $ 31)
                                   (QREFELT $ 33)) . #8#)
                         (LETT |xx|
                               (SPADCALL |x| (QREFELT $ 49)) . #8#)
                         (LETT |lf|
                               (PROGN
                                 (LETT #0# NIL . #8#)
                                 (SEQ (LETT |y| NIL . #8#)
                                      (LETT #1# |ly| . #8#) G190
                                      (COND
                                        ((OR (ATOM #1#)
                                          (PROGN
                                            (LETT |y| (CAR #1#) . #8#)
                                            NIL))
                                         #9=(GO G191)))
                                      (SEQ
                                       (EXIT
                                        (LETT #0#
                                         (CONS
                                          (SPADCALL |y| |xx|
                                           (QREFELT $ 50))
                                          #0#) . #8#)))
                                      (LETT #1# (CDR #1#) . #8#)
                                      #10=(GO G190) G191
                                      (EXIT (NREVERSE0 #0#)))) . #8#)
                         (LETT |lk0|
                               (PROGN
                                 (LETT #2# NIL . #8#)
                                 (SEQ (LETT |f| NIL . #8#)
                                      (LETT #3# |lf| . #8#) G190
                                      (COND
                                        ((OR (ATOM #3#)
                                          (PROGN
                                            (LETT |f| (CAR #3#) . #8#)
                                            NIL))
                                         #9#))
                                      (SEQ
                                       (EXIT
                                        (LETT #2#
                                         (CONS
                                          (SPADCALL |f| (QREFELT $ 52))
                                          #2#) . #8#)))
                                      (LETT #3# (CDR #3#) . #8#) #10#
                                      G191 (EXIT (NREVERSE0 #2#)))) . #8#)
                         (LETT |lk1|
                               (PROGN
                                 (LETT #4# NIL . #8#)
                                 (SEQ (LETT |f| NIL . #8#)
                                      (LETT #5# |lf| . #8#) G190
                                      (COND
                                        ((OR (ATOM #5#)
                                          (PROGN
                                            (LETT |f| (CAR #5#) . #8#)
                                            NIL))
                                         #9#))
                                      (SEQ
                                       (EXIT
                                        (LETT #4#
                                         (CONS
                                          (SPADCALL
                                           (SPADCALL |f| |x|
                                            (QREFELT $ 65))
                                           (QREFELT $ 52))
                                          #4#) . #8#)))
                                      (LETT #5# (CDR #5#) . #8#) #10#
                                      G191 (EXIT (NREVERSE0 #4#)))) . #8#)
                         (SEQ (LETT |eq| NIL . #8#)
                              (LETT #6# |eqs| . #8#) G190
                              (COND
                                ((OR (ATOM #6#)
                                     (PROGN
                                       (LETT |eq| (CAR #6#) . #8#)
                                       NIL))
                                 #9#))
                              (SEQ (LETT |u|
                                    (|ODEEF;parseSYSeq| |eq| |lk0|
                                     |lk1| |lf| |x| $) . #8#)
                                   (EXIT
                                    (COND
                                      ((QEQCAR |u| 1)
                                       (PROGN
                                         (LETT #7#
                                          (CONS 1 "failed") . #8#)
                                         (GO #7#)))
                                      ('T
                                       (SEQ
                                        (LETT |rec| (QCDR |u|) . #8#)
                                        (SPADCALL |m| (QVELT |rec| 0)
                                         (QVELT |rec| 1)
                                         (QREFELT $ 66))
                                        (EXIT
                                         (SPADCALL |v| (QVELT |rec| 0)
                                          (QVELT |rec| 2)
                                          (QREFELT $ 67))))))))
                              (LETT #6# (CDR #6#) . #8#) #10# G191
                              (EXIT NIL))
                         (EXIT (CONS 0 (CONS |m| |v|)))))))
           #7# (EXIT #7#))))) 

(DEFUN |ODEEF;parseSYSeq| (|eq| |l0| |l1| |lf| |x| $)
  (PROG (#0=#:G1978 #1=#:G1979 |l| |k| |n| |c| |v| |i| |y| #2=#:G1980
            |ci|)
    (RETURN
      (SEQ (LETT |l|
                 (PROGN
                   (LETT #0# NIL . #3=(|ODEEF;parseSYSeq|))
                   (SEQ (LETT |k| NIL . #3#)
                        (LETT #1#
                              (SPADCALL (SPADCALL |eq| (QREFELT $ 68))
                                  |x| (QREFELT $ 71)) . #3#)
                        G190
                        (COND
                          ((OR (ATOM #1#)
                               (PROGN (LETT |k| (CAR #1#) . #3#) NIL))
                           #4=(GO G191)))
                        (SEQ (EXIT (COND
                                     ((SPADCALL |k|
                                       (SPADCALL "%diff"
                                        (QREFELT $ 73))
                                       (QREFELT $ 74))
                                      (LETT #0# (CONS |k| #0#) . #3#)))))
                        (LETT #1# (CDR #1#) . #3#) #5=(GO G190) G191
                        (EXIT (NREVERSE0 #0#)))) . #3#)
           (COND
             ((OR (OR (NULL |l|) (NULL (NULL (CDR |l|))))
                  (ZEROP (LETT |n|
                               (SPADCALL
                                   (LETT |k| (|SPADfirst| |l|) . #3#)
                                   |l1| (QREFELT $ 76)) . #3#)))
              (EXIT (CONS 1 "failed"))))
           (LETT |c| (|ODEEF;getfreelincoeff1| |eq| |k| |lf| $) . #3#)
           (LETT |eq|
                 (SPADCALL |eq|
                     (SPADCALL |c| (SPADCALL |k| (QREFELT $ 77))
                         (QREFELT $ 78))
                     (QREFELT $ 11)) . #3#)
           (LETT |v|
                 (SPADCALL (LENGTH |l0|) (|spadConstant| $ 31)
                     (QREFELT $ 33)) . #3#)
           (SEQ (LETT |i| 1 . #3#) (LETT |y| NIL . #3#)
                (LETT #2# |l0| . #3#) G190
                (COND
                  ((OR (ATOM #2#)
                       (PROGN (LETT |y| (CAR #2#) . #3#) NIL))
                   #4#))
                (SEQ (LETT |ci|
                           (|ODEEF;getfreelincoeff1| |eq| |y| |lf| $) . #3#)
                     (SPADCALL |v| |i|
                         (SPADCALL (SPADCALL |ci| |c| (QREFELT $ 79))
                             (QREFELT $ 80))
                         (QREFELT $ 67))
                     (EXIT (LETT |eq|
                                 (SPADCALL |eq|
                                     (SPADCALL |ci|
                                      (SPADCALL |y| (QREFELT $ 77))
                                      (QREFELT $ 78))
                                     (QREFELT $ 11)) . #3#)))
                (LETT #2#
                      (PROG1 (CDR #2#) (LETT |i| (QSADD1 |i|) . #3#)) . #3#)
                #5# G191 (EXIT NIL))
           (EXIT (CONS 0
                       (VECTOR |n| |v| (SPADCALL |eq| (QREFELT $ 80))))))))) 

(DEFUN |ODEEF;parseODE| (|diffeq| |y| |x| $)
  (PROG (#0=#:G2004 |m| #1=#:G1988 |n| |i| |f| |c| |ny| |l| |k| |u| |d|
            |eqrhs|)
    (RETURN
      (SEQ (LETT |f|
                 (SPADCALL |y| (SPADCALL |x| (QREFELT $ 49))
                     (QREFELT $ 50))
                 . #2=(|ODEEF;parseODE|))
           (LETT |l| (LIST (SPADCALL |f| (QREFELT $ 52))) . #2#)
           (LETT |n| 2 . #2#)
           (SEQ (LETT |k| NIL . #2#)
                (LETT #0#
                      (SPADCALL (SPADCALL |diffeq| (QREFELT $ 68)) |x|
                          (QREFELT $ 71)) . #2#)
                G190
                (COND
                  ((OR (ATOM #0#)
                       (PROGN (LETT |k| (CAR #0#) . #2#) NIL))
                   #3=(GO G191)))
                (SEQ (EXIT (COND
                             ((SPADCALL |k|
                                  (SPADCALL "%diff" (QREFELT $ 73))
                                  (QREFELT $ 74))
                              (SEQ (LETT |m|
                                    (SPADCALL |k| (QREFELT $ 81)) . #2#)
                                   (EXIT
                                    (COND
                                      ((< |n| |m|)
                                       (LETT |n| |m| . #2#)))))))))
                (LETT #0# (CDR #0#) . #2#) #4=(GO G190) G191
                (EXIT NIL))
           (LETT |n|
                 (PROG1 (LETT #1# (- |n| 2) . #2#)
                   (|check-subtype| (>= #1# 0) '(|NonNegativeInteger|)
                       #1#)) . #2#)
           (SEQ (LETT |i| 1 . #2#) G190
                (COND ((QSGREATERP |i| |n|) #3#))
                (SEQ (EXIT (LETT |l|
                                 (CONS (SPADCALL
                                        (LETT |f|
                                         (SPADCALL |f| |x|
                                          (QREFELT $ 65)) . #2#)
                                        (QREFELT $ 52))
                                       |l|) . #2#)))
                (LETT |i| (QSADD1 |i|) . #2#) #4# G191 (EXIT NIL))
           (SEQ G190
                (COND
                  ((NULL (COND
                           ((NULL |l|) 'NIL)
                           ('T
                            (SPADCALL
                                (LETT |c|
                                      (|ODEEF;getlincoeff| |diffeq|
                                       (LETT |k|
                                        (|SPADfirst| |l|) . #2#)
                                       $) . #2#)
                                (QREFELT $ 82)))))
                   #3#))
                (SEQ (EXIT (LETT |l| (CDR |l|) . #2#))) NIL #4# G191
                (EXIT NIL))
           (COND
             ((OR (NULL |l|) (NULL (CDR |l|)))
              (EXIT (|error| "parseODE: equation has order 0"))))
           (LETT |diffeq|
                 (SPADCALL |diffeq|
                     (SPADCALL |c| (SPADCALL |k| (QREFELT $ 77))
                         (QREFELT $ 78))
                     (QREFELT $ 11)) . #2#)
           (LETT |ny| (SPADCALL |y| (QREFELT $ 83)) . #2#)
           (LETT |l| (CDR |l|) . #2#)
           (EXIT (COND
                   ((< 3 (SPADCALL |k| (QREFELT $ 81)))
                    (CONS 0
                          (|ODEEF;parseLODE| |diffeq| |l|
                              (SPADCALL |c| (LENGTH |l|)
                                  (QREFELT $ 86))
                              |ny| $)))
                   ('T
                    (SEQ (LETT |u|
                               (|ODEEF;getcoeff| |diffeq|
                                   (LETT |k| (|SPADfirst| |l|) . #2#)
                                   $) . #2#)
                         (EXIT (COND
                                 ((QEQCAR |u| 1)
                                  (CONS 1 (CONS |diffeq| |c|)))
                                 ('T
                                  (SEQ (LETT |eqrhs|
                                        (SPADCALL
                                         (SPADCALL
                                          (LETT |d| (QCDR |u|) . #2#)
                                          (SPADCALL |k| (QREFELT $ 77))
                                          (QREFELT $ 78))
                                         |diffeq| (QREFELT $ 11)) . #2#)
                                       (COND
                                         ((SPADCALL |eqrhs| |ny|
                                           (QREFELT $ 87))
                                          (COND
                                            ((SPADCALL |c| |ny|
                                              (QREFELT $ 87))
                                             (COND
                                               ((SPADCALL |d| |ny|
                                                 (QREFELT $ 87))
                                                (EXIT
                                                 (CONS 0
                                                  (CONS
                                                   (SPADCALL
                                                    (SPADCALL |c| 1
                                                     (QREFELT $ 86))
                                                    (SPADCALL |d|
                                                     (QREFELT $ 89))
                                                    (QREFELT $ 90))
                                                   |eqrhs|)))))))))
                                       (EXIT
                                        (CONS 1 (CONS |diffeq| |c|))))))))))))))) 

(DEFUN |ODEEF;parseLODE| (|diffeq| |l| |p| |y| $)
  (PROG (|k| #0=#:G2012 |c| #1=#:G2007 |d|)
    (RETURN
      (SEQ (COND
             ((NULL (SPADCALL (SPADCALL |p| (QREFELT $ 61)) |y|
                        (QREFELT $ 87)))
              (|error| "parseLODE: not a linear ordinary differential equation"))
             ('T
              (SEQ (LETT |d| (- (SPADCALL |p| (QREFELT $ 62)) 1)
                         . #2=(|ODEEF;parseLODE|))
                   (SEQ (LETT |k| NIL . #2#) (LETT #0# |l| . #2#) G190
                        (COND
                          ((OR (ATOM #0#)
                               (PROGN (LETT |k| (CAR #0#) . #2#) NIL))
                           (GO G191)))
                        (SEQ (LETT |p|
                                   (SPADCALL |p|
                                    (SPADCALL
                                     (LETT |c|
                                      (|ODEEF;getfreelincoeff| |diffeq|
                                       |k| |y| $) . #2#)
                                     (PROG1 (LETT #1# |d| . #2#)
                                       (|check-subtype| (>= #1# 0)
                                        '(|NonNegativeInteger|) #1#))
                                     (QREFELT $ 86))
                                    (QREFELT $ 90)) . #2#)
                             (LETT |d| (- |d| 1) . #2#)
                             (EXIT (LETT |diffeq|
                                    (SPADCALL |diffeq|
                                     (SPADCALL |c|
                                      (SPADCALL |k| (QREFELT $ 77))
                                      (QREFELT $ 78))
                                     (QREFELT $ 11)) . #2#)))
                        (LETT #0# (CDR #0#) . #2#) (GO G190) G191
                        (EXIT NIL))
                   (EXIT (COND
                           ((SPADCALL |diffeq| |y| (QREFELT $ 87))
                            (CONS |p|
                                  (SPADCALL |diffeq| (QREFELT $ 80))))
                           ('T
                            (|error| "parseLODE: not a linear ordinary differential equation"))))))))))) 

(DEFUN |ODEEF;getfreelincoeff| (|f| |k| |y| $)
  (PROG (|c|)
    (RETURN
      (COND
        ((SPADCALL
             (LETT |c| (|ODEEF;getlincoeff| |f| |k| $)
                   |ODEEF;getfreelincoeff|)
             |y| (QREFELT $ 87))
         |c|)
        ('T
         (|error| "getfreelincoeff: not a linear ordinary differential equation")))))) 

(DEFUN |ODEEF;getfreelincoeff1| (|f| |k| |ly| $)
  (PROG (|c| |y| #0=#:G2019 #1=#:G2016)
    (RETURN
      (SEQ (LETT |c| (|ODEEF;getlincoeff| |f| |k| $)
                 . #2=(|ODEEF;getfreelincoeff1|))
           (SEQ (EXIT (SEQ (LETT |y| NIL . #2#) (LETT #0# |ly| . #2#)
                           G190
                           (COND
                             ((OR (ATOM #0#)
                                  (PROGN
                                    (LETT |y| (CAR #0#) . #2#)
                                    NIL))
                              (GO G191)))
                           (SEQ (EXIT (COND
                                        ((NULL
                                          (SPADCALL |c| |y|
                                           (QREFELT $ 91)))
                                         (PROGN
                                           (LETT #1#
                                            (|error|
                                             "getfreelincoeff: not a linear ordinary differential equation") . #2#)
                                           (GO #1#))))))
                           (LETT #0# (CDR #0#) . #2#) (GO G190) G191
                           (EXIT NIL)))
                #1# (EXIT #1#))
           (EXIT |c|))))) 

(DEFUN |ODEEF;getlincoeff| (|f| |k| $)
  (PROG (|u|)
    (RETURN
      (SEQ (LETT |u| (|ODEEF;getcoeff| |f| |k| $) |ODEEF;getlincoeff|)
           (EXIT (COND
                   ((QEQCAR |u| 1)
                    (|error| "getlincoeff: not an appropriate ordinary differential equation"))
                   ('T (QCDR |u|)))))))) 

(DEFUN |ODEEF;getcoeff| (|f| |k| $)
  (PROG (|r| |p| #0=#:G2036)
    (RETURN
      (SEQ (EXIT (SEQ (SEQ (LETT |r|
                                 (SPADCALL
                                     (SPADCALL
                                      (SPADCALL |f| (QREFELT $ 93)) |k|
                                      (QREFELT $ 96))
                                     (QREFELT $ 99))
                                 . #1=(|ODEEF;getcoeff|))
                           (EXIT (COND
                                   ((OR (QEQCAR |r| 1)
                                     (< 1
                                      (SPADCALL
                                       (LETT |p|
                                        (SPADCALL
                                         (SPADCALL |f| (QREFELT $ 100))
                                         |k| (QREFELT $ 96)) . #1#)
                                       (QREFELT $ 103))))
                                    (PROGN
                                      (LETT #0#
                                       (CONS 1 "failed") . #1#)
                                      (GO #0#))))))
                      (EXIT (CONS 0
                                  (SPADCALL
                                      (SPADCALL |p| 1 (QREFELT $ 104))
                                      (QCDR |r|) (QREFELT $ 105))))))
           #0# (EXIT #0#))))) 

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

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

(MAKEPROP '|ElementaryFunctionODESolver| '|infovec|
    (LIST '#(NIL NIL NIL NIL NIL NIL (|local| |#1|) (|local| |#2|)
             (|Equation| 7) (0 . |lhs|) (5 . |rhs|) (10 . -)
             (|Record| (|:| |particular| 7) (|:| |basis| 20))
             (|Union| 12 7 '"failed") (|BasicOperator|) (|Symbol|)
             |ODEEF;solve;FBoSU;8| |ODEEF;solve;EBoSU;1|
             (|Record| (|:| |particular| 32) (|:| |basis| (|List| 32)))
             (|Union| 18 '"failed") (|List| 7) (|List| 14)
             |ODEEF;solve;LLSU;7| (|List| 8) |ODEEF;solve;LLSU;2|
             (|Union| 7 '"failed") |ODEEF;solve;FBoELU;6|
             |ODEEF;solve;EBoELU;3| (|NonNegativeInteger|) (|Matrix| 7)
             (16 . |nrows|) (21 . |Zero|) (|Vector| 7) (25 . |new|)
             |ODEEF;solve;MVSU;5| (|Union| (|List| 32) '"failed")
             |ODEEF;solve;MSU;4| (|Mapping| 7 7) (|ODEIntegration| 6 7)
             (31 . |diff|) (36 . |ncols|) (|Integer|) (41 . |column|)
             (47 . |retract|) (|Kernel| 7) (52 . |kernel|) (57 . |One|)
             (|NonLinearFirstOrderODESolver| 6 7) (61 . |solve|)
             (69 . |coerce|) (74 . |elt|) (|Kernel| $) (80 . |retract|)
             (|List| 51) (|List| $) (85 . |eval|) (92 . |Zero|)
             (|SparseUnivariatePolynomial| 7) (96 . |Zero|) (|Boolean|)
             (100 . =) (106 . |leadingCoefficient|) (111 . |degree|)
             (116 . |reductum|) (121 . |new|) (128 . |differentiate|)
             (134 . |setRow!|) (141 . |setelt|) (148 . |kernels|)
             (|List| 44) (|IntegrationTools| 6 7) (153 . |varselect|)
             (|String|) (159 . |coerce|) (164 . |is?|) (170 . |first|)
             (175 . |position|) (181 . |coerce|) (186 . *) (192 . /)
             (198 . -) (203 . |height|) (208 . |zero?|) (213 . |name|)
             (|OutputForm|) (218 . |height|) (222 . |monomial|)
             (228 . |freeOf?|) (234 . |One|) (238 . |coerce|) (243 . +)
             (249 . |freeOf?|) (|SparseMultivariatePolynomial| 6 51)
             (255 . |denom|) (|SparseUnivariatePolynomial| $)
             (|SparseMultivariatePolynomial| 6 44) (260 . |univariate|)
             (|Union| 95 '"failed") (|SparseUnivariatePolynomial| 95)
             (266 . |retractIfCan|) (271 . |numer|) (276 . |One|)
             (280 . |One|) (284 . |degree|) (289 . |coefficient|)
             (295 . /))
          '#(|solve| 301) 'NIL
          (CONS (|makeByteWordVec2| 1 'NIL)
                (CONS '#()
                      (CONS '#()
                            (|makeByteWordVec2| 105
                                '(1 8 7 0 9 1 8 7 0 10 2 7 0 0 0 11 1
                                  29 28 0 30 0 7 0 31 2 32 0 28 7 33 1
                                  38 37 15 39 1 29 28 0 40 2 29 32 0 41
                                  42 1 7 15 0 43 1 44 0 15 45 0 6 0 46
                                  4 47 25 7 7 14 15 48 1 7 0 15 49 2 7
                                  0 14 0 50 1 7 51 0 52 3 7 0 0 53 54
                                  55 0 6 0 56 0 57 0 58 2 57 59 0 0 60
                                  1 57 7 0 61 1 57 28 0 62 1 57 0 0 63
                                  3 29 0 28 28 7 64 2 7 0 0 15 65 3 29
                                  0 0 41 32 66 3 32 7 0 41 7 67 1 7 53
                                  0 68 2 70 69 69 15 71 1 15 0 72 73 2
                                  44 59 0 15 74 1 69 44 0 75 2 69 41 44
                                  0 76 1 7 0 51 77 2 7 0 0 0 78 2 7 0 0
                                  0 79 1 7 0 0 80 1 44 28 0 81 1 7 59 0
                                  82 1 14 15 0 83 0 84 41 85 2 57 0 7
                                  28 86 2 7 59 0 15 87 0 7 0 88 1 57 0
                                  7 89 2 57 0 0 0 90 2 7 59 0 0 91 1 7
                                  92 0 93 2 95 94 0 44 96 1 98 97 0 99
                                  1 7 92 0 100 0 95 0 101 0 98 0 102 1
                                  98 28 0 103 2 98 95 0 28 104 2 7 0 92
                                  92 105 2 0 35 29 15 36 3 0 19 29 32
                                  15 34 3 0 19 20 21 15 22 3 0 19 23 21
                                  15 24 3 0 13 7 14 15 16 3 0 13 8 14
                                  15 17 4 0 25 7 14 8 20 26 4 0 25 8 14
                                  8 20 27)))))
          '|lookupComplete|)) 
