
(/VERSIONCHECK 2) 

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

(DEFUN |RECOP;dummy| (|l| $)
  (SPADCALL (SPADCALL |l| 2 (QREFELT $ 21)) (QREFELT $ 22))) 

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

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

(DEFUN |RECOP;operatorName| (|l| $)
  (SPADCALL
      (SPADCALL
          (SPADCALL (SPADCALL |l| 4 (QREFELT $ 21)) (QREFELT $ 24)) 1
          (QREFELT $ 27))
      (QREFELT $ 28))) 

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

(DEFUN |RECOP;operatorArgument| (|l| $)
  (SPADCALL
      (SPADCALL
          (SPADCALL
              (SPADCALL (SPADCALL |l| 4 (QREFELT $ 21)) (QREFELT $ 24))
              1 (QREFELT $ 27))
          (QREFELT $ 29))
      1 (QREFELT $ 21))) 

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

(DEFUN |RECOP;getShiftRec;BoKSU;9| (|op| |f| |n| $)
  (PROG (|a| |p| |num| #0=#:G40088)
    (RETURN
      (SEQ (EXIT (SEQ (LETT |a| (SPADCALL |f| (QREFELT $ 29))
                            . #1=(|RECOP;getShiftRec;BoKSU;9|))
                      (COND
                        ((SPADCALL
                             (CONS #'|RECOP;getShiftRec;BoKSU;9!0|
                                   (VECTOR $ |n|))
                             |a| (QREFELT $ 36))
                         (PROGN (LETT #0# (CONS 0 0) . #1#) (GO #0#))))
                      (COND
                        ((SPADCALL (LENGTH |a|) 1 (QREFELT $ 37))
                         (|error| "RECOP: operator should have only one argument")))
                      (LETT |p|
                            (SPADCALL (SPADCALL |a| 1 (QREFELT $ 21))
                                (SPADCALL (SPADCALL |n| (QREFELT $ 32))
                                    (QREFELT $ 39))
                                (QREFELT $ 41)) . #1#)
                      (COND
                        ((SPADCALL (SPADCALL |p| (QREFELT $ 43))
                             (|spadConstant| $ 44) (QREFELT $ 45))
                         (PROGN
                           (LETT #0# (CONS 1 "failed") . #1#)
                           (GO #0#))))
                      (LETT |num| (SPADCALL |p| (QREFELT $ 47)) . #1#)
                      (EXIT (COND
                              ((EQL (SPADCALL |num| (QREFELT $ 48)) 1)
                               (COND
                                 ((SPADCALL
                                      (SPADCALL |num| 1 (QREFELT $ 49))
                                      (|spadConstant| $ 18)
                                      (QREFELT $ 50))
                                  (COND
                                    ((SPADCALL
                                      (CONS
                                       #'|RECOP;getShiftRec;BoKSU;9!1|
                                       (VECTOR $ |n|))
                                      (SPADCALL |num| (QREFELT $ 51))
                                      (QREFELT $ 36))
                                     (PROGN
                                       (LETT #0#
                                        (SPADCALL
                                         (SPADCALL |num| 0
                                          (QREFELT $ 49))
                                         (QREFELT $ 55)) . #1#)
                                       (GO #0#)))
                                    ('T
                                     (PROGN
                                       (LETT #0#
                                        (CONS 1 "failed") . #1#)
                                       (GO #0#)))))
                                 ('T
                                  (PROGN
                                    (LETT #0# (CONS 1 "failed") . #1#)
                                    (GO #0#)))))
                              ('T
                               (PROGN
                                 (LETT #0# (CONS 1 "failed") . #1#)
                                 (GO #0#)))))))
           #0# (EXIT #0#))))) 

(DEFUN |RECOP;getShiftRec;BoKSU;9!1| (|#1| $$)
  (PROG ($)
    (LETT $ (QREFELT $$ 0) |RECOP;getShiftRec;BoKSU;9|)
    (RETURN
      (PROGN
        (SPADCALL |#1| (SPADCALL (QREFELT $$ 1) (QREFELT $ 32))
            (QREFELT $ 34)))))) 

(DEFUN |RECOP;getShiftRec;BoKSU;9!0| (|#1| $$)
  (PROG ($)
    (LETT $ (QREFELT $$ 0) |RECOP;getShiftRec;BoKSU;9|)
    (RETURN
      (PROGN
        (SPADCALL |#1| (SPADCALL (QREFELT $$ 1) (QREFELT $ 32))
            (QREFELT $ 34)))))) 

(DEFUN |RECOP;shiftInfoRec;BoSFR;10| (|op| |argsym| |eq| $)
  (PROG (|f| #0=#:G40103 |shift| |error?| |maxShift| |nextKernel|
             |minShift| #1=#:G40102)
    (RETURN
      (SEQ (EXIT (SEQ (LETT |error?| 'T
                            . #2=(|RECOP;shiftInfoRec;BoSFR;10|))
                      (SEQ (LETT |f| NIL . #2#)
                           (LETT #0#
                                 (SPADCALL |eq| (QREFELT $ 24)) . #2#)
                           G190
                           (COND
                             ((OR (ATOM #0#)
                                  (PROGN
                                    (LETT |f| (CAR #0#) . #2#)
                                    NIL))
                              (GO G191)))
                           (SEQ (EXIT (COND
                                        ((SPADCALL |f| |op|
                                          (QREFELT $ 57))
                                         (SEQ
                                          (LETT |shift|
                                           (SPADCALL |op| |f| |argsym|
                                            (QREFELT $ 56)) . #2#)
                                          (EXIT
                                           (COND
                                             (|error?|
                                              (SEQ
                                               (LETT |error?|
                                                'NIL . #2#)
                                               (LETT |nextKernel|
                                                |f| . #2#)
                                               (EXIT
                                                (COND
                                                  ((QEQCAR |shift| 0)
                                                   (SEQ
                                                    (LETT |maxShift|
                                                     (QCDR |shift|) . #2#)
                                                    (EXIT
                                                     (LETT |minShift|
                                                      (QCDR |shift|) . #2#))))
                                                  ('T
                                                   (PROGN
                                                     (LETT #1#
                                                      (VECTOR
                                                       (CONS 1
                                                        "failed")
                                                       (CONS 1
                                                        "failed")
                                                       |nextKernel|) . #2#)
                                                     (GO #1#)))))))
                                             ((QEQCAR |shift| 0)
                                              (SEQ
                                               (COND
                                                 ((< |maxShift|
                                                   (QCDR |shift|))
                                                  (SEQ
                                                   (LETT |maxShift|
                                                    (QCDR |shift|) . #2#)
                                                   (EXIT
                                                    (LETT |nextKernel|
                                                     |f| . #2#)))))
                                               (EXIT
                                                (COND
                                                  ((< (QCDR |shift|)
                                                    |minShift|)
                                                   (LETT |minShift|
                                                    (QCDR |shift|) . #2#))))))
                                             ('T
                                              (PROGN
                                                (LETT #1#
                                                 (VECTOR
                                                  (CONS 1 "failed")
                                                  (CONS 1 "failed")
                                                  |nextKernel|) . #2#)
                                                (GO #1#))))))))))
                           (LETT #0# (CDR #0#) . #2#) (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 (|n| |len| |shiftInfo| |p| |num| |next| #0=#:G40105 |nextval|
             |newval|)
    (RETURN
      (SEQ (LETT |n| (SPADCALL |arg| (QREFELT $ 55))
                 . #1=(|RECOP;evalRec;BoS3FLF;11|))
           (EXIT (COND
                   ((OR (QEQCAR |n| 1) (< (QCDR |n|) 0))
                    (SEQ (LETT |shiftInfo|
                               (SPADCALL |op| |argsym| |eq|
                                   (QREFELT $ 59)) . #1#)
                         (EXIT (COND
                                 ((OR (QEQCAR (QVELT |shiftInfo| 1) 1)
                                      (< 0
                                       (PROG2
                                        (LETT #0#
                                         (QVELT |shiftInfo| 1) . #1#)
                                        (QCDR #0#)
                                         (|check-union| (QEQCAR #0# 0)
                                          (|Integer|) #0#))))
                                  (SPADCALL (QREFELT $ 13)
                                      (APPEND
                                       (LIST |eq|
                                        (SPADCALL |argsym|
                                         (QREFELT $ 32))
                                        |argdisp|
                                        (SPADCALL |op| |arg|
                                         (QREFELT $ 60)))
                                       |values|)
                                      (QREFELT $ 62)))
                                 ('T
                                  (SEQ (LETT |p|
                                        (SPADCALL |eq|
                                         (QVELT |shiftInfo| 2)
                                         (QREFELT $ 41)) . #1#)
                                       (LETT |num|
                                        (SPADCALL |p| (QREFELT $ 47)) . #1#)
                                       (EXIT
                                        (COND
                                          ((EQL
                                            (SPADCALL |num|
                                             (QREFELT $ 48))
                                            1)
                                           (SPADCALL
                                            (SPADCALL
                                             (SPADCALL
                                              (SPADCALL |num| 0
                                               (QREFELT $ 49))
                                              (SPADCALL |num| 1
                                               (QREFELT $ 49))
                                              (QREFELT $ 63))
                                             (QREFELT $ 64))
                                            (SPADCALL |argsym|
                                             (QREFELT $ 32))
                                            (SPADCALL |arg|
                                             (SPADCALL
                                              (PROG2
                                               (LETT #0#
                                                (QVELT |shiftInfo| 0) . #1#)
                                               (QCDR #0#)
                                                (|check-union|
                                                 (QEQCAR #0# 0)
                                                 (|Integer|) #0#))
                                              (QREFELT $ 65))
                                             (QREFELT $ 66))
                                            (QREFELT $ 67)))
                                          ('T
                                           (SPADCALL (QREFELT $ 13)
                                            (APPEND
                                             (LIST |eq|
                                              (SPADCALL |argsym|
                                               (QREFELT $ 32))
                                              |argdisp|
                                              (SPADCALL |op| |arg|
                                               (QREFELT $ 60)))
                                             |values|)
                                            (QREFELT $ 62)))))))))))
                   ('T
                    (SEQ (LETT |len| (LENGTH |values|) . #1#)
                         (EXIT (COND
                                 ((< (QCDR |n|) |len|)
                                  (SPADCALL |values|
                                      (- |len| (QCDR |n|))
                                      (QREFELT $ 21)))
                                 ('T
                                  (SEQ (LETT |shiftInfo|
                                        (SPADCALL |op| |argsym| |eq|
                                         (QREFELT $ 59)) . #1#)
                                       (EXIT
                                        (COND
                                          ((QEQCAR
                                            (QVELT |shiftInfo| 0) 0)
                                           (SEQ
                                            (LETT |p|
                                             (SPADCALL |eq|
                                              (QVELT |shiftInfo| 2)
                                              (QREFELT $ 41)) . #1#)
                                            (LETT |num|
                                             (SPADCALL |p|
                                              (QREFELT $ 47)) . #1#)
                                            (EXIT
                                             (COND
                                               ((EQL
                                                 (SPADCALL |num|
                                                  (QREFELT $ 48))
                                                 1)
                                                (SEQ
                                                 (LETT |next|
                                                  (SPADCALL
                                                   (SPADCALL
                                                    (SPADCALL |num| 0
                                                     (QREFELT $ 49))
                                                    (SPADCALL |num| 1
                                                     (QREFELT $ 49))
                                                    (QREFELT $ 63))
                                                   (QREFELT $ 64)) . #1#)
                                                 (LETT |nextval|
                                                  (SPADCALL |next|
                                                   (SPADCALL |argsym|
                                                    (QREFELT $ 32))
                                                   (SPADCALL
                                                    (- |len|
                                                     (PROG2
                                                      (LETT #0#
                                                       (QVELT
                                                        |shiftInfo| 0) . #1#)
                                                      (QCDR #0#)
                                                       (|check-union|
                                                        (QEQCAR #0# 0)
                                                        (|Integer|)
                                                        #0#)))
                                                    (QREFELT $ 65))
                                                   (QREFELT $ 67)) . #1#)
                                                 (LETT |newval|
                                                  (SPADCALL |nextval|
                                                   |op|
                                                   (CONS
                                                    #'|RECOP;evalRec;BoS3FLF;11!0|
                                                    (VECTOR $ |values|
                                                     |eq| |argdisp|
                                                     |argsym| |op|))
                                                   (QREFELT $ 74)) . #1#)
                                                 (EXIT
                                                  (SPADCALL |op|
                                                   |argsym| |argdisp|
                                                   |arg| |eq|
                                                   (CONS |newval|
                                                    |values|)
                                                   (QREFELT $ 72)))))
                                               ('T
                                                (SPADCALL
                                                 (QREFELT $ 13)
                                                 (APPEND
                                                  (LIST |eq|
                                                   (SPADCALL |argsym|
                                                    (QREFELT $ 32))
                                                   |argdisp|
                                                   (SPADCALL |op| |arg|
                                                    (QREFELT $ 60)))
                                                  |values|)
                                                 (QREFELT $ 62)))))))
                                          ('T
                                           (SPADCALL (QREFELT $ 13)
                                            (APPEND
                                             (LIST |eq|
                                              (SPADCALL |argsym|
                                               (QREFELT $ 32))
                                              |argdisp|
                                              (SPADCALL |op| |arg|
                                               (QREFELT $ 60)))
                                             |values|)
                                            (QREFELT $ 62))))))))))))))))) 

(DEFUN |RECOP;evalRec;BoS3FLF;11!0| (|#1| $$)
  (SPADCALL (QREFELT $$ 5) (QREFELT $$ 4) (QREFELT $$ 3) |#1|
      (QREFELT $$ 2) (QREFELT $$ 1) (QREFELT (QREFELT $$ 0) 72))) 

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

(DEFUN |RECOP;evalRec;BoS3FLF;13|
       (|op| |argsym| |argdisp| |arg| |eq| |values| $)
  (SPADCALL (QREFELT $ 13)
      (APPEND (LIST |eq| (SPADCALL |argsym| (QREFELT $ 32)) |argdisp|
                    (SPADCALL |op| |arg| (QREFELT $ 60)))
              |values|)
      (QREFELT $ 62))) 

(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 $ 72))) 

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

(DEFUN |RECOP;getOrder| (|op| |f| $)
  (PROG (|g| |res|)
    (RETURN
      (SEQ (LETT |res| 0 . #0=(|RECOP;getOrder|)) (LETT |g| |f| . #0#)
           (SEQ G190
                (COND
                  ((NULL (SPADCALL |g| '|%diff| (QREFELT $ 90)))
                   (GO G191)))
                (SEQ (LETT |g|
                           (SPADCALL
                               (SPADCALL
                                   (SPADCALL
                                    (SPADCALL |g| (QREFELT $ 29)) 1
                                    (QREFELT $ 21))
                                   (QREFELT $ 24))
                               1 (QREFELT $ 27)) . #0#)
                     (EXIT (LETT |res| (+ |res| 1) . #0#)))
                NIL (GO G190) G191 (EXIT NIL))
           (EXIT (COND
                   ((SPADCALL |g| |op| (QREFELT $ 57)) |res|)
                   ('T 0))))))) 

(DEFUN |RECOP;evalADE;BoS3FLF;18|
       (|op| |argsym| |argdisp| |arg| |eq| |values| $)
  (PROG (|n| #0=#:G40153 |keq| |k| #1=#:G40154 |order| |p| #2=#:G40146
             |s| #3=#:G40148)
    (RETURN
      (SEQ (COND
             ((NULL (SPADCALL |eq| (SPADCALL |argdisp| (QREFELT $ 22))
                        (QREFELT $ 91)))
              (|error| "RECOP: The argument should not be used in the equation of the ADE")))
           (LETT |n| (SPADCALL |arg| (QREFELT $ 55))
                 . #4=(|RECOP;evalADE;BoS3FLF;18|))
           (EXIT (COND
                   ((QEQCAR |n| 1)
                    (SEQ (LETT |keq|
                               (SPADCALL |eq| (QREFELT $ 24)) . #4#)
                         (LETT |order|
                               (|RECOP;getOrder| |op|
                                   (SPADCALL |keq| 1 (QREFELT $ 27)) $) . #4#)
                         (SEQ (LETT |k| NIL . #4#)
                              (LETT #0# (CDR |keq|) . #4#) G190
                              (COND
                                ((OR (ATOM #0#)
                                     (PROGN
                                       (LETT |k| (CAR #0#) . #4#)
                                       NIL))
                                 #5=(GO G191)))
                              (SEQ (EXIT
                                    (LETT |order|
                                     (MAX |order|
                                      (|RECOP;getOrder| |op| |k| $)) . #4#)))
                              (LETT #0# (CDR #0#) . #4#) #6=(GO G190)
                              G191 (EXIT NIL))
                         (LETT |p|
                               (SPADCALL |eq|
                                   (SPADCALL
                                    (SPADCALL
                                     (SPADCALL
                                      (SPADCALL |op|
                                       (SPADCALL |argsym|
                                        (QREFELT $ 32))
                                       (QREFELT $ 60))
                                      |argsym| |order| (QREFELT $ 92))
                                     (QREFELT $ 24))
                                    1 (QREFELT $ 27))
                                   (QREFELT $ 41)) . #4#)
                         (EXIT (COND
                                 ((EQL (SPADCALL
                                        (SPADCALL |p| (QREFELT $ 47))
                                        (QREFELT $ 48))
                                       1)
                                  (SPADCALL (QREFELT $ 14)
                                      (APPEND
                                       (LIST |eq|
                                        (SPADCALL |argsym|
                                         (QREFELT $ 32))
                                        |argdisp|
                                        (SPADCALL |op| |arg|
                                         (QREFELT $ 60)))
                                       (REVERSE
                                        (SPADCALL (REVERSE |values|)
                                         |order| (QREFELT $ 93))))
                                      (QREFELT $ 62)))
                                 ('T
                                  (SPADCALL (QREFELT $ 14)
                                      (APPEND
                                       (LIST |eq|
                                        (SPADCALL |argsym|
                                         (QREFELT $ 32))
                                        |argdisp|
                                        (SPADCALL |op| |arg|
                                         (QREFELT $ 60)))
                                       |values|)
                                      (QREFELT $ 62)))))))
                   ((< (QCDR |n|) 0) (|spadConstant| $ 53))
                   ('T
                    (SEQ (LETT |keq|
                               (SPADCALL |eq| (QREFELT $ 24)) . #4#)
                         (LETT |order|
                               (|RECOP;getOrder| |op|
                                   (SPADCALL |keq| 1 (QREFELT $ 27)) $) . #4#)
                         (SEQ (LETT |k| NIL . #4#)
                              (LETT #1# (CDR |keq|) . #4#) G190
                              (COND
                                ((OR (ATOM #1#)
                                     (PROGN
                                       (LETT |k| (CAR #1#) . #4#)
                                       NIL))
                                 #5#))
                              (SEQ (EXIT
                                    (LETT |order|
                                     (MAX |order|
                                      (|RECOP;getOrder| |op| |k| $)) . #4#)))
                              (LETT #1# (CDR #1#) . #4#) #6# G191
                              (EXIT NIL))
                         (LETT |p|
                               (SPADCALL |eq|
                                   (SPADCALL
                                    (SPADCALL
                                     (SPADCALL
                                      (SPADCALL |op|
                                       (SPADCALL |argsym|
                                        (QREFELT $ 32))
                                       (QREFELT $ 60))
                                      |argsym| |order| (QREFELT $ 92))
                                     (QREFELT $ 24))
                                    1 (QREFELT $ 27))
                                   (QREFELT $ 41)) . #4#)
                         (EXIT (COND
                                 ((< 1
                                     (SPADCALL
                                      (SPADCALL |p| (QREFELT $ 47))
                                      (QREFELT $ 48)))
                                  (SEQ (LETT |s|
                                        (SPADCALL |eq| |op| |argsym|
                                         (REVERSE |values|)
                                         (QREFELT $ 97)) . #4#)
                                       (EXIT
                                        (SPADCALL |s|
                                         (PROG1
                                          (LETT #2# (QCDR |n|) . #4#)
                                           (|check-subtype| (>= #2# 0)
                                            '(|NonNegativeInteger|)
                                            #2#))
                                         (QREFELT $ 98)))))
                                 ('T
                                  (SEQ (LETT |s|
                                        (SPADCALL |eq| |op| |argsym|
                                         (SPADCALL (REVERSE |values|)
                                          |order| (QREFELT $ 93))
                                         (QREFELT $ 97)) . #4#)
                                       (EXIT
                                        (SPADCALL |s|
                                         (PROG1
                                          (LETT #3# (QCDR |n|) . #4#)
                                           (|check-subtype| (>= #3# 0)
                                            '(|NonNegativeInteger|)
                                            #3#))
                                         (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 (|ker| |l|)
    (RETURN
      (SEQ (LETT |ker| (SPADCALL |f| (QREFELT $ 24))
                 . #0=(|RECOP;getEq;2F;20|))
           (EXIT (COND
                   ((EQL (LENGTH |ker|) 1)
                    (COND
                      ((OR (SPADCALL
                               (SPADCALL
                                   (SPADCALL |ker| 1 (QREFELT $ 27))
                                   (QREFELT $ 28))
                               (SPADCALL "rootOfADE" (QREFELT $ 10))
                               (QREFELT $ 100))
                           (SPADCALL
                               (SPADCALL
                                   (SPADCALL |ker| 1 (QREFELT $ 27))
                                   (QREFELT $ 28))
                               (SPADCALL "rootOfRec" (QREFELT $ 10))
                               (QREFELT $ 100)))
                       (SEQ (LETT |l|
                                  (SPADCALL
                                      (SPADCALL |ker| 1 (QREFELT $ 27))
                                      (QREFELT $ 29)) . #0#)
                            (EXIT (SPADCALL (|RECOP;eqAsF| |l| $)
                                      (|RECOP;dummyAsF| |l| $)
                                      (|RECOP;displayVariable| |l| $)
                                      (QREFELT $ 67)))))
                      ('T
                       (|error| "getEq: argument should be a single rootOfADE or rootOfRec object"))))
                   ('T
                    (|error| "getEq: argument should be a single rootOfADE or rootOfRec object")))))))) 

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

(DEFUN |RECOP;ddADE| (|l| $)
  (PROG (|op| |values| #0=#:G40169 |i| #1=#:G40170 |vals|)
    (RETURN
      (SEQ (LETT |op| (|RECOP;operatorName| |l| $)
                 . #2=(|RECOP;ddADE|))
           (LETT |values| (REVERSE |l|) . #2#)
           (LETT |vals|
                 (CONS (SPADCALL
                           (SPADCALL
                               (SPADCALL (|RECOP;eqAsF| |l| $)
                                   (|RECOP;dummyAsF| |l| $)
                                   (|RECOP;displayVariable| |l| $)
                                   (QREFELT $ 67))
                               (QREFELT $ 81))
                           (SPADCALL (|spadConstant| $ 52)
                               (QREFELT $ 82))
                           (QREFELT $ 83))
                       (PROGN
                         (LETT #0# NIL . #2#)
                         (SEQ (LETT |i| 0 . #2#)
                              (LETT #1#
                                    (MIN 4 (- (LENGTH |values|) 5)) . #2#)
                              G190
                              (COND ((QSGREATERP |i| #1#) (GO G191)))
                              (SEQ (EXIT
                                    (LETT #0#
                                     (CONS
                                      (SPADCALL
                                       (SPADCALL
                                        (SPADCALL
                                         (SPADCALL
                                          (SPADCALL |op|
                                           (|RECOP;dummyAsF| |l| $)
                                           (QREFELT $ 60))
                                          (|RECOP;dummy| |l| $) |i|
                                          (QREFELT $ 92))
                                         (SPADCALL
                                          (|RECOP;dummyAsF| |l| $)
                                          (|spadConstant| $ 53)
                                          (QREFELT $ 104))
                                         (QREFELT $ 106))
                                        (QREFELT $ 81))
                                       (SPADCALL
                                        (SPADCALL
                                         (SPADCALL |values| (+ |i| 1)
                                          (QREFELT $ 21))
                                         (QREFELT $ 81))
                                        (SPADCALL
                                         (SPADCALL
                                          (SPADCALL
                                           (SPADCALL
                                            (SPADCALL |i|
                                             (QREFELT $ 107))
                                            (QREFELT $ 108))
                                           (QREFELT $ 109))
                                          (QREFELT $ 110))
                                         (QREFELT $ 81))
                                        (QREFELT $ 111))
                                       (QREFELT $ 83))
                                      #0#) . #2#)))
                              (LETT |i| (QSADD1 |i|) . #2#) (GO G190)
                              G191 (EXIT (NREVERSE0 #0#))))) . #2#)
           (EXIT (SPADCALL
                     (SPADCALL
                         (LIST (SPADCALL
                                   (SPADCALL
                                    (SPADCALL
                                     (|RECOP;displayVariable| |l| $)
                                     (QREFELT $ 81))
                                    (SPADCALL
                                     (|RECOP;operatorArgument| |l| $)
                                     (QREFELT $ 81))
                                    (QREFELT $ 112))
                                   (QREFELT $ 89))
                               (SPADCALL
                                   (SPADCALL |op|
                                    (|RECOP;displayVariable| |l| $)
                                    (QREFELT $ 60))
                                   (QREFELT $ 81))
                               ": " (SPADCALL |vals| (QREFELT $ 87)))
                         (QREFELT $ 88))
                     (QREFELT $ 89))))))) 

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

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

(MAKEPROP '|RecurrenceOperator| '|infovec|
    (LIST '#(NIL NIL NIL NIL NIL NIL (|local| |#1|) (|local| |#2|)
             (|String|) (|Symbol|) (0 . |coerce|) (|BasicOperator|)
             (5 . |operator|) '|oprecur| '|opADE| (|None|)
             (10 . |setProperty|) (17 . |One|) (21 . |One|) (|Integer|)
             (|List| 7) (25 . |elt|) (31 . |retract|) (|List| 38)
             (36 . |kernels|) (|Kernel| 7) (|List| 25) (41 . |elt|)
             (47 . |operator|) (52 . |argument|) (|NonNegativeInteger|)
             (57 . |rest|) (63 . |coerce|) (|Boolean|) (68 . |freeOf?|)
             (|Mapping| 33 7) (74 . |every?|) (80 . ~=) (|Kernel| $)
             (86 . |retract|)
             (|Fraction| (|SparseUnivariatePolynomial| $))
             (91 . |univariate|) (|Fraction| 46) (97 . |denominator|)
             (102 . |One|) (106 . ~=) (|SparseUnivariatePolynomial| 7)
             (112 . |numer|) (117 . |degree|) (122 . |coefficient|)
             (128 . =) (134 . |coefficients|) (139 . |Zero|)
             (143 . |Zero|) (|Union| 19 '"failed")
             (147 . |retractIfCan|) (152 . |getShiftRec|) (159 . |is?|)
             (|Record| (|:| |max| 54) (|:| |ord| 54) (|:| |ker| 25))
             (165 . |shiftInfoRec|) (172 . |elt|) (|List| $)
             (178 . |kernel|) (184 . /) (190 . -) (195 . |coerce|)
             (200 . -) (206 . |eval|) (213 . |Zero|) (217 . |Zero|)
             (|SparseMultivariatePolynomial| 6 25) (221 . |Zero|)
             (225 . |evalRec|) (|Mapping| $ $) (235 . |eval|)
             (242 . |retract|) (247 . |numberOfValuesNeeded|)
             (|Mapping| 7 20) (|BasicOperatorFunctions1| 7)
             (255 . |evaluate|) (|OutputForm|) (261 . |coerce|)
             (266 . |coerce|) (271 . =) (277 . |coerce|)
             (282 . |coerce|) (287 . |elt|) (293 . |commaSeparate|)
             (298 . |hconcat|) (303 . |bracket|) (308 . |is?|)
             (314 . |freeOf?|) (320 . D) (327 . |first|) (333 . |One|)
             (|UnivariateFormalPowerSeries| 7)
             (|ExpressionSolve| 6 7 95
                 (|UnivariateFormalPowerSeries|
                     (|SparseUnivariatePolynomialExpressions| 7)))
             (337 . |seriesSolve|) (345 . |elt|)
             |RECOP;evalADE;BoS3FLF;18| (351 . |is?|)
             |RECOP;getEq;2F;20| |RECOP;getOp;FBo;21| (|Equation| 7)
             (357 . =) (|Equation| $) (363 . |eval|) (369 . |coerce|)
             (374 . |coerce|) (379 . |box|) (384 . |factorial|)
             (389 . *) (395 . **))
          '#(|shiftInfoRec| 401 |numberOfValuesNeeded| 408
             |getShiftRec| 416 |getOp| 423 |getEq| 428 |evalRec| 433
             |evalADE| 443)
          'NIL
          (CONS (|makeByteWordVec2| 1 'NIL)
                (CONS '#()
                      (CONS '#()
                            (|makeByteWordVec2| 112
                                '(1 9 0 8 10 1 11 0 9 12 3 11 0 0 9 15
                                  16 0 6 0 17 0 7 0 18 2 20 7 0 19 21 1
                                  7 9 0 22 1 7 23 0 24 2 26 25 0 19 27
                                  1 25 11 0 28 1 25 20 0 29 2 20 0 0 30
                                  31 1 7 0 9 32 2 7 33 0 0 34 2 20 33
                                  35 0 36 2 30 33 0 0 37 1 7 38 0 39 2
                                  7 40 0 38 41 1 42 0 0 43 0 42 0 44 2
                                  42 33 0 0 45 1 42 46 0 47 1 46 30 0
                                  48 2 46 7 0 30 49 2 7 33 0 0 50 1 46
                                  20 0 51 0 6 0 52 0 7 0 53 1 7 54 0 55
                                  3 0 54 11 25 9 56 2 25 33 0 11 57 3 0
                                  58 11 9 7 59 2 7 0 11 0 60 2 7 0 11
                                  61 62 2 7 0 0 0 63 1 7 0 0 64 1 7 0
                                  19 65 2 7 0 0 0 66 3 7 0 0 0 0 67 0
                                  42 0 68 0 46 0 69 0 70 0 71 6 0 7 11
                                  9 7 7 7 20 72 3 7 0 0 11 73 74 1 19
                                  19 0 75 4 0 19 19 11 9 7 76 2 78 11
                                  11 77 79 1 7 80 0 81 1 6 80 0 82 2 80
                                  0 0 0 83 1 11 80 0 84 1 19 80 0 85 2
                                  80 0 0 61 86 1 80 0 61 87 1 80 0 61
                                  88 1 80 0 0 89 2 25 33 0 9 90 2 7 33
                                  0 9 91 3 7 0 0 9 30 92 2 20 0 0 30 93
                                  0 46 0 94 4 96 95 7 11 9 20 97 2 95 7
                                  0 30 98 2 11 33 0 9 100 2 103 0 7 7
                                  104 2 7 0 0 105 106 1 6 0 19 107 1 7
                                  0 6 108 1 7 0 0 109 1 7 0 0 110 2 80
                                  0 0 0 111 2 80 0 0 0 112 3 1 58 11 9
                                  7 59 4 0 19 19 11 9 7 76 3 1 54 11 25
                                  9 56 1 0 11 7 102 1 0 7 7 101 6 0 7
                                  11 9 7 7 7 20 72 6 0 7 11 9 7 7 7 20
                                  99)))))
          '|lookupComplete|)) 
