
(/VERSIONCHECK 2) 

(DEFUN |RECOP;eqAsF| (|l| $) (SPADCALL |l| 1 (QREFELT $ 19))) 

(DEFUN |RECOP;dummy| (|l| $)
  (SPADCALL (SPADCALL |l| 2 (QREFELT $ 19)) (QREFELT $ 20))) 

(DEFUN |RECOP;dummyAsF| (|l| $) (SPADCALL |l| 2 (QREFELT $ 19))) 

(DEFUN |RECOP;displayVariable| (|l| $) (SPADCALL |l| 3 (QREFELT $ 19))) 

(DEFUN |RECOP;operatorName| (|l| $)
  (SPADCALL
   (SPADCALL (SPADCALL (SPADCALL |l| 4 (QREFELT $ 19)) (QREFELT $ 22)) 1
             (QREFELT $ 25))
   (QREFELT $ 26))) 

(DEFUN |RECOP;operatorNameAsF| (|l| $) (SPADCALL |l| 4 (QREFELT $ 19))) 

(DEFUN |RECOP;operatorArgument| (|l| $)
  (SPADCALL
   (SPADCALL
    (SPADCALL (SPADCALL (SPADCALL |l| 4 (QREFELT $ 19)) (QREFELT $ 22)) 1
              (QREFELT $ 25))
    (QREFELT $ 27))
   1 (QREFELT $ 19))) 

(DEFUN |RECOP;initialValues| (|l| $) (SPADCALL |l| 4 (QREFELT $ 29))) 

