
(/VERSIONCHECK 2) 

(DEFUN |LODEEF;smpxpart| (|p| |x| |l| |lp| $)
  (|LODEEF;downmp| (SPADCALL (|LODEEF;upmp| |p| |l| $) (QREFELT $ 16))
      |l| |lp| $)) 

(DEFUN |LODEEF;downmp| (|p| |l| |lp| $)
  (SPADCALL (SPADCALL |p| |l| |lp| (QREFELT $ 19)) (QREFELT $ 21))) 

(DEFUN |LODEEF;homosolve| (|lf| |op| |sols| |k| |x| $)
  (|LODEEF;homosolve1| |lf| (|LODEEF;ratlogsol| |op| |sols| |k| |x| $)
      |k| |x| $)) 

(DEFUN |LODEEF;algSolve| (|op| |g| |k| |l| |x| $)
  (PROG (|kx| |rec| |z| |lk| |lv| |u| |rc| |kz| #0=#:G1858 |f|
              #1=#:G1859)
    (RETURN
      (SEQ (COND
             ((QEQCAR (SPADCALL
                          (LETT |kx|
                                (SPADCALL |k| |l| |x| (QREFELT $ 24))
                                . #2=(|LODEEF;algSolve|))
                          (QREFELT $ 26))
                      0)
              (|LODEEF;palgSolve| |op| |g| |kx| |k| |x| $))
             ((SPADCALL (SPADCALL |kx| (QREFELT $ 28)) (QREFELT $ 12)
                  (QREFELT $ 30))
              (SEQ (LETT |rec|
                         (SPADCALL (SPADCALL |kx| (QREFELT $ 32))
                             (SPADCALL |k| (QREFELT $ 32))
                             (QREFELT $ 35)) . #2#)
                   (LETT |z|
                         (SPADCALL (QVELT |rec| 3) (QREFELT $ 37)) . #2#)
                   (LETT |lk| (LIST |kx| |k|) . #2#)
                   (LETT |lv|
                         (LIST (SPADCALL (QVELT |rec| 1) |z|
                                   (QREFELT $ 39))
                               (SPADCALL (QVELT |rec| 2) |z|
                                   (QREFELT $ 39))) . #2#)
                   (LETT |u|
                         (SPADCALL
                             (|LODEEF;localmap|
                                 (CONS #'|LODEEF;algSolve!0|
                                       (VECTOR $ |lv| |lk|))
                                 |op| $)
                             (SPADCALL |g| |lk| |lv| (QREFELT $ 42))
                             |x| (QREFELT $ 45)) . #2#)
                   (EXIT (COND
                           ((QEQCAR |u| 1) (CONS 1 "failed"))
                           ('T
                            (SEQ (LETT |rc| (QCDR |u|) . #2#)
                                 (LETT |kz|
                                       (SPADCALL |z| (QREFELT $ 46)) . #2#)
                                 (EXIT (CONS 0
                                        (CONS
                                         (SPADCALL (QCAR |rc|) |kz|
                                          (QVELT |rec| 0)
                                          (QREFELT $ 47))
                                         (PROGN
                                           (LETT #0# NIL . #2#)
                                           (SEQ (LETT |f| NIL . #2#)
                                            (LETT #1#
                                             (QCDR |rc|) . #2#)
                                            G190
                                            (COND
                                              ((OR (ATOM #1#)
                                                (PROGN
                                                  (LETT |f|
                                                   (CAR #1#) . #2#)
                                                  NIL))
                                               (GO G191)))
                                            (SEQ
                                             (EXIT
                                              (LETT #0#
                                               (CONS
                                                (SPADCALL |f| |kz|
                                                 (QVELT |rec| 0)
                                                 (QREFELT $ 47))
                                                #0#) . #2#)))
                                            (LETT #1# (CDR #1#) . #2#)
                                            (GO G190) G191
                                            (EXIT (NREVERSE0 #0#)))))))))))))
             ('T (|LODEEF;lastChance| |op| |g| |x| $))))))) 

(DEFUN |LODEEF;algSolve!0| (|#1| $$)
  (SPADCALL |#1| (QREFELT $$ 2) (QREFELT $$ 1)
      (QREFELT (QREFELT $$ 0) 42))) 

(DEFUN |LODEEF;doVarParams| (|eq| |g| |bas| |x| $)
  (PROG (|u|)
    (RETURN
      (SEQ (LETT |u|
                 (SPADCALL |eq| |g| |bas|
                     (CONS #'|LODEEF;doVarParams!0| (VECTOR $ |x|))
                     (QREFELT $ 54))
                 |LODEEF;doVarParams|)
           (EXIT (COND
                   ((QEQCAR |u| 1)
                    (|LODEEF;lastChance| |eq| |g| |x| $))
                   ('T (CONS 0 (CONS (QCDR |u|) |bas|))))))))) 

(DEFUN |LODEEF;doVarParams!0| (|#1| $$)
  (SPADCALL |#1| (QREFELT $$ 1) (QREFELT (QREFELT $$ 0) 49))) 

(DEFUN |LODEEF;lastChance| (|op| |g| |x| $)
  (COND
    ((EQL (SPADCALL |op| (QREFELT $ 56)) 1)
     (CONS 0
           (|LODEEF;firstOrder| (SPADCALL |op| 0 (QREFELT $ 60))
               (SPADCALL |op| (QREFELT $ 61)) |g| |x| $)))
    ('T (CONS 1 "failed")))) 

(DEFUN |LODEEF;firstOrder| (|a0| |a1| |g| |x| $)
  (PROG (|h|)
    (RETURN
      (SEQ (LETT |h|
                 (|LODEEF;xpart|
                     (SPADCALL
                         (SPADCALL (SPADCALL |a0| |a1| (QREFELT $ 62))
                             (QREFELT $ 63))
                         |x| (QREFELT $ 64))
                     |x| $)
                 |LODEEF;firstOrder|)
           (EXIT (CONS (SPADCALL |h|
                           (SPADCALL
                               (SPADCALL
                                   (SPADCALL |g| |h| (QREFELT $ 62))
                                   |a1| (QREFELT $ 62))
                               |x| (QREFELT $ 49))
                           (QREFELT $ 65))
                       (LIST |h|))))))) 

(DEFUN |LODEEF;xpart| (|f| |x| $)
  (PROG (|l| #0=#:G1885 |k| #1=#:G1886 |lp|)
    (RETURN
      (SEQ (LETT |l|
                 (NREVERSE
                     (SPADCALL (SPADCALL |f| (QREFELT $ 66)) |x|
                         (QREFELT $ 67)))
                 . #2=(|LODEEF;xpart|))
           (LETT |lp|
                 (PROGN
                   (LETT #0# NIL . #2#)
                   (SEQ (LETT |k| NIL . #2#) (LETT #1# |l| . #2#) G190
                        (COND
                          ((OR (ATOM #1#)
                               (PROGN (LETT |k| (CAR #1#) . #2#) NIL))
                           (GO G191)))
                        (SEQ (EXIT (LETT #0#
                                    (CONS (SPADCALL |k| (QREFELT $ 68))
                                     #0#) . #2#)))
                        (LETT #1# (CDR #1#) . #2#) (GO G190) G191
                        (EXIT (NREVERSE0 #0#)))) . #2#)
           (EXIT (SPADCALL
                     (|LODEEF;smpxpart| (SPADCALL |f| (QREFELT $ 70))
                         |x| |l| |lp| $)
                     (|LODEEF;smpxpart| (SPADCALL |f| (QREFELT $ 71))
                         |x| |l| |lp| $)
                     (QREFELT $ 72))))))) 

(DEFUN |LODEEF;upmp| (|p| |l| $)
  (PROG (|k| |ans| |up|)
    (RETURN
      (SEQ (COND
             ((NULL |l|) (SPADCALL |p| (QREFELT $ 73)))
             ('T
              (SEQ (LETT |up|
                         (SPADCALL |p|
                             (LETT |k| (|SPADfirst| |l|)
                                   . #0=(|LODEEF;upmp|))
                             (QREFELT $ 74)) . #0#)
                   (LETT |l| (CDR |l|) . #0#)
                   (LETT |ans| (|spadConstant| $ 75) . #0#)
                   (SEQ G190
                        (COND
                          ((NULL (COND
                                   ((SPADCALL |up|
                                     (|spadConstant| $ 77)
                                     (QREFELT $ 78))
                                    'NIL)
                                   ('T 'T)))
                           (GO G191)))
                        (SEQ (LETT |ans|
                                   (SPADCALL |ans|
                                    (SPADCALL
                                     (|LODEEF;upmp|
                                      (SPADCALL |up| (QREFELT $ 79))
                                      |l| $)
                                     |k| (SPADCALL |up| (QREFELT $ 80))
                                     (QREFELT $ 81))
                                    (QREFELT $ 82)) . #0#)
                             (EXIT (LETT |up|
                                    (SPADCALL |up| (QREFELT $ 83)) . #0#)))
                        NIL (GO G190) G191 (EXIT NIL))
                   (EXIT |ans|)))))))) 

(DEFUN |LODEEF;multint| (|a| |l| |x| $)
  (PROG (|g| #0=#:G1895)
    (RETURN
      (SEQ (SEQ (LETT |g| NIL . #1=(|LODEEF;multint|))
                (LETT #0# |l| . #1#) G190
                (COND
                  ((OR (ATOM #0#)
                       (PROGN (LETT |g| (CAR #0#) . #1#) NIL))
                   (GO G191)))
                (SEQ (EXIT (LETT |a|
                                 (SPADCALL |g|
                                     (|LODEEF;xpart|
                                      (SPADCALL |a| |x| (QREFELT $ 49))
                                      |x| $)
                                     (QREFELT $ 65)) . #1#)))
                (LETT #0# (CDR #0#) . #1#) (GO G190) G191 (EXIT NIL))
           (EXIT |a|))))) 

(DEFUN |LODEEF;expsols| (|op| |k| |x| $)
  (PROG (#0=#:G1901 |h| #1=#:G1902)
    (RETURN
      (SEQ (COND
             ((EQL (SPADCALL |op| (QREFELT $ 85)) 1)
              (QCDR (|LODEEF;firstOrder|
                        (SPADCALL (SPADCALL |op| 0 (QREFELT $ 87)) |k|
                            (QREFELT $ 89))
                        (SPADCALL (SPADCALL |op| (QREFELT $ 90)) |k|
                            (QREFELT $ 89))
                        (|spadConstant| $ 59) |x| $)))
             ('T
              (PROGN
                (LETT #0# NIL . #2=(|LODEEF;expsols|))
                (SEQ (LETT |h| NIL . #2#)
                     (LETT #1#
                           (SPADCALL |op| (ELT $ 93) (QREFELT $ 97)) . #2#)
                     G190
                     (COND
                       ((OR (ATOM #1#)
                            (PROGN (LETT |h| (CAR #1#) . #2#) NIL))
                        (GO G191)))
                     (SEQ (EXIT (LETT #0#
                                      (CONS
                                       (|LODEEF;xpart|
                                        (SPADCALL
                                         (SPADCALL |h| |k|
                                          (QREFELT $ 89))
                                         |x| (QREFELT $ 64))
                                        |x| $)
                                       #0#) . #2#)))
                     (LETT #1# (CDR #1#) . #2#) (GO G190) G191
                     (EXIT (NREVERSE0 #0#)))))))))) 

(DEFUN |LODEEF;ratlogsol| (|oper| |sols| |k| |x| $)
  (PROG (#0=#:G1913 #1=#:G1914 |bas| |rec| |le| #2=#:G1915 #3=#:G1916
            |int| #4=#:G1917 |h| #5=#:G1918 #6=#:G1919 |e| #7=#:G1920)
    (RETURN
      (SEQ (LETT |bas|
                 (PROGN
                   (LETT #0# NIL . #8=(|LODEEF;ratlogsol|))
                   (SEQ (LETT |h| NIL . #8#) (LETT #1# |sols| . #8#)
                        G190
                        (COND
                          ((OR (ATOM #1#)
                               (PROGN (LETT |h| (CAR #1#) . #8#) NIL))
                           #9=(GO G191)))
                        (SEQ (EXIT (LETT #0#
                                    (CONS
                                     (|LODEEF;xpart|
                                      (SPADCALL |h| |k| (QREFELT $ 89))
                                      |x| $)
                                     #0#) . #8#)))
                        (LETT #1# (CDR #1#) . #8#) #10=(GO G190) G191
                        (EXIT (NREVERSE0 #0#)))) . #8#)
           (EXIT (COND
                   ((EQL (SPADCALL |oper| (QREFELT $ 85))
                         (LENGTH |bas|))
                    |bas|)
                   ('T
                    (SEQ (LETT |rec|
                               (SPADCALL |oper| |sols| (QREFELT $ 100)) . #8#)
                         (LETT |le|
                               (|LODEEF;expsols| (QCAR |rec|) |k| |x|
                                   $) . #8#)
                         (LETT |int|
                               (PROGN
                                 (LETT #2# NIL . #8#)
                                 (SEQ (LETT |h| NIL . #8#)
                                      (LETT #3# (QCDR |rec|) . #8#)
                                      G190
                                      (COND
                                        ((OR (ATOM #3#)
                                          (PROGN
                                            (LETT |h| (CAR #3#) . #8#)
                                            NIL))
                                         #9#))
                                      (SEQ
                                       (EXIT
                                        (LETT #2#
                                         (CONS
                                          (|LODEEF;xpart|
                                           (SPADCALL |h| |k|
                                            (QREFELT $ 89))
                                           |x| $)
                                          #2#) . #8#)))
                                      (LETT #3# (CDR #3#) . #8#) #10#
                                      G191 (EXIT (NREVERSE0 #2#)))) . #8#)
                         (EXIT (SPADCALL
                                   (PROGN
                                     (LETT #4# NIL . #8#)
                                     (SEQ (LETT |h| NIL . #8#)
                                      (LETT #5# |sols| . #8#) G190
                                      (COND
                                        ((OR (ATOM #5#)
                                          (PROGN
                                            (LETT |h| (CAR #5#) . #8#)
                                            NIL))
                                         #9#))
                                      (SEQ
                                       (EXIT
                                        (LETT #4#
                                         (CONS
                                          (|LODEEF;xpart|
                                           (SPADCALL |h| |k|
                                            (QREFELT $ 89))
                                           |x| $)
                                          #4#) . #8#)))
                                      (LETT #5# (CDR #5#) . #8#) #10#
                                      G191 (EXIT (NREVERSE0 #4#))))
                                   (PROGN
                                     (LETT #6# NIL . #8#)
                                     (SEQ (LETT |e| NIL . #8#)
                                      (LETT #7# |le| . #8#) G190
                                      (COND
                                        ((OR (ATOM #7#)
                                          (PROGN
                                            (LETT |e| (CAR #7#) . #8#)
                                            NIL))
                                         #9#))
                                      (SEQ
                                       (EXIT
                                        (LETT #6#
                                         (CONS
                                          (|LODEEF;multint| |e| |int|
                                           |x| $)
                                          #6#) . #8#)))
                                      (LETT #7# (CDR #7#) . #8#) #10#
                                      G191 (EXIT (NREVERSE0 #6#))))
                                   (QREFELT $ 101))))))))))) 

(DEFUN |LODEEF;homosolve1| (|oper| |sols| |k| |x| $)
  (PROG (#0=#:G1943 |n| |rec| #1=#:G1951 |h| #2=#:G1952 |int|
            #3=#:G1953 |e| #4=#:G1954)
    (RETURN
      (SEQ (COND
             ((ZEROP (LETT |n|
                           (PROG1 (LETT #0#
                                        (-
                                         (SPADCALL |oper|
                                          (QREFELT $ 56))
                                         (LENGTH |sols|))
                                        . #5=(|LODEEF;homosolve1|))
                             (|check-subtype| (>= #0# 0)
                                 '(|NonNegativeInteger|) #0#)) . #5#))
              |sols|)
             ('T
              (SEQ (LETT |rec|
                         (SPADCALL |oper| |sols| (QREFELT $ 104)) . #5#)
                   (LETT |int|
                         (PROGN
                           (LETT #1# NIL . #5#)
                           (SEQ (LETT |h| NIL . #5#)
                                (LETT #2# (QCDR |rec|) . #5#) G190
                                (COND
                                  ((OR (ATOM #2#)
                                    (PROGN
                                      (LETT |h| (CAR #2#) . #5#)
                                      NIL))
                                   #6=(GO G191)))
                                (SEQ (EXIT
                                      (LETT #1#
                                       (CONS (|LODEEF;xpart| |h| |x| $)
                                        #1#) . #5#)))
                                (LETT #2# (CDR #2#) . #5#) #7=(GO G190)
                                G191 (EXIT (NREVERSE0 #1#)))) . #5#)
                   (EXIT (SPADCALL |sols|
                             (PROGN
                               (LETT #3# NIL . #5#)
                               (SEQ (LETT |e| NIL . #5#)
                                    (LETT #4#
                                     (|LODEEF;norf1| (QCAR |rec|) |k|
                                      |x| |n| $) . #5#)
                                    G190
                                    (COND
                                      ((OR (ATOM #4#)
                                        (PROGN
                                          (LETT |e| (CAR #4#) . #5#)
                                          NIL))
                                       #6#))
                                    (SEQ
                                     (EXIT
                                      (LETT #3#
                                       (CONS
                                        (|LODEEF;multint| |e| |int| |x|
                                         $)
                                        #3#) . #5#)))
                                    (LETT #4# (CDR #4#) . #5#) #7# G191
                                    (EXIT (NREVERSE0 #3#))))
                             (QREFELT $ 101)))))))))) 

(DEFUN |LODEEF;norf1| (|op| |k| |x| |n| $)
  (PROG (|eq| |bas|)
    (RETURN
      (SEQ (COND
             ((EQL |n| 1)
              (QCDR (|LODEEF;firstOrder|
                        (SPADCALL |op| 0 (QREFELT $ 60))
                        (SPADCALL |op| (QREFELT $ 61))
                        (|spadConstant| $ 59) |x| $)))
             ((QEQCAR (SPADCALL
                          (SPADCALL
                              (SPADCALL (SPADCALL |op| (QREFELT $ 106))
                                  |x| (QREFELT $ 107))
                              (QREFELT $ 108))
                          (QREFELT $ 26))
                      0)
              (SEQ (LETT |eq| (|LODEEF;ulodo| |op| |k| $)
                         . #0=(|LODEEF;norf1|))
                   (EXIT (COND
                           ((EQL |n| 2)
                            (|LODEEF;kovode| |eq| |k| |x| $))
                           ('T
                            (SEQ (LETT |eq|
                                       (SPADCALL
                                        (SPADCALL |eq| (QREFELT $ 111))
                                        (QREFELT $ 112)) . #0#)
                                 (EXIT (COND
                                         ((EQL
                                           (SPADCALL |eq|
                                            (QREFELT $ 85))
                                           2)
                                          (COND
                                            ((NULL
                                              (LETT |bas|
                                               (|LODEEF;kovode| |eq|
                                                |k| |x| $) . #0#))
                                             NIL)
                                            ('T
                                             (|LODEEF;homosolve1| |op|
                                              |bas| |k| |x| $))))
                                         ('T NIL)))))))))
             ('T NIL)))))) 

(DEFUN |LODEEF;kovode| (|op| |k| |x| $)
  (PROG (|b| |a| |u| |p| |ba| #0=#:G1976 |e| #1=#:G1977 |y1|)
    (RETURN
      (SEQ (LETT |b| (SPADCALL |op| 1 (QREFELT $ 87))
                 . #2=(|LODEEF;kovode|))
           (LETT |a| (SPADCALL |op| 2 (QREFELT $ 87)) . #2#)
           (LETT |u|
                 (SPADCALL (SPADCALL |op| 0 (QREFELT $ 87)) |b| |a|
                     (ELT $ 93) (QREFELT $ 115)) . #2#)
           (EXIT (COND
                   ((QEQCAR |u| 1) NIL)
                   ('T
                    (SEQ (LETT |p|
                               (SPADCALL
                                   (CONS #'|LODEEF;kovode!0|
                                    (VECTOR $ |k|))
                                   (QCDR |u|) (QREFELT $ 119)) . #2#)
                         (LETT |ba|
                               (SPADCALL
                                   (SPADCALL
                                    (SPADCALL |b| |a| (QREFELT $ 120))
                                    (QREFELT $ 121))
                                   |k| (QREFELT $ 89)) . #2#)
                         (EXIT (COND
                                 ((EQL (SPADCALL |p| (QREFELT $ 122))
                                       2)
                                  (PROGN
                                    (LETT #0# NIL . #2#)
                                    (SEQ (LETT |e| NIL . #2#)
                                     (LETT #1#
                                      (SPADCALL |p| (QREFELT $ 123)) . #2#)
                                     G190
                                     (COND
                                       ((OR (ATOM #1#)
                                         (PROGN
                                           (LETT |e| (CAR #1#) . #2#)
                                           NIL))
                                        (GO G191)))
                                     (SEQ
                                      (EXIT
                                       (LETT #0#
                                        (CONS
                                         (|LODEEF;xpart|
                                          (SPADCALL
                                           (SPADCALL
                                            (SPADCALL |ba|
                                             (SPADCALL 2
                                              (QREFELT $ 125))
                                             (QREFELT $ 62))
                                            |e| (QREFELT $ 126))
                                           |x| (QREFELT $ 64))
                                          |x| $)
                                         #0#) . #2#)))
                                     (LETT #1# (CDR #1#) . #2#)
                                     (GO G190) G191
                                     (EXIT (NREVERSE0 #0#)))))
                                 ('T
                                  (SEQ (LETT |y1|
                                        (|LODEEF;xpart|
                                         (SPADCALL
                                          (SPADCALL
                                           (SPADCALL |ba|
                                            (SPADCALL 2
                                             (QREFELT $ 125))
                                            (QREFELT $ 62))
                                           (SPADCALL |p|
                                            (QREFELT $ 127))
                                           (QREFELT $ 126))
                                          |x| (QREFELT $ 64))
                                         |x| $) . #2#)
                                       (EXIT
                                        (LIST |y1|
                                         (SPADCALL |y1|
                                          (|LODEEF;xpart|
                                           (SPADCALL
                                            (SPADCALL
                                             (SPADCALL |ba| |x|
                                              (QREFELT $ 64))
                                             (SPADCALL |y1| 2
                                              (QREFELT $ 129))
                                             (QREFELT $ 62))
                                            |x| (QREFELT $ 49))
                                           |x| $)
                                          (QREFELT $ 65)))))))))))))))) 

(DEFUN |LODEEF;kovode!0| (|#1| $$)
  (SPADCALL |#1| (QREFELT $$ 1) (QREFELT (QREFELT $$ 0) 89))) 

(DEFUN |LODEEF;solve;LFSU;16| (|op| |g| |x| $)
  (PROG (|l| |k|)
    (RETURN
      (COND
        ((NULL (LETT |l|
                     (SPADCALL (SPADCALL |op| (QREFELT $ 106)) |x|
                         (QREFELT $ 107))
                     . #0=(|LODEEF;solve;LFSU;16|)))
         (CONS 0 (SPADCALL |op| |g| |x| (QREFELT $ 131))))
        ((QEQCAR (SPADCALL
                     (LETT |k| (SPADCALL |l| (QREFELT $ 108)) . #0#)
                     (QREFELT $ 26))
                 0)
         (|LODEEF;rfSolve| |op| |g| |k| |x| $))
        ((SPADCALL (SPADCALL |k| (QREFELT $ 28)) (QREFELT $ 12)
             (QREFELT $ 30))
         (|LODEEF;algSolve| |op| |g| |k| |l| |x| $))
        ('T (|LODEEF;lastChance| |op| |g| |x| $)))))) 

(DEFUN |LODEEF;ulodo| (|eq| |k| $)
  (PROG (|op|)
    (RETURN
      (SEQ (LETT |op| (|spadConstant| $ 132) . #0=(|LODEEF;ulodo|))
           (SEQ G190
                (COND
                  ((NULL (COND
                           ((SPADCALL |eq| (|spadConstant| $ 133)
                                (QREFELT $ 134))
                            'NIL)
                           ('T 'T)))
                   (GO G191)))
                (SEQ (LETT |op|
                           (SPADCALL |op|
                               (SPADCALL
                                   (SPADCALL
                                    (SPADCALL |eq| (QREFELT $ 61)) |k|
                                    (QREFELT $ 136))
                                   (SPADCALL |eq| (QREFELT $ 56))
                                   (QREFELT $ 137))
                               (QREFELT $ 138)) . #0#)
                     (EXIT (LETT |eq|
                                 (SPADCALL |eq| (QREFELT $ 139)) . #0#)))
                NIL (GO G190) G191 (EXIT NIL))
           (EXIT |op|))))) 

(DEFUN |LODEEF;rfSolve| (|eq| |g| |k| |x| $)
  (PROG (|op| |rc| #0=#:G2003)
    (RETURN
      (SEQ (LETT |op| (|LODEEF;ulodo| |eq| |k| $)
                 . #1=(|LODEEF;rfSolve|))
           (EXIT (COND
                   ((NULL (SPADCALL |k|
                              (SPADCALL (SPADCALL |g| (QREFELT $ 140))
                                  |x| (QREFELT $ 67))
                              (QREFELT $ 141)))
                    (SEQ (LETT |rc|
                               (SPADCALL |op|
                                   (SPADCALL |g| |k| (QREFELT $ 136))
                                   (QREFELT $ 145)) . #1#)
                         (EXIT (COND
                                 ((QEQCAR (QCAR |rc|) 1)
                                  (|LODEEF;doVarParams| |eq| |g|
                                      (|LODEEF;homosolve| |eq| |op|
                                       (QCDR |rc|) |k| |x| $)
                                      |x| $))
                                 ('T
                                  (CONS 0
                                        (CONS
                                         (SPADCALL
                                          (PROG2
                                           (LETT #0# (QCAR |rc|) . #1#)
                                           (QCDR #0#)
                                            (|check-union|
                                             (QEQCAR #0# 0)
                                             (|Fraction|
                                              (|SparseUnivariatePolynomial|
                                               (QREFELT $ 7)))
                                             #0#))
                                          |k| (QREFELT $ 89))
                                         (|LODEEF;homosolve| |eq| |op|
                                          (QCDR |rc|) |k| |x| $))))))))
                   ('T
                    (|LODEEF;doVarParams| |eq| |g|
                        (|LODEEF;homosolve| |eq| |op|
                            (QCDR (SPADCALL |op| (|spadConstant| $ 146)
                                      (QREFELT $ 145)))
                            |k| |x| $)
                        |x| $)))))))) 

(DEFUN |LODEEF;solve;LFSFLU;19| (|op| |g| |x| |a| |y0| $)
  (PROG (|u| |b| |n| |v| |kx| |yy| #0=#:G2029 #1=#:G2028 |h| |sol| |s|
             |i| |f| #2=#:G2030 |hp|)
    (RETURN
      (SEQ (LETT |u| (SPADCALL |op| |g| |x| (QREFELT $ 45))
                 . #3=(|LODEEF;solve;LFSFLU;19|))
           (EXIT (COND
                   ((QEQCAR |u| 1) (CONS 1 "failed"))
                   (#4='T
                    (SEQ (LETT |hp|
                               (LETT |h| (QCAR (QCDR |u|)) . #3#) . #3#)
                         (LETT |b| (QCDR (QCDR |u|)) . #3#)
                         (LETT |v|
                               (SPADCALL (LETT |n| (LENGTH |y0|) . #3#)
                                   (|spadConstant| $ 59)
                                   (QREFELT $ 148)) . #3#)
                         (LETT |kx|
                               (SPADCALL |x| (QREFELT $ 149)) . #3#)
                         (SEQ (LETT |yy| NIL . #3#)
                              (LETT #0# |y0| . #3#)
                              (LETT |i|
                                    (SPADCALL |v| (QREFELT $ 150)) . #3#)
                              (LETT #1# (QVSIZE |v|) . #3#) G190
                              (COND
                                ((OR (> |i| #1#) (ATOM #0#)
                                     (PROGN
                                       (LETT |yy| (CAR #0#) . #3#)
                                       NIL))
                                 #5=(GO G191)))
                              (SEQ (SPADCALL |v| |i|
                                    (SPADCALL |yy|
                                     (SPADCALL |h| |kx| |a|
                                      (QREFELT $ 47))
                                     (QREFELT $ 151))
                                    (QREFELT $ 152))
                                   (EXIT
                                    (LETT |h|
                                     (SPADCALL (QREFELT $ 14) |h|
                                      (QREFELT $ 153)) . #3#)))
                              (LETT |i|
                                    (PROG1 (+ |i| 1)
                                      (LETT #0# (CDR #0#) . #3#)) . #3#)
                              #6=(GO G190) G191 (EXIT NIL))
                         (LETT |sol|
                               (SPADCALL
                                   (SPADCALL
                                    (CONS #'|LODEEF;solve;LFSFLU;19!0|
                                     (VECTOR $ |a| |kx|))
                                    (SPADCALL |b| |n| (QREFELT $ 155))
                                    (QREFELT $ 156))
                                   |v| (QREFELT $ 159)) . #3#)
                         (EXIT (COND
                                 ((QEQCAR |sol| 1) (CONS 1 "failed"))
                                 (#4#
                                  (SEQ (SEQ
                                        (LETT |i|
                                         (SPADCALL
                                          (LETT |s| (QCDR |sol|) . #3#)
                                          (QREFELT $ 150)) . #3#)
                                        (LETT |f| NIL . #3#)
                                        (LETT #2# |b| . #3#) G190
                                        (COND
                                          ((OR (ATOM #2#)
                                            (PROGN
                                              (LETT |f|
                                               (CAR #2#) . #3#)
                                              NIL))
                                           #5#))
                                        (SEQ
                                         (EXIT
                                          (LETT |hp|
                                           (SPADCALL |hp|
                                            (SPADCALL
                                             (SPADCALL |s| |i|
                                              (QREFELT $ 160))
                                             |f| (QREFELT $ 65))
                                            (QREFELT $ 126)) . #3#)))
                                        (LETT #2#
                                         (PROG1 (CDR #2#)
                                           (LETT |i| (+ |i| 1) . #3#)) . #3#)
                                        #6# G191 (EXIT NIL))
                                       (EXIT (CONS 0 |hp|)))))))))))))) 

(DEFUN |LODEEF;solve;LFSFLU;19!0| (|#1| $$)
  (SPADCALL |#1| (QREFELT $$ 2) (QREFELT $$ 1)
      (QREFELT (QREFELT $$ 0) 47))) 

(DEFUN |LODEEF;localmap| (|f| |op| $)
  (PROG (|ans|)
    (RETURN
      (SEQ (LETT |ans| (|spadConstant| $ 133) . #0=(|LODEEF;localmap|))
           (SEQ G190
                (COND
                  ((NULL (COND
                           ((SPADCALL |op| (|spadConstant| $ 133)
                                (QREFELT $ 134))
                            'NIL)
                           ('T 'T)))
                   (GO G191)))
                (SEQ (LETT |ans|
                           (SPADCALL |ans|
                               (SPADCALL
                                   (SPADCALL
                                    (SPADCALL |op| (QREFELT $ 61)) |f|)
                                   (SPADCALL |op| (QREFELT $ 56))
                                   (QREFELT $ 162))
                               (QREFELT $ 163)) . #0#)
                     (EXIT (LETT |op|
                                 (SPADCALL |op| (QREFELT $ 139)) . #0#)))
                NIL (GO G190) G191 (EXIT NIL))
           (EXIT |ans|))))) 

(DEFUN |LODEEF;palgSolve| (|op| |g| |kx| |k| |x| $)
  (PROG (|rec| #0=#:G2042)
    (RETURN
      (SEQ (LETT |rec| (SPADCALL |op| |g| |kx| |k| |x| (QREFELT $ 166))
                 . #1=(|LODEEF;palgSolve|))
           (EXIT (COND
                   ((QEQCAR (QCAR |rec|) 1)
                    (|LODEEF;doVarParams| |op| |g|
                        (|LODEEF;homosolve1| |op| (QCDR |rec|) |k| |x|
                            $)
                        |x| $))
                   ('T
                    (CONS 0
                          (CONS (PROG2 (LETT #0# (QCAR |rec|) . #1#)
                                       (QCDR #0#)
                                  (|check-union| (QEQCAR #0# 0)
                                      (QREFELT $ 7) #0#))
                                (|LODEEF;homosolve1| |op| (QCDR |rec|)
                                    |k| |x| $)))))))))) 

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

(DEFUN |ElementaryFunctionLODESolver;| (|#1| |#2| |#3|)
  (PROG (DV$1 DV$2 DV$3 |dv$| $ |pv$|)
    (RETURN
      (PROGN
        (LETT DV$1 (|devaluate| |#1|)
              . #0=(|ElementaryFunctionLODESolver|))
        (LETT DV$2 (|devaluate| |#2|) . #0#)
        (LETT DV$3 (|devaluate| |#3|) . #0#)
        (LETT |dv$|
              (LIST '|ElementaryFunctionLODESolver| DV$1 DV$2 DV$3) . #0#)
        (LETT $ (GETREFV 167) . #0#)
        (QSETREFV $ 0 |dv$|)
        (QSETREFV $ 3 (LETT |pv$| (|buildPredVector| 0 0 NIL) . #0#))
        (|haddProp| |$ConstructorCache| '|ElementaryFunctionLODESolver|
            (LIST DV$1 DV$2 DV$3) (CONS 1 $))
        (|stuffDomainSlots| $)
        (QSETREFV $ 6 |#1|)
        (QSETREFV $ 7 |#2|)
        (QSETREFV $ 8 |#3|)
        (QSETREFV $ 12 (SPADCALL "%alg" (QREFELT $ 11)))
        (QSETREFV $ 14 (SPADCALL (QREFELT $ 13)))
        $)))) 

(MAKEPROP '|ElementaryFunctionLODESolver| '|infovec|
    (LIST '#(NIL NIL NIL NIL NIL NIL (|local| |#1|) (|local| |#2|)
             (|local| |#3|) (|String|) (|Symbol|) (0 . |coerce|) 'ALGOP
             (5 . D) '|diff| (|SparseMultivariatePolynomial| 20 22)
             (9 . |primitivePart|) (|List| 22) (|List| 20)
             (14 . |eval|) (|SparseMultivariatePolynomial| 6 22)
             (21 . |ground|) (|Kernel| 7) (|IntegrationTools| 6 7)
             (26 . |ksec|) (|Union| 10 '"failed") (33 . |symbolIfCan|)
             (|BasicOperator|) (38 . |operator|) (|Boolean|)
             (43 . |has?|) (|Kernel| $) (49 . |coerce|)
             (|Record| (|:| |primelt| 7) (|:| |pol1| 38)
                 (|:| |pol2| 38) (|:| |prim| 38))
             (|FunctionSpacePrimitiveElement| 6 7)
             (54 . |primitiveElement|) (|SparseUnivariatePolynomial| $)
             (60 . |rootOf|) (|SparseUnivariatePolynomial| 7)
             (65 . |elt|) (|List| 31) (|List| $) (71 . |eval|)
             (|Record| (|:| |particular| 7) (|:| |basis| 51))
             (|Union| 43 '"failed") |LODEEF;solve;LFSU;16|
             (78 . |retract|) (83 . |eval|) (|ODEIntegration| 6 7)
             (90 . |int|) (|Union| 7 '"failed") (|List| 7)
             (|Mapping| 7 7) (|ODETools| 7 8)
             (96 . |particularSolution|) (|NonNegativeInteger|)
             (104 . |degree|) (109 . |One|) (113 . |Zero|)
             (117 . |Zero|) (121 . |coefficient|)
             (127 . |leadingCoefficient|) (132 . /) (138 . -)
             (143 . |expint|) (149 . *) (155 . |tower|)
             (160 . |varselect|) (166 . |coerce|)
             (|SparseMultivariatePolynomial| 6 31) (171 . |numer|)
             (176 . |denom|) (181 . /) (187 . |coerce|)
             (192 . |univariate|) (198 . |Zero|)
             (|SparseUnivariatePolynomial| 20) (202 . |Zero|) (206 . =)
             (212 . |leadingCoefficient|) (217 . |degree|)
             (222 . |monomial|) (229 . +) (235 . |reductum|)
             (|LinearOrdinaryDifferentialOperator1| 86)
             (240 . |degree|) (|Fraction| 38) (245 . |coefficient|)
             (|PolynomialCategoryQuotientFunctions|
                 (|IndexedExponents| 22) 22 6 20 7)
             (251 . |multivariate|) (257 . |leadingCoefficient|)
             (|Factored| 38)
             (|FunctionSpaceUnivariatePolynomialFactor| 6 7 38)
             (262 . |ffactor|) (|List| 86) (|Mapping| 91 38)
             (|RationalRicDE| 7 38) (267 . |ricDsolve|)
             (|Record| (|:| |eq| 84) (|:| |op| 94))
             (|ReductionOfOrder| 86 84) (273 . |ReduceOrder|)
             (279 . |concat!|) (|Record| (|:| |eq| 8) (|:| |op| 51))
             (|ReductionOfOrder| 7 8) (285 . |ReduceOrder|)
             (291 . |One|) (295 . |coefficients|) (300 . |vark|)
             (306 . |kmax|) (|List| 84)
             (|LinearOrdinaryDifferentialOperatorFactorizer| 7 38)
             (311 . |factor1|) (316 . |last|) (|Union| 117 '"failed")
             (|Kovacic| 7 38) (321 . |kovacic|) (|Mapping| 7 86)
             (|SparseUnivariatePolynomial| 86)
             (|SparseUnivariatePolynomialFunctions2| 86 7)
             (329 . |map|) (335 . /) (341 . -) (346 . |degree|)
             (351 . |zerosOf|) (|Integer|) (356 . |coerce|) (361 . +)
             (367 . |zeroOf|) (|PositiveInteger|) (372 . **)
             (|ConstantLODE| 6 7 8) (378 . |constDsolve|)
             (385 . |Zero|) (389 . |Zero|) (393 . =) (|Fraction| 36)
             (399 . |univariate|) (405 . |monomial|) (411 . +)
             (417 . |reductum|) (422 . |kernels|) (427 . |remove!|)
             (|Union| 86 '"failed")
             (|Record| (|:| |particular| 142) (|:| |basis| 94))
             (|RationalLODE| 7 38) (433 . |ratDsolve|) (439 . |Zero|)
             (|Vector| 7) (443 . |new|) (449 . |kernel|)
             (454 . |minIndex|) (459 . -) (465 . |setelt|)
             (472 . |elt|) (|Matrix| 7) (478 . |wronskianMatrix|)
             (484 . |map!|) (|Union| 147 '"failed")
             (|LinearSystemMatrixPackage| 7 147 147 154)
             (490 . |particularSolution|) (496 . |elt|)
             |LODEEF;solve;LFSFLU;19| (502 . |monomial|) (508 . +)
             (|Record| (|:| |particular| 50) (|:| |basis| 51))
             (|PureAlgebraicIntegration| 6 7 8) (514 . |palgLODE|))
          '#(|solve| 523) 'NIL
          (CONS (|makeByteWordVec2| 1 'NIL)
                (CONS '#()
                      (CONS '#()
                            (|makeByteWordVec2| 166
                                '(1 10 0 9 11 0 8 0 13 1 15 0 0 16 3 15
                                  0 0 17 18 19 1 15 20 0 21 3 23 22 22
                                  17 10 24 1 22 25 0 26 1 22 27 0 28 2
                                  27 29 0 10 30 1 7 0 31 32 2 34 33 7 7
                                  35 1 7 0 36 37 2 38 7 0 7 39 3 7 0 0
                                  40 41 42 1 7 31 0 46 3 7 0 0 31 0 47
                                  2 48 7 7 10 49 4 53 50 8 7 51 52 54 1
                                  8 55 0 56 0 6 0 57 0 6 0 58 0 7 0 59
                                  2 8 7 0 55 60 1 8 7 0 61 2 7 0 0 0 62
                                  1 7 0 0 63 2 48 7 7 10 64 2 7 0 0 0
                                  65 1 7 40 0 66 2 23 17 17 10 67 1 20
                                  0 22 68 1 7 69 0 70 1 7 69 0 71 2 7 0
                                  69 69 72 1 15 0 20 73 2 20 36 0 22 74
                                  0 15 0 75 0 76 0 77 2 76 29 0 0 78 1
                                  76 20 0 79 1 76 55 0 80 3 15 0 0 22
                                  55 81 2 15 0 0 0 82 1 76 0 0 83 1 84
                                  55 0 85 2 84 86 0 55 87 2 88 7 86 22
                                  89 1 84 86 0 90 1 92 91 38 93 2 96 94
                                  84 95 97 2 99 98 84 94 100 2 51 0 0 0
                                  101 2 103 102 8 51 104 0 7 0 105 1 8
                                  51 0 106 2 23 17 51 10 107 1 23 22 17
                                  108 1 110 109 84 111 1 109 84 0 112 4
                                  114 113 86 86 86 95 115 2 118 38 116
                                  117 119 2 86 0 0 0 120 1 86 0 0 121 1
                                  38 55 0 122 1 7 41 36 123 1 7 0 124
                                  125 2 7 0 0 0 126 1 7 0 36 127 2 7 0
                                  0 128 129 3 130 43 8 7 10 131 0 84 0
                                  132 0 8 0 133 2 8 29 0 0 134 2 7 135
                                  0 31 136 2 84 0 86 55 137 2 84 0 0 0
                                  138 1 8 0 0 139 1 7 40 0 140 2 17 0
                                  22 0 141 2 144 143 84 86 145 0 86 0
                                  146 2 147 0 55 7 148 1 22 0 10 149 1
                                  147 124 0 150 2 7 0 0 0 151 3 147 7 0
                                  124 7 152 2 8 7 0 7 153 2 53 154 51
                                  55 155 2 154 0 52 0 156 2 158 157 154
                                  147 159 2 147 7 0 124 160 2 8 0 7 55
                                  162 2 8 0 0 0 163 5 165 164 8 7 22 22
                                  10 166 5 0 50 8 7 10 7 51 161 3 0 44
                                  8 7 10 45)))))
          '|lookupComplete|)) 
