
(/VERSIONCHECK 2) 

(DEFUN |ODERAT;infOrder| (|f| $)
  (- (SPADCALL (SPADCALL |f| (QREFELT $ 12)) (QREFELT $ 14))
     (SPADCALL (SPADCALL |f| (QREFELT $ 15)) (QREFELT $ 14)))) 

(DEFUN |ODERAT;evenodd| (|n| $)
  (COND ((SPADCALL |n| (QREFELT $ 18)) (|spadConstant| $ 19))
        ('T (SPADCALL (|spadConstant| $ 19) (QREFELT $ 21))))) 

(DEFUN |ODERAT;ratDsolve1| (|op| |lg| $)
  (PROG (|sys1| |l| #1=#:G1857 |i| #2=#:G1856 #3=#:G1855 |q| #4=#:G1854 |rec|
         |d|)
    (RETURN
     (SEQ
      (LETT |d| (SPADCALL |op| |lg| (QREFELT $ 25)) . #5=(|ODERAT;ratDsolve1|))
      (LETT |rec| (|ODERAT;candidates| |op| |lg| |d| $) . #5#)
      (LETT |l|
            (SPADCALL
             (PROGN
              (LETT #4# NIL . #5#)
              (SEQ (LETT |q| NIL . #5#) (LETT #3# (QCAR |rec|) . #5#) G190
                   (COND
                    ((OR (ATOM #3#) (PROGN (LETT |q| (CAR #3#) . #5#) NIL))
                     #6=(GO G191)))
                   (SEQ
                    (EXIT
                     (LETT #4# (CONS (SPADCALL |op| |q| (QREFELT $ 26)) #4#)
                           . #5#)))
                   (LETT #3# (CDR #3#) . #5#) #7=(GO G190) G191
                   (EXIT (NREVERSE0 #4#))))
             (PROGN
              (LETT #2# NIL . #5#)
              (SEQ (LETT |i| 1 . #5#) (LETT #1# (LENGTH (QCDR |rec|)) . #5#)
                   G190 (COND ((QSGREATERP |i| #1#) #6#))
                   (SEQ
                    (EXIT
                     (LETT #2#
                           (CONS
                            (SPADCALL
                             (SPADCALL |op|
                                       (SPADCALL (QCDR |rec|) |i|
                                                 (QREFELT $ 27))
                                       (QREFELT $ 26))
                             (SPADCALL |lg| |i| (QREFELT $ 27)) (QREFELT $ 28))
                            #2#)
                           . #5#)))
                   (LETT |i| (QSADD1 |i|) . #5#) #7# G191
                   (EXIT (NREVERSE0 #2#))))
             (QREFELT $ 29))
            . #5#)
      (LETT |sys1|
            (SPADCALL (SPADCALL (LIST |l|) (QREFELT $ 32)) (QREFELT $ 35))
            . #5#)
      (EXIT (CONS (QCAR |rec|) (SPADCALL |sys1| (QREFELT $ 37)))))))) 

(DEFUN |ODERAT;ratDsolve0| (|op| |g| $)
  (PROG (#1=#:G1910 |v| #2=#:G1909 |part| #3=#:G1896 |sol| |m| |sys2| |sys1|
         |h| |lb| |l| |lsol| |opq| #4=#:G1908 |q| |rec| |u| #5=#:G1860 |b| |uu|
         #6=#:G1907 |f|)
    (RETURN
     (SEQ
      (COND
       ((ZEROP (SPADCALL |op| (QREFELT $ 38)))
        (CONS
         (CONS 0
               (SPADCALL
                (SPADCALL
                 (SPADCALL (SPADCALL |op| (QREFELT $ 39)) (QREFELT $ 40))
                 (QREFELT $ 41))
                |g| (QREFELT $ 42)))
         NIL))
       ((< 0 (SPADCALL |op| (QREFELT $ 49)))
        (SEQ
         (LETT |sol|
               (|ODERAT;ratDsolve0|
                (QCAR
                 (SPADCALL |op|
                           (SPADCALL (|spadConstant| $ 20) 1 (QREFELT $ 50))
                           (QREFELT $ 52)))
                |g| $)
               . #7=(|ODERAT;ratDsolve0|))
         (LETT |b| (LIST (|spadConstant| $ 53)) . #7#)
         (SEQ (LETT |f| NIL . #7#) (LETT #6# (QCDR |sol|) . #7#) G190
              (COND
               ((OR (ATOM #6#) (PROGN (LETT |f| (CAR #6#) . #7#) NIL))
                #8=(GO G191)))
              (SEQ (LETT |uu| (SPADCALL |f| (QREFELT $ 56)) . #7#)
                   (EXIT
                    (COND
                     ((QEQCAR |uu| 0)
                      (LETT |b| (CONS (QCDR |uu|) |b|) . #7#)))))
              (LETT #6# (CDR #6#) . #7#) #9=(GO G190) G191 (EXIT NIL))
         (EXIT
          (COND ((QEQCAR (QCAR |sol|) 1) (CONS (CONS 1 "failed") |b|))
                (#10='T
                 (CONS
                  (SPADCALL
                   (PROG2
                       (LETT #5# (QCAR |sol|) . #7#)
                       (QCDR #5#)
                     (|check-union| (QEQCAR #5# 0) (|Fraction| (QREFELT $ 7))
                                    #5#))
                   (QREFELT $ 56))
                  |b|))))))
       (#10#
        (SEQ (LETT |u| (SPADCALL |op| |g| (QREFELT $ 58)) . #7#)
             (EXIT
              (COND ((QEQCAR |u| 1) (CONS (CONS 1 "failed") NIL))
                    (#10#
                     (SEQ
                      (LETT |rec|
                            (|ODERAT;candidates| |op| (LIST |g|) (QCDR |u|) $)
                            . #7#)
                      (LETT |l| (LETT |lb| (LETT |lsol| NIL . #7#) . #7#)
                            . #7#)
                      (SEQ (LETT |q| NIL . #7#) (LETT #4# (QCAR |rec|) . #7#)
                           G190
                           (COND
                            ((OR (ATOM #4#)
                                 (PROGN (LETT |q| (CAR #4#) . #7#) NIL))
                             #8#))
                           (SEQ
                            (EXIT
                             (COND
                              ((SPADCALL
                                (LETT |opq| (SPADCALL |op| |q| (QREFELT $ 26))
                                      . #7#)
                                (QREFELT $ 59))
                               (LETT |lsol| (CONS |q| |lsol|) . #7#))
                              ('T
                               (SEQ (LETT |l| (CONS |opq| |l|) . #7#)
                                    (EXIT
                                     (LETT |lb| (CONS |q| |lb|) . #7#)))))))
                           (LETT #4# (CDR #4#) . #7#) #9# G191 (EXIT NIL))
                      (LETT |h|
                            (COND
                             ((SPADCALL |g| (QREFELT $ 59))
                              (|spadConstant| $ 46))
                             (#10# (|SPADfirst| (QCDR |rec|))))
                            . #7#)
                      (EXIT
                       (COND
                        ((NULL |l|)
                         (COND
                          ((SPADCALL |g| (QREFELT $ 59))
                           (CONS (CONS 0 (|spadConstant| $ 46)) |lsol|))
                          (#10#
                           (CONS
                            (COND
                             ((SPADCALL |g| (SPADCALL |op| |h| (QREFELT $ 26))
                                        (QREFELT $ 60))
                              (CONS 0 |h|))
                             (#10# (CONS 1 "failed")))
                            |lsol|))))
                        (#10#
                         (SEQ
                          (COND
                           ((SPADCALL |g| (QREFELT $ 59))
                            (SEQ
                             (LETT |m|
                                   (SPADCALL
                                    (SPADCALL
                                     (SPADCALL (LIST |l|) (QREFELT $ 32))
                                     (QREFELT $ 35))
                                    (QREFELT $ 37))
                                   . #7#)
                             (EXIT
                              (LETT |v|
                                    (MAKEARR1 (SPADCALL |m| (QREFELT $ 61))
                                              (|spadConstant| $ 43))
                                    . #7#))))
                           (#10#
                            (SEQ
                             (LETT |sys1|
                                   (SPADCALL
                                    (SPADCALL (LIST |l|) (QREFELT $ 32))
                                    (SPADCALL
                                     (LIST
                                      (SPADCALL |g|
                                                (SPADCALL |op| |h|
                                                          (QREFELT $ 26))
                                                (QREFELT $ 28)))
                                     (QREFELT $ 63))
                                    (QREFELT $ 66))
                                   . #7#)
                             (LETT |sys2|
                                   (SPADCALL (QCAR |sys1|) (QCDR |sys1|)
                                             (QREFELT $ 68))
                                   . #7#)
                             (LETT |m| (QCAR |sys2|) . #7#)
                             (EXIT (LETT |v| (QCDR |sys2|) . #7#)))))
                          (LETT |sol| (SPADCALL |m| |v| (QREFELT $ 73)) . #7#)
                          (LETT |part|
                                (COND
                                 ((SPADCALL |g| (QREFELT $ 59))
                                  (CONS 0 (|spadConstant| $ 46)))
                                 ((QEQCAR (QCAR |sol|) 1) (CONS 1 "failed"))
                                 (#10#
                                  (CONS 0
                                        (SPADCALL
                                         (|ODERAT;makeDot|
                                          (PROG2
                                              (LETT #3# (QCAR |sol|) . #7#)
                                              (QCDR #3#)
                                            (|check-union| (QEQCAR #3# 0)
                                                           (|Vector|
                                                            (QREFELT $ 6))
                                                           #3#))
                                          |lb| $)
                                         (|SPADfirst| (QCDR |rec|))
                                         (QREFELT $ 74)))))
                                . #7#)
                          (EXIT
                           (CONS |part|
                                 (SPADCALL |lsol|
                                           (PROGN
                                            (LETT #2# NIL . #7#)
                                            (SEQ (LETT |v| NIL . #7#)
                                                 (LETT #1# (QCDR |sol|) . #7#)
                                                 G190
                                                 (COND
                                                  ((OR (ATOM #1#)
                                                       (PROGN
                                                        (LETT |v| (CAR #1#)
                                                              . #7#)
                                                        NIL))
                                                   #8#))
                                                 (SEQ
                                                  (EXIT
                                                   (COND
                                                    ((|ODERAT;nzero?| |v| $)
                                                     (LETT #2#
                                                           (CONS
                                                            (|ODERAT;makeDot|
                                                             |v| |lb| $)
                                                            #2#)
                                                           . #7#)))))
                                                 (LETT #1# (CDR #1#) . #7#) #9#
                                                 G191 (EXIT (NREVERSE0 #2#))))
                                           (QREFELT $ 75))))))))))))))))))) 

(DEFUN |ODERAT;indicialEquationAtInfinity;LodoUP;5| (|op| $)
  (PROG (|rec|)
    (RETURN
     (SEQ
      (LETT |rec| (|ODERAT;infMuLambda| |op| $)
            |ODERAT;indicialEquationAtInfinity;LodoUP;5|)
      (EXIT
       (|ODERAT;infIndicialEquation| (QVELT |rec| 1) (QVELT |rec| 2) $)))))) 

(DEFUN |ODERAT;indicialEquationAtInfinity;LodoUP;6| (|op| $)
  (PROG (|rec|)
    (RETURN
     (SEQ
      (LETT |rec| (SPADCALL |op| NIL (QREFELT $ 79))
            |ODERAT;indicialEquationAtInfinity;LodoUP;6|)
      (EXIT (SPADCALL (QCAR |rec|) (QREFELT $ 76))))))) 

(DEFUN |ODERAT;regularPoint| (|l| |lg| $)
  (PROG (#1=#:G1920 #2=#:G1923 |j| |i| |a|)
    (RETURN
     (SEQ
      (EXIT
       (SEQ
        (LETT |a|
              (SPADCALL (SPADCALL |l| (QREFELT $ 39))
                        (SPADCALL |lg| (QREFELT $ 82)) (QREFELT $ 83))
              . #3=(|ODERAT;regularPoint|))
        (COND
         ((NULL
           (SPADCALL (SPADCALL |a| 0 (QREFELT $ 84)) (|spadConstant| $ 43)
                     (QREFELT $ 85)))
          (EXIT 0)))
        (EXIT
         (SEQ (LETT |i| 1 . #3#) G190 NIL
              (SEQ
               (EXIT
                (COND
                 ((NULL
                   (SPADCALL
                    (SPADCALL |a|
                              (LETT |j| (SPADCALL |i| (QREFELT $ 86)) . #3#)
                              (QREFELT $ 87))
                    (|spadConstant| $ 43) (QREFELT $ 85)))
                  (PROGN (LETT #2# |i| . #3#) (GO #2#)))
                 ((NULL
                   (SPADCALL
                    (SPADCALL |a| (SPADCALL |j| (QREFELT $ 21)) (QREFELT $ 87))
                    (|spadConstant| $ 43) (QREFELT $ 85)))
                  (PROGN
                   (LETT #1# (PROGN (LETT #2# (- |i|) . #3#) (GO #2#)) . #3#)
                   (GO #1#)))))
               #1# (EXIT #1#))
              (LETT |i| (QSADD1 |i|) . #3#) (GO G190) G191 (EXIT NIL)))))
      #2# (EXIT #2#))))) 

(DEFUN |ODERAT;unitlist| (|i| |q| $)
  (PROG (|v|)
    (RETURN
     (SEQ (LETT |v| (MAKEARR1 |q| (|spadConstant| $ 43)) |ODERAT;unitlist|)
          (SPADCALL |v| |i| (|spadConstant| $ 19) (QREFELT $ 88))
          (EXIT (SPADCALL |v| (QREFELT $ 90))))))) 

(DEFUN |ODERAT;candidates| (|op| |lg| |d| $)
  (PROG (|part| #1=#:G1933 |g| #2=#:G1932 |a1| |hom| |i| #3=#:G1931 |e| |q| |f|
         |dd| |solver| |tools| |uts| |m| |n|)
    (RETURN
     (SEQ
      (LETT |n|
            (+ (SPADCALL |d| (QREFELT $ 14)) (|ODERAT;infBound| |op| |lg| $))
            . #4=(|ODERAT;candidates|))
      (LETT |m| (|ODERAT;regularPoint| |op| |lg| $) . #4#)
      (LETT |uts|
            (|UnivariateTaylorSeries| (QREFELT $ 6) (QREFELT $ 10)
                                      (SPADCALL |m| (QREFELT $ 86)))
            . #4#)
      (LETT |tools|
            (|UTSodetools| (QREFELT $ 6) (QREFELT $ 7)
                           (|LinearOrdinaryDifferentialOperator2| (QREFELT $ 7)
                                                                  (|Fraction|
                                                                   (QREFELT $
                                                                            7)))
                           |uts|)
            . #4#)
      (LETT |solver| (|UnivariateTaylorSeriesODESolver| (QREFELT $ 6) |uts|)
            . #4#)
      (LETT |dd|
            (SPADCALL |d|
                      (|compiledLookupCheck| 'UP2UTS
                                             (LIST (|devaluate| |uts|)
                                                   (|devaluate| (ELT $ 7)))
                                             |tools|))
            . #4#)
      (LETT |f|
            (SPADCALL |op|
                      (|compiledLookupCheck| 'LODO2FUN
                                             (LIST
                                              (LIST '|Mapping|
                                                    (|devaluate| |uts|)
                                                    (LIST '|List|
                                                          (|devaluate| |uts|)))
                                              (LIST
                                               '|LinearOrdinaryDifferentialOperator2|
                                               (|devaluate| (ELT $ 7))
                                               (LIST '|Fraction|
                                                     (|devaluate| (ELT $ 7)))))
                                             |tools|))
            . #4#)
      (LETT |q| (SPADCALL |op| (QREFELT $ 38)) . #4#)
      (LETT |e| (|ODERAT;unitlist| 1 |q| $) . #4#)
      (LETT |hom|
            (PROGN
             (LETT #3# NIL . #4#)
             (SEQ (LETT |i| 1 . #4#) G190
                  (COND ((QSGREATERP |i| |q|) #5=(GO G191)))
                  (SEQ
                   (EXIT
                    (LETT #3#
                          (CONS
                           (SPADCALL
                            (SPADCALL
                             (SPADCALL |dd|
                                       (SPADCALL |f|
                                                 (|ODERAT;unitlist| |i| |q| $)
                                                 (|compiledLookupCheck| '|ode|
                                                                        (LIST
                                                                         (|devaluate|
                                                                          |uts|)
                                                                         (LIST
                                                                          '|Mapping|
                                                                          (|devaluate|
                                                                           |uts|)
                                                                          (LIST
                                                                           '|List|
                                                                           (|devaluate|
                                                                            |uts|)))
                                                                         (LIST
                                                                          '|List|
                                                                          (|devaluate|
                                                                           (ELT
                                                                            $
                                                                            6))))
                                                                        |solver|))
                                       (|compiledLookupCheck| '*
                                                              (LIST '$ '$ '$)
                                                              |uts|))
                             |n|
                             (|compiledLookupCheck| 'UTS2UP
                                                    (LIST
                                                     (|devaluate| (ELT $ 7))
                                                     (|devaluate| |uts|)
                                                     (LIST
                                                      '|NonNegativeInteger|))
                                                    |tools|))
                            |d| (QREFELT $ 91))
                           #3#)
                          . #4#)))
                  (LETT |i| (QSADD1 |i|) . #4#) #6=(GO G190) G191
                  (EXIT (NREVERSE0 #3#))))
            . #4#)
      (LETT |a1|
            (SPADCALL (SPADCALL (SPADCALL |op| (QREFELT $ 39)) (QREFELT $ 40))
                      (QREFELT $ 41))
            . #4#)
      (LETT |part|
            (PROGN
             (LETT #2# NIL . #4#)
             (SEQ (LETT |g| NIL . #4#) (LETT #1# |lg| . #4#) G190
                  (COND
                   ((OR (ATOM #1#) (PROGN (LETT |g| (CAR #1#) . #4#) NIL))
                    #5#))
                  (SEQ
                   (EXIT
                    (COND
                     ((COND
                       ((SPADCALL |g| (|spadConstant| $ 46) (QREFELT $ 60))
                        'NIL)
                       ('T 'T))
                      (LETT #2#
                            (CONS
                             (SPADCALL
                              (SPADCALL
                               (SPADCALL |dd|
                                         (SPADCALL
                                          (CONS #'|ODERAT;candidates!0|
                                                (VECTOR |f| |tools| |uts| $ |g|
                                                        |a1|))
                                          |e|
                                          (|compiledLookupCheck| '|ode|
                                                                 (LIST
                                                                  (|devaluate|
                                                                   |uts|)
                                                                  (LIST
                                                                   '|Mapping|
                                                                   (|devaluate|
                                                                    |uts|)
                                                                   (LIST
                                                                    '|List|
                                                                    (|devaluate|
                                                                     |uts|)))
                                                                  (LIST '|List|
                                                                        (|devaluate|
                                                                         (ELT $
                                                                              6))))
                                                                 |solver|))
                                         (|compiledLookupCheck| '*
                                                                (LIST '$ '$ '$)
                                                                |uts|))
                               |n|
                               (|compiledLookupCheck| 'UTS2UP
                                                      (LIST
                                                       (|devaluate| (ELT $ 7))
                                                       (|devaluate| |uts|)
                                                       (LIST
                                                        '|NonNegativeInteger|))
                                                      |tools|))
                              |d| (QREFELT $ 91))
                             #2#)
                            . #4#)))))
                  (LETT #1# (CDR #1#) . #4#) #6# G191 (EXIT (NREVERSE0 #2#))))
            . #4#)
      (EXIT (CONS |hom| |part|)))))) 

(DEFUN |ODERAT;candidates!0| (|l1| $$)
  (PROG (|a1| |g| $ |uts| |tools| |f|)
    (LETT |a1| (QREFELT $$ 5) . #1=(|ODERAT;candidates|))
    (LETT |g| (QREFELT $$ 4) . #1#)
    (LETT $ (QREFELT $$ 3) . #1#)
    (LETT |uts| (QREFELT $$ 2) . #1#)
    (LETT |tools| (QREFELT $$ 1) . #1#)
    (LETT |f| (QREFELT $$ 0) . #1#)
    (RETURN
     (PROGN
      (SPADCALL
       (SPADCALL (SPADCALL |a1| |g| (QREFELT $ 42))
                 (|compiledLookupCheck| 'RF2UTS
                                        (LIST (|devaluate| |uts|)
                                              (LIST '|Fraction|
                                                    (|devaluate| (ELT $ 7))))
                                        |tools|))
       (SPADCALL |l1| |f|) (|compiledLookupCheck| '+ (LIST '$ '$ '$) |uts|)))))) 

(DEFUN |ODERAT;nzero?| (|v| $)
  (PROG (#1=#:G1935 #2=#:G1937 #3=#:G1938 |i|)
    (RETURN
     (SEQ
      (EXIT
       (SEQ
        (SEQ
         (EXIT
          (SEQ (LETT |i| (SPADCALL |v| (QREFELT $ 92)) . #4=(|ODERAT;nzero?|))
               (LETT #3# (QVSIZE |v|) . #4#) G190
               (COND ((> |i| #3#) (GO G191)))
               (SEQ
                (EXIT
                 (COND
                  ((NULL (SPADCALL (QAREF1O |v| |i| 1) (QREFELT $ 93)))
                   (PROGN
                    (LETT #1# (PROGN (LETT #2# 'T . #4#) (GO #2#)) . #4#)
                    (GO #1#))))))
               (LETT |i| (+ |i| 1) . #4#) (GO G190) G191 (EXIT NIL)))
         #1# (EXIT #1#))
        (EXIT 'NIL)))
      #2# (EXIT #2#))))) 

(DEFUN |ODERAT;UPfact| (|n| $)
  (PROG (#1=#:G1942 #2=#:G1941 #3=#:G1943 #4=#:G1947 #5=#:G1940 |i| |z|)
    (RETURN
     (SEQ
      (COND ((ZEROP |n|) (|spadConstant| $ 20))
            (#6='T
             (SEQ
              (LETT |z| (SPADCALL (|spadConstant| $ 19) 1 (QREFELT $ 94))
                    . #7=(|ODERAT;UPfact|))
              (EXIT
               (PROGN
                (LETT #1# NIL . #7#)
                (SEQ (LETT |i| 0 . #7#)
                     (LETT #4#
                           (PROG1 (LETT #5# (- |n| 1) . #7#)
                             (|check-subtype| (>= #5# 0)
                                              '(|NonNegativeInteger|) #5#))
                           . #7#)
                     G190 (COND ((QSGREATERP |i| #4#) (GO G191)))
                     (SEQ
                      (EXIT
                       (PROGN
                        (LETT #3#
                              (SPADCALL |z|
                                        (SPADCALL (SPADCALL |i| (QREFELT $ 86))
                                                  (QREFELT $ 95))
                                        (QREFELT $ 96))
                              . #7#)
                        (COND
                         (#1#
                          (LETT #2# (SPADCALL #2# #3# (QREFELT $ 83)) . #7#))
                         ('T
                          (PROGN (LETT #2# #3# . #7#) (LETT #1# 'T . #7#)))))))
                     (LETT |i| (QSADD1 |i|) . #7#) (GO G190) G191 (EXIT NIL))
                (COND (#1# #2#) (#6# (|spadConstant| $ 20)))))))))))) 

(DEFUN |ODERAT;infMuLambda| (|l| $)
  (PROG (|lf| |lamb| |mup| |m| |d| |a|)
    (RETURN
     (SEQ
      (LETT |lamb|
            (LIST
             (LETT |d| (SPADCALL |l| (QREFELT $ 38))
                   . #1=(|ODERAT;infMuLambda|)))
            . #1#)
      (LETT |lf| (LIST (LETT |a| (SPADCALL |l| (QREFELT $ 39)) . #1#)) . #1#)
      (LETT |mup| (- (SPADCALL |a| (QREFELT $ 14)) |d|) . #1#)
      (SEQ G190
           (COND
            ((NULL
              (SEQ (LETT |l| (SPADCALL |l| (QREFELT $ 97)) . #1#)
                   (EXIT
                    (COND
                     ((SPADCALL |l| (|spadConstant| $ 45) (QREFELT $ 98)) 'NIL)
                     ('T 'T)))))
             (GO G191)))
           (SEQ (LETT |a| (SPADCALL |l| (QREFELT $ 39)) . #1#)
                (LETT |m|
                      (- (SPADCALL |a| (QREFELT $ 14))
                         (LETT |d| (SPADCALL |l| (QREFELT $ 38)) . #1#))
                      . #1#)
                (EXIT
                 (COND
                  ((< |mup| |m|)
                   (SEQ (LETT |mup| |m| . #1#) (LETT |lamb| (LIST |d|) . #1#)
                        (EXIT (LETT |lf| (LIST |a|) . #1#))))
                  ((EQL |m| |mup|)
                   (SEQ (LETT |lamb| (CONS |d| |lamb|) . #1#)
                        (EXIT (LETT |lf| (CONS |a| |lf|) . #1#)))))))
           NIL (GO G190) G191 (EXIT NIL))
      (EXIT (VECTOR |mup| |lamb| |lf|)))))) 

(DEFUN |ODERAT;infIndicialEquation| (|lambda| |lf| $)
  (PROG (|ans| #1=#:G1959 |i| #2=#:G1960 |f|)
    (RETURN
     (SEQ
      (LETT |ans| (|spadConstant| $ 44) . #3=(|ODERAT;infIndicialEquation|))
      (SEQ (LETT |f| NIL . #3#) (LETT #2# |lf| . #3#) (LETT |i| NIL . #3#)
           (LETT #1# |lambda| . #3#) G190
           (COND
            ((OR (ATOM #1#) (PROGN (LETT |i| (CAR #1#) . #3#) NIL) (ATOM #2#)
                 (PROGN (LETT |f| (CAR #2#) . #3#) NIL))
             (GO G191)))
           (SEQ
            (EXIT
             (LETT |ans|
                   (SPADCALL |ans|
                             (SPADCALL
                              (SPADCALL (|ODERAT;evenodd| |i| $)
                                        (SPADCALL |f| (QREFELT $ 99))
                                        (QREFELT $ 100))
                              (|ODERAT;UPfact| |i| $) (QREFELT $ 101))
                             (QREFELT $ 96))
                   . #3#)))
           (LETT #1# (PROG1 (CDR #1#) (LETT #2# (CDR #2#) . #3#)) . #3#)
           (GO G190) G191 (EXIT NIL))
      (EXIT |ans|))))) 

(DEFUN |ODERAT;infBound| (|l| |lg| $)
  (PROG (#1=#:G1968 |m| |mm| #2=#:G1972 |g| #3=#:G1964 |n| |rec|)
    (RETURN
     (SEQ (LETT |rec| (|ODERAT;infMuLambda| |l| $) . #4=(|ODERAT;infBound|))
          (LETT |n|
                (MIN (- (- (SPADCALL |l| (QREFELT $ 38))) 1)
                     (SPADCALL
                      (|ODERAT;infIndicialEquation| (QVELT |rec| 1)
                       (QVELT |rec| 2) $)
                      (QREFELT $ 103)))
                . #4#)
          (SEQ G190
               (COND
                ((NULL
                  (COND ((NULL |lg|) 'NIL)
                        ('T (SPADCALL (|SPADfirst| |lg|) (QREFELT $ 59)))))
                 #5=(GO G191)))
               (SEQ (EXIT (LETT |lg| (CDR |lg|) . #4#))) NIL #6=(GO G190) G191
               (EXIT NIL))
          (EXIT
           (COND
            ((NULL |lg|)
             (PROG1 (LETT #3# (- |n|) . #4#)
               (|check-subtype| (>= #3# 0) '(|NonNegativeInteger|) #3#)))
            ('T
             (SEQ (LETT |m| (|ODERAT;infOrder| (|SPADfirst| |lg|) $) . #4#)
                  (SEQ (LETT |g| NIL . #4#) (LETT #2# (CDR |lg|) . #4#) G190
                       (COND
                        ((OR (ATOM #2#) (PROGN (LETT |g| (CAR #2#) . #4#) NIL))
                         #5#))
                       (SEQ
                        (EXIT
                         (COND
                          ((NULL (SPADCALL |g| (QREFELT $ 59)))
                           (SEQ (LETT |mm| (|ODERAT;infOrder| |g| $) . #4#)
                                (EXIT
                                 (COND
                                  ((< |mm| |m|) (LETT |m| |mm| . #4#)))))))))
                       (LETT #2# (CDR #2#) . #4#) #6# G191 (EXIT NIL))
                  (EXIT
                   (PROG1
                       (LETT #1#
                             (-
                              (MIN |n|
                                   (+
                                    (- (QVELT |rec| 0)
                                       (SPADCALL (SPADCALL |l| (QREFELT $ 39))
                                                 (QREFELT $ 14)))
                                    |m|)))
                             . #4#)
                     (|check-subtype| (>= #1# 0) '(|NonNegativeInteger|)
                                      #1#))))))))))) 

(DEFUN |ODERAT;makeDot| (|v| |bas| $)
  (PROG (|ans| |i| #1=#:G1976 |b|)
    (RETURN
     (SEQ (LETT |ans| (|spadConstant| $ 46) . #2=(|ODERAT;makeDot|))
          (SEQ (LETT |b| NIL . #2#) (LETT #1# |bas| . #2#) (LETT |i| 1 . #2#)
               G190
               (COND
                ((OR (ATOM #1#) (PROGN (LETT |b| (CAR #1#) . #2#) NIL))
                 (GO G191)))
               (SEQ
                (EXIT
                 (LETT |ans|
                       (SPADCALL |ans|
                                 (SPADCALL
                                  (SPADCALL (SPADCALL |v| |i| (QREFELT $ 104))
                                            (QREFELT $ 95))
                                  |b| (QREFELT $ 105))
                                 (QREFELT $ 74))
                       . #2#)))
               (LETT |i| (PROG1 (QSADD1 |i|) (LETT #1# (CDR #1#) . #2#)) . #2#)
               (GO G190) G191 (EXIT NIL))
          (EXIT |ans|))))) 

(DEFUN |ODERAT;ratDsolve;LodoFR;16| (|op| |g| $)
  (PROG (|rec|)
    (RETURN
     (SEQ
      (LETT |rec| (SPADCALL |op| (LIST |g|) (QREFELT $ 79))
            |ODERAT;ratDsolve;LodoFR;16|)
      (EXIT (|ODERAT;ratDsolve0| (QCAR |rec|) (|SPADfirst| (QCDR |rec|)) $)))))) 

(DEFUN |ODERAT;ratDsolve;LodoLR;17| (|op| |lg| $)
  (PROG (|rec|)
    (RETURN
     (SEQ
      (LETT |rec| (SPADCALL |op| |lg| (QREFELT $ 79))
            |ODERAT;ratDsolve;LodoLR;17|)
      (EXIT (|ODERAT;ratDsolve1| (QCAR |rec|) (QCDR |rec|) $)))))) 

(DEFUN |ODERAT;ratDsolve;LodoFR;18| (|op| |g| $)
  (PROG (#1=#:G1992 |c|)
    (RETURN
     (COND
      ((SPADCALL
        (LETT |c| (SPADCALL |op| (QREFELT $ 110))
              . #2=(|ODERAT;ratDsolve;LodoFR;18|))
        (QREFELT $ 111))
       (|ODERAT;ratDsolve0| |op| |g| $))
      ('T
       (|ODERAT;ratDsolve0|
        (PROG2
            (LETT #1# (SPADCALL |op| |c| (QREFELT $ 113)) . #2#)
            (QCDR #1#)
          (|check-union| (QEQCAR #1# 0)
                         (|LinearOrdinaryDifferentialOperator2| (QREFELT $ 7)
                                                                (|Fraction|
                                                                 (QREFELT $
                                                                          7)))
                         #1#))
        (SPADCALL (SPADCALL (SPADCALL |c| (QREFELT $ 40)) (QREFELT $ 41)) |g|
                  (QREFELT $ 42))
        $)))))) 

(DEFUN |ODERAT;ratDsolve;LodoLR;19| (|op| |lg| $)
  (PROG (#1=#:G2004 |g| #2=#:G2003 #3=#:G1998 |c|)
    (RETURN
     (SEQ
      (COND
       ((SPADCALL
         (LETT |c| (SPADCALL |op| (QREFELT $ 110))
               . #4=(|ODERAT;ratDsolve;LodoLR;19|))
         (QREFELT $ 111))
        (|ODERAT;ratDsolve1| |op| |lg| $))
       ('T
        (|ODERAT;ratDsolve1|
         (PROG2
             (LETT #3# (SPADCALL |op| |c| (QREFELT $ 113)) . #4#)
             (QCDR #3#)
           (|check-union| (QEQCAR #3# 0)
                          (|LinearOrdinaryDifferentialOperator2| (QREFELT $ 7)
                                                                 (|Fraction|
                                                                  (QREFELT $
                                                                           7)))
                          #3#))
         (PROGN
          (LETT #2# NIL . #4#)
          (SEQ (LETT |g| NIL . #4#) (LETT #1# |lg| . #4#) G190
               (COND
                ((OR (ATOM #1#) (PROGN (LETT |g| (CAR #1#) . #4#) NIL))
                 (GO G191)))
               (SEQ
                (EXIT
                 (LETT #2#
                       (CONS
                        (SPADCALL
                         (SPADCALL (SPADCALL |c| (QREFELT $ 40))
                                   (QREFELT $ 41))
                         |g| (QREFELT $ 42))
                        #2#)
                       . #4#)))
               (LETT #1# (CDR #1#) . #4#) (GO G190) G191
               (EXIT (NREVERSE0 #2#))))
         $))))))) 

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

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

(MAKEPROP '|RationalLODE| '|infovec|
          (LIST
           '#(NIL NIL NIL NIL NIL NIL (|local| |#1|) (|local| |#2|) (|Symbol|)
              (0 . |new|) '|dummy| (|Fraction| 7) (4 . |denom|)
              (|NonNegativeInteger|) (9 . |degree|) (14 . |numer|) (|Boolean|)
              (|Integer|) (19 . |even?|) (24 . |One|) (28 . |One|) (32 . -)
              (|LinearOrdinaryDifferentialOperator2| 7 11) (|List| 11)
              (|PrimitiveRatDE| 6 7 22 78) (37 . |denomLODE|) (43 . |elt|)
              (49 . |elt|) (55 . -) (61 . |concat|) (|List| 23) (|Matrix| 11)
              (67 . |matrix|) (|Matrix| 7) (|Matrix| $) (72 . |reducedSystem|)
              (|Matrix| 6) (77 . |reducedSystem|) (82 . |degree|)
              (87 . |leadingCoefficient|) (92 . |coerce|) (97 . |inv|)
              (102 . *) (108 . |Zero|) (112 . |Zero|) (116 . |Zero|)
              (120 . |Zero|) (|Fraction| 17) (124 . |Zero|)
              (128 . |minimumDegree|) (133 . |monomial|)
              (|Record| (|:| |quotient| $) (|:| |remainder| $))
              (139 . |monicRightDivide|) (145 . |One|) (|Union| 11 '"failed")
              (|RationalIntegration| 6 7) (149 . |infieldint|)
              (|Union| 7 '"failed") (154 . |denomLODE|) (160 . |zero?|)
              (165 . =) (171 . |ncols|) (|Vector| 11) (176 . |vector|)
              (|Record| (|:| |mat| 33) (|:| |vec| (|Vector| 7))) (|Vector| $)
              (181 . |reducedSystem|) (|Record| (|:| |mat| 36) (|:| |vec| 71))
              (187 . |reducedSystem|) (|Union| 71 '"failed")
              (|Record| (|:| |particular| 69) (|:| |basis| (|List| 71)))
              (|Vector| 6) (|LinearSystemMatrixPackage| 6 71 71 36)
              (193 . |solve|) (199 . +) (205 . |concat!|)
              |ODERAT;indicialEquationAtInfinity;LodoUP;5|
              (|Record| (|:| |eq| 22) (|:| |rh| 23))
              (|LinearOrdinaryDifferentialOperator1| 11)
              (211 . |splitDenominator|)
              |ODERAT;indicialEquationAtInfinity;LodoUP;6|
              (|InnerCommonDenominator| 7 11 (|List| 7) 23)
              (217 . |commonDenominator|) (222 . *) (228 . |coefficient|)
              (234 . =) (240 . |coerce|) (245 . |elt|) (251 . |setelt|)
              (|List| 6) (258 . |parts|) (263 . /) (269 . |minIndex|)
              (274 . |zero?|) (279 . |monomial|) (285 . |coerce|) (290 . +)
              (296 . |reductum|) (301 . =) (307 . |leadingCoefficient|)
              (312 . *) (318 . *) (|BoundIntegerRoots| 6 7)
              (324 . |integerBound|) (329 . |elt|) (335 . *)
              (|Record| (|:| |particular| 54) (|:| |basis| 23))
              |ODERAT;ratDsolve;LodoFR;16|
              (|Record| (|:| |basis| 23) (|:| |mat| 36))
              |ODERAT;ratDsolve;LodoLR;17| (341 . |content|) (346 . |unit?|)
              (|Union| $ '"failed") (351 . |exquo|)
              |ODERAT;ratDsolve;LodoFR;18| |ODERAT;ratDsolve;LodoLR;19|)
           '#(|ratDsolve| 357 |indicialEquationAtInfinity| 381) 'NIL
           (CONS (|makeByteWordVec2| 1 'NIL)
                 (CONS '#()
                       (CONS '#()
                             (|makeByteWordVec2| 115
                                                 '(0 8 0 9 1 11 7 0 12 1 7 13 0
                                                   14 1 11 7 0 15 1 17 16 0 18
                                                   0 6 0 19 0 7 0 20 1 6 0 0 21
                                                   2 24 7 22 23 25 2 22 11 0 11
                                                   26 2 23 11 0 17 27 2 11 0 0
                                                   0 28 2 23 0 0 0 29 1 31 0 30
                                                   32 1 11 33 34 35 1 7 36 34
                                                   37 1 22 13 0 38 1 22 7 0 39
                                                   1 11 0 7 40 1 11 0 0 41 2 11
                                                   0 0 0 42 0 6 0 43 0 7 0 44 0
                                                   22 0 45 0 11 0 46 0 47 0 48
                                                   1 22 13 0 49 2 22 0 7 13 50
                                                   2 22 51 0 0 52 0 11 0 53 1
                                                   55 54 11 56 2 24 57 22 11 58
                                                   1 11 16 0 59 2 11 16 0 0 60
                                                   1 36 13 0 61 1 62 0 23 63 2
                                                   11 64 34 65 66 2 7 67 34 65
                                                   68 2 72 70 36 71 73 2 11 0 0
                                                   0 74 2 23 0 0 0 75 2 24 77
                                                   78 23 79 1 81 7 23 82 2 7 0
                                                   0 0 83 2 7 6 0 13 84 2 6 16
                                                   0 0 85 1 6 0 17 86 2 7 6 0 6
                                                   87 3 71 6 0 17 6 88 1 71 89
                                                   0 90 2 11 0 7 7 91 1 71 17 0
                                                   92 1 6 16 0 93 2 7 0 6 13 94
                                                   1 7 0 6 95 2 7 0 0 0 96 1 22
                                                   0 0 97 2 22 16 0 0 98 1 7 6
                                                   0 99 2 6 0 0 0 100 2 7 0 6 0
                                                   101 1 102 17 7 103 2 71 6 0
                                                   17 104 2 11 0 7 0 105 1 22 7
                                                   0 110 1 7 16 0 111 2 22 112
                                                   0 7 113 2 0 106 78 11 107 2
                                                   0 106 22 11 114 2 0 108 78
                                                   23 109 2 0 108 22 23 115 1 0
                                                   7 22 76 1 0 7 78 80)))))
           '|lookupComplete|)) 