(DEFUN |RECOP;getShiftRec;BoKSU;9| (|op| |f| |n| $)
  (PROG (#1=#:G2555 |num| |p| |a|)
    (RETURN
     (SEQ
      (EXIT
       (SEQ
        (LETT |a| (SPADCALL |f| (QREFELT $ 27))
              . #2=(|RECOP;getShiftRec;BoKSU;9|))
        (COND
         ((SPADCALL (CONS #'|RECOP;getShiftRec;BoKSU;9!0| (VECTOR $ |n|)) |a|
                    (QREFELT $ 34))
          (PROGN (LETT #1# (CONS 0 0) . #2#) (GO #1#))))
        (COND
         ((NULL (EQL (LENGTH |a|) 1))
          (|error| "RECOP: operator should have only one argument")))
        (LETT |p|
              (SPADCALL (SPADCALL |a| 1 (QREFELT $ 19))
                        (SPADCALL (SPADCALL |n| (QREFELT $ 30)) (QREFELT $ 36))
                        (QREFELT $ 38))
              . #2#)
        (COND
         ((NULL
           (SPADCALL (SPADCALL |p| (QREFELT $ 40)) (|spadConstant| $ 41)
                     (QREFELT $ 42)))
          (PROGN (LETT #1# (CONS 1 "failed") . #2#) (GO #1#))))
        (LETT |num| (SPADCALL |p| (QREFELT $ 44)) . #2#)
        (EXIT
         (COND
          ((EQL (SPADCALL |num| (QREFELT $ 45)) 1)
           (COND
            ((SPADCALL (SPADCALL |num| 1 (QREFELT $ 46)) (|spadConstant| $ 16)
                       (QREFELT $ 47))
             (COND
              ((SPADCALL (CONS #'|RECOP;getShiftRec;BoKSU;9!1| (VECTOR $ |n|))
                         (SPADCALL |num| (QREFELT $ 48)) (QREFELT $ 34))
               (PROGN
                (LETT #1#
                      (SPADCALL (SPADCALL |num| 0 (QREFELT $ 46))
                                (QREFELT $ 52))
                      . #2#)
                (GO #1#)))
              (#3='T (PROGN (LETT #1# (CONS 1 #4="failed") . #2#) (GO #1#)))))
            (#3# (PROGN (LETT #1# (CONS 1 #4#) . #2#) (GO #1#)))))
          (#3# (PROGN (LETT #1# (CONS 1 #4#) . #2#) (GO #1#)))))))
      #1# (EXIT #1#))))) 

(DEFUN |RECOP;getShiftRec;BoKSU;9!1| (|z| $$)
  (PROG (|n| $)
    (LETT |n| (QREFELT $$ 1) . #1=(|RECOP;getShiftRec;BoKSU;9|))
    (LETT $ (QREFELT $$ 0) . #1#)
    (RETURN
     (PROGN (SPADCALL |z| (SPADCALL |n| (QREFELT $ 30)) (QREFELT $ 32)))))) 

(DEFUN |RECOP;getShiftRec;BoKSU;9!0| (|z| $$)
  (PROG (|n| $)
    (LETT |n| (QREFELT $$ 1) . #1=(|RECOP;getShiftRec;BoKSU;9|))
    (LETT $ (QREFELT $$ 0) . #1#)
    (RETURN
     (PROGN (SPADCALL |z| (SPADCALL |n| (QREFELT $ 30)) (QREFELT $ 32)))))) 

(DEFUN |RECOP;shiftInfoRec;BoSFR;10| (|op| |argsym| |eq| $)
  (PROG (#1=#:G2569 |minShift| |nextKernel| |maxShift| |error?| |shift|
         #2=#:G2570 |f|)
    (RETURN
     (SEQ
      (EXIT
       (SEQ (LETT |error?| 'T . #3=(|RECOP;shiftInfoRec;BoSFR;10|))
            (SEQ (LETT |f| NIL . #3#)
                 (LETT #2# (SPADCALL |eq| (QREFELT $ 22)) . #3#) G190
                 (COND
                  ((OR (ATOM #2#) (PROGN (LETT |f| (CAR #2#) . #3#) NIL))
                   (GO G191)))
                 (SEQ
                  (EXIT
                   (COND
                    ((SPADCALL |f| |op| (QREFELT $ 54))
                     (SEQ
                      (LETT |shift| (SPADCALL |op| |f| |argsym| (QREFELT $ 53))
                            . #3#)
                      (EXIT
                       (COND
                        (|error?|
                         (SEQ (LETT |error?| 'NIL . #3#)
                              (LETT |nextKernel| |f| . #3#)
                              (EXIT
                               (COND
                                ((QEQCAR |shift| 0)
                                 (SEQ (LETT |maxShift| (QCDR |shift|) . #3#)
                                      (EXIT
                                       (LETT |minShift| (QCDR |shift|)
                                             . #3#))))
                                ('T
                                 (PROGN
                                  (LETT #1#
                                        (VECTOR (CONS 1 "failed")
                                                (CONS 1 "failed") |nextKernel|)
                                        . #3#)
                                  (GO #1#)))))))
                        ((QEQCAR |shift| 0)
                         (SEQ
                          (COND
                           ((< |maxShift| (QCDR |shift|))
                            (SEQ (LETT |maxShift| (QCDR |shift|) . #3#)
                                 (EXIT (LETT |nextKernel| |f| . #3#)))))
                          (EXIT
                           (COND
                            ((< (QCDR |shift|) |minShift|)
                             (LETT |minShift| (QCDR |shift|) . #3#))))))
                        ('T
                         (PROGN
                          (LETT #1#
                                (VECTOR (CONS 1 "failed") (CONS 1 "failed")
                                        |nextKernel|)
                                . #3#)
                          (GO #1#))))))))))
                 (LETT #2# (CDR #2#) . #3#) (GO G190) G191 (EXIT NIL))
            (COND
             (|error?|
              (|error| "evalRec: equation does not contain operator")))
            (EXIT
             (VECTOR (CONS 0 |maxShift|) (CONS 0 (- |maxShift| |minShift|))
                     |nextKernel|))))
      #1# (EXIT #1#))))) 

(DEFUN |RECOP;evalRec;BoS3FLF;11|
       (|op| |argsym| |argdisp| |arg| |eq| |values| $)
  (PROG (|newval| |nextval| #1=#:G2572 |next| |num| |p| |shiftInfo| |len| |uc1|
         |uc0| |c1| |c0| |argsymKer| |n|)
    (RETURN
     (SEQ
      (LETT |n| (SPADCALL |arg| (QREFELT $ 52))
            . #2=(|RECOP;evalRec;BoS3FLF;11|))
      (EXIT
       (COND
        ((OR (QEQCAR |n| 1) (< (QCDR |n|) 0))
         (SEQ
          (LETT |shiftInfo| (SPADCALL |op| |argsym| |eq| (QREFELT $ 56)) . #2#)
          (EXIT
           (COND
            ((OR (QEQCAR (QVELT |shiftInfo| 1) 1)
                 (< 0
                    (PROG2
                        (LETT #1# (QVELT |shiftInfo| 1) . #2#)
                        (QCDR #1#)
                      (|check-union| (QEQCAR #1# 0) (|Integer|) #1#))))
             (SPADCALL (QREFELT $ 11)
                       (APPEND
                        (LIST |eq| (SPADCALL |argsym| (QREFELT $ 30)) |argdisp|
                              (SPADCALL |op| |arg| (QREFELT $ 57)))
                        |values|)
                       (QREFELT $ 59)))
            ('T
             (SEQ
              (LETT |p| (SPADCALL |eq| (QVELT |shiftInfo| 2) (QREFELT $ 38))
                    . #2#)
              (LETT |num| (SPADCALL |p| (QREFELT $ 44)) . #2#)
              (COND
               ((NULL (SPADCALL (SPADCALL |p| (QREFELT $ 60)) (QREFELT $ 61)))
                (|error|
                 "evalRec assumes that the equation has no denominator")))
              (LETT |argsymKer|
                    (SPADCALL (SPADCALL |argsym| (QREFELT $ 30))
                              (QREFELT $ 36))
                    . #2#)
              (LETT |c0| (SPADCALL |num| 0 (QREFELT $ 46)) . #2#)
              (LETT |c1| (SPADCALL |num| 1 (QREFELT $ 46)) . #2#)
              (EXIT
               (COND
                ((EQL (SPADCALL |num| (QREFELT $ 45)) 1)
                 (COND
                  ((OR (SPADCALL |c1| |argsym| (QREFELT $ 62))
                       (NULL
                        (OR
                         (OR (SPADCALL |c0| (QREFELT $ 68))
                             (NULL
                              (SPADCALL
                               (SPADCALL
                                (SPADCALL
                                 (LETT |uc0|
                                       (SPADCALL |c0| |argsymKer|
                                                 (QREFELT $ 38))
                                       . #2#)
                                 (QREFELT $ 44))
                                (SPADCALL
                                 (LETT |uc1|
                                       (SPADCALL |c1| |argsymKer|
                                                 (QREFELT $ 38))
                                       . #2#)
                                 (QREFELT $ 44))
                                (QREFELT $ 70))
                               (QREFELT $ 61))))
                         (NULL
                          (SPADCALL
                           (SPADCALL (SPADCALL |uc0| (QREFELT $ 60))
                                     (SPADCALL |uc1| (QREFELT $ 60))
                                     (QREFELT $ 70))
                           (QREFELT $ 61))))))
                   (SPADCALL
                    (SPADCALL (SPADCALL |c0| |c1| (QREFELT $ 63))
                              (QREFELT $ 64))
                    (SPADCALL |argsym| (QREFELT $ 30))
                    (SPADCALL |arg|
                              (SPADCALL
                               (PROG2
                                   (LETT #1# (QVELT |shiftInfo| 0) . #2#)
                                   (QCDR #1#)
                                 (|check-union| (QEQCAR #1# 0) (|Integer|)
                                                #1#))
                               (QREFELT $ 65))
                              (QREFELT $ 66))
                    (QREFELT $ 67)))
                  ('T
                   (SPADCALL (QREFELT $ 11)
                             (APPEND
                              (LIST |eq| (SPADCALL |argsym| (QREFELT $ 30))
                                    |argdisp|
                                    (SPADCALL |op| |arg| (QREFELT $ 57)))
                              |values|)
                             (QREFELT $ 59)))))
                (#3='T
                 (SPADCALL (QREFELT $ 11)
                           (APPEND
                            (LIST |eq| (SPADCALL |argsym| (QREFELT $ 30))
                                  |argdisp|
                                  (SPADCALL |op| |arg| (QREFELT $ 57)))
                            |values|)
                           (QREFELT $ 59)))))))))))
        ('T
         (SEQ (LETT |len| (LENGTH |values|) . #2#)
              (EXIT
               (COND
                ((< (QCDR |n|) |len|)
                 (SPADCALL |values| (- |len| (QCDR |n|)) (QREFELT $ 19)))
                (#3#
                 (SEQ
                  (LETT |shiftInfo|
                        (SPADCALL |op| |argsym| |eq| (QREFELT $ 56)) . #2#)
                  (EXIT
                   (COND
                    ((QEQCAR (QVELT |shiftInfo| 0) 0)
                     (SEQ
                      (LETT |p|
                            (SPADCALL |eq| (QVELT |shiftInfo| 2)
                                      (QREFELT $ 38))
                            . #2#)
                      (LETT |num| (SPADCALL |p| (QREFELT $ 44)) . #2#)
                      (COND
                       ((NULL
                         (SPADCALL (SPADCALL |p| (QREFELT $ 60))
                                   (QREFELT $ 61)))
                        (|error|
                         "evalRec assumes that the equation has no denominator")))
                      (EXIT
                       (COND
                        ((EQL (SPADCALL |num| (QREFELT $ 45)) 1)
                         (SEQ
                          (LETT |next|
                                (SPADCALL
                                 (SPADCALL (SPADCALL |num| 0 (QREFELT $ 46))
                                           (SPADCALL |num| 1 (QREFELT $ 46))
                                           (QREFELT $ 63))
                                 (QREFELT $ 64))
                                . #2#)
                          (LETT |nextval|
                                (SPADCALL |next|
                                          (SPADCALL |argsym| (QREFELT $ 30))
                                          (SPADCALL
                                           (- |len|
                                              (PROG2
                                                  (LETT #1#
                                                        (QVELT |shiftInfo| 0)
                                                        . #2#)
                                                  (QCDR #1#)
                                                (|check-union| (QEQCAR #1# 0)
                                                               (|Integer|)
                                                               #1#)))
                                           (QREFELT $ 65))
                                          (QREFELT $ 67))
                                . #2#)
                          (LETT |newval|
                                (SPADCALL |nextval| |op|
                                          (CONS #'|RECOP;evalRec;BoS3FLF;11!0|
                                                (VECTOR $ |values| |eq|
                                                        |argdisp| |argsym|
                                                        |op|))
                                          (QREFELT $ 75))
                                . #2#)
                          (EXIT
                           (SPADCALL |op| |argsym| |argdisp| |arg| |eq|
                                     (CONS |newval| |values|)
                                     (QREFELT $ 73)))))
                        (#3#
                         (SPADCALL (QREFELT $ 11)
                                   (APPEND
                                    (LIST |eq|
                                          (SPADCALL |argsym| (QREFELT $ 30))
                                          |argdisp|
                                          (SPADCALL |op| |arg| (QREFELT $ 57)))
                                    |values|)
                                   (QREFELT $ 59)))))))
                    (#3#
                     (SPADCALL (QREFELT $ 11)
                               (APPEND
                                (LIST |eq| (SPADCALL |argsym| (QREFELT $ 30))
                                      |argdisp|
                                      (SPADCALL |op| |arg| (QREFELT $ 57)))
                                |values|)
                               (QREFELT $ 59))))))))))))))))) 

(DEFUN |RECOP;evalRec;BoS3FLF;11!0| (|z| $$)
  (PROG (|op| |argsym| |argdisp| |eq| |values| $)
    (LETT |op| (QREFELT $$ 5) . #1=(|RECOP;evalRec;BoS3FLF;11|))
    (LETT |argsym| (QREFELT $$ 4) . #1#)
    (LETT |argdisp| (QREFELT $$ 3) . #1#)
    (LETT |eq| (QREFELT $$ 2) . #1#)
    (LETT |values| (QREFELT $$ 1) . #1#)
    (LETT $ (QREFELT $$ 0) . #1#)
    (RETURN
     (PROGN
      (SPADCALL |op| |argsym| |argdisp| |z| |eq| |values| (QREFELT $ 73)))))) 

(DEFUN |RECOP;numberOfValuesNeeded;IBoSFI;12|
       (|numberOfValues| |op| |argsym| |eq| $)
  (PROG (|order|)
    (RETURN
     (SEQ
      (LETT |order| (QVELT (SPADCALL |op| |argsym| |eq| (QREFELT $ 56)) 1)
            |RECOP;numberOfValuesNeeded;IBoSFI;12|)
      (EXIT
       (COND
        ((QEQCAR |order| 0)
         (MIN |numberOfValues| (SPADCALL (QCDR |order|) (QREFELT $ 76))))
        ('T |numberOfValues|))))))) 

(DEFUN |RECOP;evalRec;BoS3FLF;13|
       (|op| |argsym| |argdisp| |arg| |eq| |values| $)
  (SPADCALL (QREFELT $ 11)
            (APPEND
             (LIST |eq| (SPADCALL |argsym| (QREFELT $ 30)) |argdisp|
                   (SPADCALL |op| |arg| (QREFELT $ 57)))
             |values|)
            (QREFELT $ 59))) 

(PUT '|RECOP;numberOfValuesNeeded;IBoSFI;14| '|SPADreplace|
     '(XLAM (|numberOfValues| |op| |argsym| |eq|) |numberOfValues|)) 

(DEFUN |RECOP;numberOfValuesNeeded;IBoSFI;14|
       (|numberOfValues| |op| |argsym| |eq| $)
  |numberOfValues|) 

(DEFUN |RECOP;irecur| (|l| $)
  (SPADCALL (|RECOP;operatorName| |l| $) (|RECOP;dummy| |l| $)
            (|RECOP;displayVariable| |l| $) (|RECOP;operatorArgument| |l| $)
            (|RECOP;eqAsF| |l| $) (|RECOP;initialValues| |l| $) (QREFELT $ 73))) 

(DEFUN |RECOP;ddrec| (|l| $)
  (PROG (|vals| |i| #1=#:G2612 |numberOfValues| |eq| |values| |op|)
    (RETURN
     (SEQ (LETT |op| (|RECOP;operatorName| |l| $) . #2=(|RECOP;ddrec|))
          (LETT |values| (REVERSE |l|) . #2#)
          (LETT |eq| (|RECOP;eqAsF| |l| $) . #2#)
          (LETT |numberOfValues|
                (SPADCALL (- (LENGTH |values|) 4) |op| (|RECOP;dummy| |l| $)
                          |eq| (QREFELT $ 77))
                . #2#)
          (LETT |vals|
                (CONS
                 (SPADCALL
                  (SPADCALL
                   (SPADCALL |eq| (|RECOP;dummyAsF| |l| $)
                             (|RECOP;displayVariable| |l| $) (QREFELT $ 67))
                   (QREFELT $ 82))
                  (SPADCALL (|spadConstant| $ 49) (QREFELT $ 83))
                  (QREFELT $ 84))
                 (PROGN
                  (LETT #1# NIL . #2#)
                  (SEQ (LETT |i| 1 . #2#) G190
                       (COND ((QSGREATERP |i| |numberOfValues|) (GO G191)))
                       (SEQ
                        (EXIT
                         (LETT #1#
                               (CONS
                                (SPADCALL
                                 (SPADCALL (SPADCALL |op| (QREFELT $ 85))
                                           (LIST
                                            (SPADCALL (- |i| 1)
                                                      (QREFELT $ 86)))
                                           (QREFELT $ 87))
                                 (SPADCALL
                                  (SPADCALL |values| |i| (QREFELT $ 19))
                                  (QREFELT $ 82))
                                 (QREFELT $ 84))
                                #1#)
                               . #2#)))
                       (LETT |i| (QSADD1 |i|) . #2#) (GO G190) G191
                       (EXIT (NREVERSE0 #1#)))))
                . #2#)
          (EXIT
           (SPADCALL
            (SPADCALL
             (LIST (SPADCALL (|RECOP;operatorNameAsF| |l| $) (QREFELT $ 82))
                   ": " (SPADCALL |vals| (QREFELT $ 88)))
             (QREFELT $ 89))
            (QREFELT $ 90))))))) 

(DEFUN |RECOP;getOrder| (|op| |f| $)
  (PROG (|res| |g|)
    (RETURN
     (SEQ (LETT |res| 0 . #1=(|RECOP;getOrder|)) (LETT |g| |f| . #1#)
          (SEQ G190
               (COND ((NULL (SPADCALL |g| '|%diff| (QREFELT $ 91))) (GO G191)))
               (SEQ
                (LETT |g|
                      (SPADCALL
                       (SPADCALL
                        (SPADCALL (SPADCALL |g| (QREFELT $ 27)) 1
                                  (QREFELT $ 19))
                        (QREFELT $ 22))
                       1 (QREFELT $ 25))
                      . #1#)
                (EXIT (LETT |res| (+ |res| 1) . #1#)))
               NIL (GO G190) G191 (EXIT NIL))
          (EXIT (COND ((SPADCALL |g| |op| (QREFELT $ 54)) |res|) ('T 0))))))) 

(DEFUN |RECOP;evalADE;BoS3FLF;18|
       (|op| |argsym| |argdisp| |arg| |eq| |values| $)
  (PROG (#1=#:G2626 |s| #2=#:G2624 |p| |order| #3=#:G2632 |k| |keq| #4=#:G2631
         |n|)
    (RETURN
     (SEQ
      (COND
       ((NULL
         (SPADCALL |eq| (SPADCALL |argdisp| (QREFELT $ 20)) (QREFELT $ 62)))
        (|error|
         "RECOP: The argument should not be used in the equation of the ADE")))
      (LETT |n| (SPADCALL |arg| (QREFELT $ 52))
            . #5=(|RECOP;evalADE;BoS3FLF;18|))
      (EXIT
       (COND
        ((QEQCAR |n| 1)
         (SEQ (LETT |keq| (SPADCALL |eq| (QREFELT $ 22)) . #5#)
              (LETT |order|
                    (|RECOP;getOrder| |op| (SPADCALL |keq| 1 (QREFELT $ 25)) $)
                    . #5#)
              (SEQ (LETT |k| NIL . #5#) (LETT #4# (CDR |keq|) . #5#) G190
                   (COND
                    ((OR (ATOM #4#) (PROGN (LETT |k| (CAR #4#) . #5#) NIL))
                     #6=(GO G191)))
                   (SEQ
                    (EXIT
                     (LETT |order| (MAX |order| (|RECOP;getOrder| |op| |k| $))
                           . #5#)))
                   (LETT #4# (CDR #4#) . #5#) #7=(GO G190) G191 (EXIT NIL))
              (LETT |p|
                    (SPADCALL |eq|
                              (SPADCALL
                               (SPADCALL
                                (SPADCALL
                                 (SPADCALL |op|
                                           (SPADCALL |argsym| (QREFELT $ 30))
                                           (QREFELT $ 57))
                                 |argsym| |order| (QREFELT $ 92))
                                (QREFELT $ 22))
                               1 (QREFELT $ 25))
                              (QREFELT $ 38))
                    . #5#)
              (EXIT
               (COND
                ((EQL (SPADCALL (SPADCALL |p| (QREFELT $ 44)) (QREFELT $ 45))
                      1)
                 (SPADCALL (QREFELT $ 12)
                           (APPEND
                            (LIST |eq| (SPADCALL |argsym| (QREFELT $ 30))
                                  |argdisp|
                                  (SPADCALL |op| |arg| (QREFELT $ 57)))
                            (REVERSE
                             (SPADCALL (REVERSE |values|) |order|
                                       (QREFELT $ 93))))
                           (QREFELT $ 59)))
                (#8='T
                 (SPADCALL (QREFELT $ 12)
                           (APPEND
                            (LIST |eq| (SPADCALL |argsym| (QREFELT $ 30))
                                  |argdisp|
                                  (SPADCALL |op| |arg| (QREFELT $ 57)))
                            |values|)
                           (QREFELT $ 59)))))))
        ((< (QCDR |n|) 0) (|spadConstant| $ 50))
        (#8#
         (SEQ (LETT |keq| (SPADCALL |eq| (QREFELT $ 22)) . #5#)
              (LETT |order|
                    (|RECOP;getOrder| |op| (SPADCALL |keq| 1 (QREFELT $ 25)) $)
                    . #5#)
              (SEQ (LETT |k| NIL . #5#) (LETT #3# (CDR |keq|) . #5#) G190
                   (COND
                    ((OR (ATOM #3#) (PROGN (LETT |k| (CAR #3#) . #5#) NIL))
                     #6#))
                   (SEQ
                    (EXIT
                     (LETT |order| (MAX |order| (|RECOP;getOrder| |op| |k| $))
                           . #5#)))
                   (LETT #3# (CDR #3#) . #5#) #7# G191 (EXIT NIL))
              (LETT |p|
                    (SPADCALL |eq|
                              (SPADCALL
                               (SPADCALL
                                (SPADCALL
                                 (SPADCALL |op|
                                           (SPADCALL |argsym| (QREFELT $ 30))
                                           (QREFELT $ 57))
                                 |argsym| |order| (QREFELT $ 92))
                                (QREFELT $ 22))
                               1 (QREFELT $ 25))
                              (QREFELT $ 38))
                    . #5#)
              (EXIT
               (COND
                ((< 1 (SPADCALL (SPADCALL |p| (QREFELT $ 44)) (QREFELT $ 45)))
                 (SEQ
                  (LETT |s|
                        (SPADCALL |eq| |op| |argsym| (REVERSE |values|)
                                  (QREFELT $ 97))
                        . #5#)
                  (EXIT
                   (SPADCALL |s|
                             (PROG1 (LETT #2# (QCDR |n|) . #5#)
                               (|check-subtype| (>= #2# 0)
                                                '(|NonNegativeInteger|) #2#))
                             (QREFELT $ 98)))))
                (#8#
                 (SEQ
                  (LETT |s|
                        (SPADCALL |eq| |op| |argsym|
                                  (SPADCALL (REVERSE |values|) |order|
                                            (QREFELT $ 93))
                                  (QREFELT $ 97))
                        . #5#)
                  (EXIT
                   (SPADCALL |s|
                             (PROG1 (LETT #1# (QCDR |n|) . #5#)
                               (|check-subtype| (>= #1# 0)
                                                '(|NonNegativeInteger|) #1#))
                             (QREFELT $ 98))))))))))))))) 

(DEFUN |RECOP;iADE| (|l| $)
  (SPADCALL (|RECOP;operatorName| |l| $) (|RECOP;dummy| |l| $)
            (|RECOP;displayVariable| |l| $) (|RECOP;operatorArgument| |l| $)
            (|RECOP;eqAsF| |l| $) (|RECOP;initialValues| |l| $) (QREFELT $ 99))) 

(DEFUN |RECOP;getEq;2F;20| (|f| $)
  (PROG (|l| |ker|)
    (RETURN
     (SEQ (LETT |ker| (SPADCALL |f| (QREFELT $ 22)) . #1=(|RECOP;getEq;2F;20|))
          (EXIT
           (COND
            ((EQL (LENGTH |ker|) 1)
             (COND
              ((OR
                (SPADCALL
                 (SPADCALL (SPADCALL |ker| 1 (QREFELT $ 25)) (QREFELT $ 26))
                 '|rootOfADE| (QREFELT $ 100))
                (SPADCALL
                 (SPADCALL (SPADCALL |ker| 1 (QREFELT $ 25)) (QREFELT $ 26))
                 '|rootOfRec| (QREFELT $ 100)))
               (SEQ
                (LETT |l|
                      (SPADCALL (SPADCALL |ker| 1 (QREFELT $ 25))
                                (QREFELT $ 27))
                      . #1#)
                (EXIT
                 (SPADCALL (|RECOP;eqAsF| |l| $) (|RECOP;dummyAsF| |l| $)
                           (|RECOP;displayVariable| |l| $) (QREFELT $ 67)))))
              ('T
               (|error|
                #2="getEq: argument should be a single rootOfADE or rootOfRec object"))))
            ('T (|error| #2#)))))))) 

(DEFUN |RECOP;getOp;FBo;21| (|f| $)
  (PROG (|ker|)
    (RETURN
     (SEQ (LETT |ker| (SPADCALL |f| (QREFELT $ 22)) |RECOP;getOp;FBo;21|)
          (EXIT
           (COND
            ((EQL (LENGTH |ker|) 1)
             (COND
              ((OR
                (SPADCALL
                 (SPADCALL (SPADCALL |ker| 1 (QREFELT $ 25)) (QREFELT $ 26))
                 '|rootOfADE| (QREFELT $ 100))
                (SPADCALL
                 (SPADCALL (SPADCALL |ker| 1 (QREFELT $ 25)) (QREFELT $ 26))
                 '|rootOfRec| (QREFELT $ 100)))
               (|RECOP;operatorName|
                (SPADCALL (SPADCALL |ker| 1 (QREFELT $ 25)) (QREFELT $ 27)) $))
              ('T
               (|error|
                #1="getOp: argument should be a single rootOfADE or rootOfRec object"))))
            ('T (|error| #1#)))))))) 

(DEFUN |RECOP;ddADE| (|l| $)
  (PROG (|TaylorPoly| |TaylorO| |TaylorList| #1=#:G2651 |i| #2=#:G2650 |DiffEq|
         |TaylorCoeff| |values| |x| |op|)
    (RETURN
     (SEQ (LETT |op| (|RECOP;operatorName| |l| $) . #3=(|RECOP;ddADE|))
          (LETT |x| (|RECOP;displayVariable| |l| $) . #3#)
          (LETT |values| (REVERSE |l|) . #3#)
          (LETT |TaylorCoeff|
                (SPADCALL
                 (SPADCALL (SPADCALL |x| (QREFELT $ 82))
                           (SPADCALL (|RECOP;operatorArgument| |l| $)
                                     (QREFELT $ 82))
                           (QREFELT $ 103))
                 (QREFELT $ 90))
                . #3#)
          (LETT |DiffEq|
                (SPADCALL
                 (LIST |TaylorCoeff|
                       (SPADCALL (SPADCALL |op| |x| (QREFELT $ 57))
                                 (QREFELT $ 82))
                       ": "
                       (SPADCALL
                        (SPADCALL
                         (SPADCALL (|RECOP;eqAsF| |l| $)
                                   (|RECOP;dummyAsF| |l| $) |x| (QREFELT $ 67))
                         (QREFELT $ 82))
                        (SPADCALL (|spadConstant| $ 49) (QREFELT $ 83))
                        (QREFELT $ 84)))
                 (QREFELT $ 89))
                . #3#)
          (EXIT
           (COND ((< (LENGTH |values|) 5) (SPADCALL |DiffEq| (QREFELT $ 90)))
                 (#4='T
                  (SEQ
                   (LETT |TaylorList|
                         (PROGN
                          (LETT #2# NIL . #3#)
                          (SEQ (LETT |i| 0 . #3#)
                               (LETT #1# (MIN 4 (- (LENGTH |values|) 5)) . #3#)
                               G190 (COND ((QSGREATERP |i| #1#) (GO G191)))
                               (SEQ
                                (EXIT
                                 (COND
                                  ((COND
                                    ((SPADCALL
                                      (SPADCALL |values| (+ |i| 1)
                                                (QREFELT $ 19))
                                      (|spadConstant| $ 50) (QREFELT $ 47))
                                     'NIL)
                                    (#4# 'T))
                                   (LETT #2#
                                         (CONS
                                          (SPADCALL
                                           (SPADCALL
                                            (SPADCALL |values| (+ |i| 1)
                                                      (QREFELT $ 19))
                                            (SPADCALL |x| |i| (QREFELT $ 104))
                                            (QREFELT $ 105))
                                           (QREFELT $ 82))
                                          #2#)
                                         . #3#)))))
                               (LETT |i| (QSADD1 |i|) . #3#) (GO G190) G191
                               (EXIT (NREVERSE0 #2#))))
                         . #3#)
                   (LETT |TaylorO|
                         (SPADCALL "O"
                                   (LIST
                                    (SPADCALL
                                     (SPADCALL |x|
                                               (+ 1
                                                  (MIN 4
                                                       (- (LENGTH |values|)
                                                          5)))
                                               (QREFELT $ 106))
                                     (QREFELT $ 82)))
                                   (QREFELT $ 107))
                         . #3#)
                   (LETT |TaylorPoly|
                         (SPADCALL
                          (SPADCALL (SPADCALL |op| |x| (QREFELT $ 57))
                                    (QREFELT $ 82))
                          (SPADCALL (ELT $ 108)
                                    (SPADCALL |TaylorList| |TaylorO|
                                              (QREFELT $ 110))
                                    (QREFELT $ 112))
                          (QREFELT $ 84))
                         . #3#)
                   (EXIT
                    (SPADCALL
                     (SPADCALL (LIST |DiffEq| |TaylorPoly|) (QREFELT $ 88))
                     (QREFELT $ 90))))))))))) 

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

(DEFUN |RecurrenceOperator;| (|#1| |#2|)
  (PROG (|pv$| $ |dv$| DV$2 DV$1)
    (RETURN
     (PROGN
      (LETT DV$1 (|devaluate| |#1|) . #1=(|RecurrenceOperator|))
      (LETT DV$2 (|devaluate| |#2|) . #1#)
      (LETT |dv$| (LIST '|RecurrenceOperator| DV$1 DV$2) . #1#)
      (LETT $ (GETREFV 113) . #1#)
      (QSETREFV $ 0 |dv$|)
      (QSETREFV $ 3
                (LETT |pv$|
                      (|buildPredVector| 0 0
                                         (LIST (|HasCategory| |#1| '(|Ring|))))
                      . #1#))
      (|haddProp| |$ConstructorCache| '|RecurrenceOperator| (LIST DV$1 DV$2)
                  (CONS 1 $))
      (|stuffDomainSlots| $)
      (QSETREFV $ 6 |#1|)
      (QSETREFV $ 7 |#2|)
      (QSETREFV $ 11 (SPADCALL '|rootOfRec| (QREFELT $ 10)))
      (QSETREFV $ 12 (SPADCALL '|rootOfADE| (QREFELT $ 10)))
      (SPADCALL (QREFELT $ 11) '|%dummyVar| 2 (QREFELT $ 14))
      (SPADCALL (QREFELT $ 12) '|%dummyVar| 2 (QREFELT $ 14))
      (COND
       ((|testBitVector| |pv$| 1)
        (PROGN
         (QSETREFV $ 53
                   (CONS (|dispatchFunction| |RECOP;getShiftRec;BoKSU;9|) $))
         (QSETREFV $ 56
                   (CONS (|dispatchFunction| |RECOP;shiftInfoRec;BoSFR;10|) $))
         (QSETREFV $ 73
                   (CONS (|dispatchFunction| |RECOP;evalRec;BoS3FLF;11|) $))
         (QSETREFV $ 77
                   (CONS
                    (|dispatchFunction| |RECOP;numberOfValuesNeeded;IBoSFI;12|)
                    $))))
       ('T
        (PROGN
         (QSETREFV $ 73
                   (CONS (|dispatchFunction| |RECOP;evalRec;BoS3FLF;13|) $))
         (QSETREFV $ 77
                   (CONS
                    (|dispatchFunction| |RECOP;numberOfValuesNeeded;IBoSFI;14|)
                    $)))))
      (SPADCALL (QREFELT $ 11) (CONS (|function| |RECOP;irecur|) $)
                (QREFELT $ 80))
      (SPADCALL (QREFELT $ 11) '|%specialDisp|
                (CONS (|function| |RECOP;ddrec|) $) (QREFELT $ 14))
      (SPADCALL (QREFELT $ 12) (CONS (|function| |RECOP;iADE|) $)
                (QREFELT $ 80))
      (SPADCALL (QREFELT $ 12) '|%specialDisp|
                (CONS (|function| |RECOP;ddADE|) $) (QREFELT $ 14))
      $)))) 

(MAKEPROP '|RecurrenceOperator| '|infovec|
          (LIST
           '#(NIL NIL NIL NIL NIL NIL (|local| |#1|) (|local| |#2|) (|Symbol|)
              (|BasicOperator|) (0 . |operator|) '|oprecur| '|opADE| (|None|)
              (5 . |setProperty|) (12 . |One|) (16 . |One|) (|Integer|)
              (|List| 7) (20 . |elt|) (26 . |retract|) (|List| 35)
              (31 . |kernels|) (|Kernel| 7) (|List| 23) (36 . |elt|)
              (42 . |operator|) (47 . |argument|) (|NonNegativeInteger|)
              (52 . |rest|) (58 . |coerce|) (|Boolean|) (63 . |freeOf?|)
              (|Mapping| 31 7) (69 . |every?|) (|Kernel| $) (75 . |retract|)
              (|Fraction| 69) (80 . |univariate|) (|Fraction| 43)
              (86 . |denominator|) (91 . |One|) (95 . =)
              (|SparseUnivariatePolynomial| 7) (101 . |numer|) (106 . |degree|)
              (111 . |coefficient|) (117 . =) (123 . |coefficients|)
              (128 . |Zero|) (132 . |Zero|) (|Union| 17 '"failed")
              (136 . |retractIfCan|) (141 . |getShiftRec|) (148 . |is?|)
              (|Record| (|:| |max| 51) (|:| |ord| 51) (|:| |ker| 23))
              (154 . |shiftInfoRec|) (161 . |elt|) (|List| $) (167 . |kernel|)
              (173 . |denom|) (178 . |one?|) (183 . |freeOf?|) (189 . /)
              (195 . -) (200 . |coerce|) (205 . -) (211 . |eval|)
              (218 . |zero?|) (|SparseUnivariatePolynomial| $)
              (223 . |gcdPolynomial|) (229 . |Zero|) (233 . |Zero|)
              (237 . |evalRec|) (|Mapping| $ $) (247 . |eval|)
              (254 . |retract|) (259 . |numberOfValuesNeeded|) (|Mapping| 7 18)
              (|BasicOperatorFunctions1| 7) (267 . |evaluate|) (|OutputForm|)
              (273 . |coerce|) (278 . |coerce|) (283 . =) (289 . |coerce|)
              (294 . |coerce|) (299 . |elt|) (305 . |commaSeparate|)
              (310 . |hconcat|) (315 . |bracket|) (320 . |is?|) (326 . D)
              (333 . |first|) (339 . |One|) (|UnivariateFormalPowerSeries| 7)
              (|ExpressionSolve| 6 7 95
                                 (|UnivariateFormalPowerSeries|
                                  (|SparseUnivariatePolynomialExpressions| 7)))
              (343 . |seriesSolve|) (351 . |elt|) |RECOP;evalADE;BoS3FLF;18|
              (357 . |is?|) |RECOP;getEq;2F;20| |RECOP;getOp;FBo;21| (363 . ^)
              (369 . ^) (375 . *) (381 . ^) (387 . |prefix|) (393 . +)
              (|List| 81) (399 . |concat|) (|Mapping| 81 81 81)
              (405 . |reduce|))
           '#(|shiftInfoRec| 411 |numberOfValuesNeeded| 418 |getShiftRec| 426
              |getOp| 433 |getEq| 438 |evalRec| 443 |evalADE| 453)
           'NIL
           (CONS (|makeByteWordVec2| 1 'NIL)
                 (CONS '#()
                       (CONS '#()
                             (|makeByteWordVec2| 112
                                                 '(1 9 0 8 10 3 9 0 0 8 13 14 0
                                                   6 0 15 0 7 0 16 2 18 7 0 17
                                                   19 1 7 8 0 20 1 7 21 0 22 2
                                                   24 23 0 17 25 1 23 9 0 26 1
                                                   23 18 0 27 2 18 0 0 28 29 1
                                                   7 0 8 30 2 7 31 0 0 32 2 18
                                                   31 33 0 34 1 7 35 0 36 2 7
                                                   37 0 35 38 1 39 0 0 40 0 39
                                                   0 41 2 39 31 0 0 42 1 39 43
                                                   0 44 1 43 28 0 45 2 43 7 0
                                                   28 46 2 7 31 0 0 47 1 43 18
                                                   0 48 0 6 0 49 0 7 0 50 1 7
                                                   51 0 52 3 0 51 9 23 8 53 2
                                                   23 31 0 9 54 3 0 55 9 8 7 56
                                                   2 7 0 9 0 57 2 7 0 9 58 59 1
                                                   39 43 0 60 1 43 31 0 61 2 7
                                                   31 0 8 62 2 7 0 0 0 63 1 7 0
                                                   0 64 1 7 0 17 65 2 7 0 0 0
                                                   66 3 7 0 0 0 0 67 1 7 31 0
                                                   68 2 7 69 69 69 70 0 39 0 71
                                                   0 43 0 72 6 0 7 9 8 7 7 7 18
                                                   73 3 7 0 0 9 74 75 1 17 17 0
                                                   76 4 0 17 17 9 8 7 77 2 79 9
                                                   9 78 80 1 7 81 0 82 1 6 81 0
                                                   83 2 81 0 0 0 84 1 9 81 0 85
                                                   1 17 81 0 86 2 81 0 0 58 87
                                                   1 81 0 58 88 1 81 0 58 89 1
                                                   81 0 0 90 2 23 31 0 8 91 3 7
                                                   0 0 8 28 92 2 18 0 0 28 93 0
                                                   43 0 94 4 96 95 7 9 8 18 97
                                                   2 95 7 0 28 98 2 9 31 0 8
                                                   100 2 81 0 0 0 103 2 7 0 0
                                                   28 104 2 7 0 0 0 105 2 7 0 0
                                                   17 106 2 81 0 0 58 107 2 81
                                                   0 0 0 108 2 109 0 0 81 110 2
                                                   109 81 111 0 112 3 1 55 9 8
                                                   7 56 4 0 17 17 9 8 7 77 3 1
                                                   51 9 23 8 53 1 0 9 7 102 1 0
                                                   7 7 101 6 0 7 9 8 7 7 7 18
                                                   73 6 0 7 9 8 7 7 7 18
                                                   99)))))
           '|lookupComplete|)) 
