
(/VERSIONCHECK 2) 

(DEFUN |GUESS;ord1| (|x| |i| $)
  (PROG (#1=#:G3227 |k| #2=#:G3226 |j| #3=#:G3225 #4=#:G3224 |n|)
    (RETURN
     (SEQ (LETT |n| (- (- (LENGTH |x|) 3) |i|) . #5=(|GUESS;ord1|))
          (EXIT
           (+
            (* (SPADCALL |x| (+ |n| 1) (QREFELT $ 15))
               (SPADCALL (ELT $ 16)
                         (PROGN
                          (LETT #4# NIL . #5#)
                          (SEQ (LETT |j| 1 . #5#) G190
                               (COND ((QSGREATERP |j| |n|) #6=(GO G191)))
                               (SEQ
                                (EXIT
                                 (LETT #4#
                                       (CONS (SPADCALL |x| |j| (QREFELT $ 15))
                                             #4#)
                                       . #5#)))
                               (LETT |j| (QSADD1 |j|) . #5#) #7=(GO G190) G191
                               (EXIT (NREVERSE0 #4#))))
                         0 (QREFELT $ 18)))
            (SPADCALL 2
                      (SPADCALL (ELT $ 16)
                                (PROGN
                                 (LETT #3# NIL . #5#)
                                 (SEQ (LETT |j| 1 . #5#) G190
                                      (COND ((QSGREATERP |j| |n|) #6#))
                                      (SEQ
                                       (EXIT
                                        (LETT #3#
                                              (CONS
                                               (SPADCALL (ELT $ 16)
                                                         (PROGN
                                                          (LETT #2# NIL . #5#)
                                                          (SEQ
                                                           (LETT |k| 1 . #5#)
                                                           (LETT #1# (- |j| 1)
                                                                 . #5#)
                                                           G190
                                                           (COND
                                                            ((QSGREATERP |k|
                                                                         #1#)
                                                             #6#))
                                                           (SEQ
                                                            (EXIT
                                                             (LETT #2#
                                                                   (CONS
                                                                    (*
                                                                     (SPADCALL
                                                                      |x| |k|
                                                                      (QREFELT
                                                                       $ 15))
                                                                     (SPADCALL
                                                                      |x| |j|
                                                                      (QREFELT
                                                                       $ 15)))
                                                                    #2#)
                                                                   . #5#)))
                                                           (LETT |k|
                                                                 (QSADD1 |k|)
                                                                 . #5#)
                                                           #7# G191
                                                           (EXIT
                                                            (NREVERSE0 #2#))))
                                                         0 (QREFELT $ 18))
                                               #3#)
                                              . #5#)))
                                      (LETT |j| (QSADD1 |j|) . #5#) #7# G191
                                      (EXIT (NREVERSE0 #3#))))
                                0 (QREFELT $ 18))
                      (QREFELT $ 20)))))))) 

(DEFUN |GUESS;ord2| (|x| |i| $)
  (PROG (|j| #1=#:G3234 |n|)
    (RETURN
     (SEQ
      (COND
       ((ZEROP |i|)
        (SEQ (LETT |n| (- (- (LENGTH |x|) 3) |i|) . #2=(|GUESS;ord2|))
             (EXIT
              (+ (|GUESS;ord1| |x| |i| $)
                 (*
                  (SPADCALL (ELT $ 16)
                            (PROGN
                             (LETT #1# NIL . #2#)
                             (SEQ (LETT |j| 1 . #2#) G190
                                  (COND ((QSGREATERP |j| |n|) (GO G191)))
                                  (SEQ
                                   (EXIT
                                    (LETT #1#
                                          (CONS
                                           (SPADCALL |x| |j| (QREFELT $ 15))
                                           #1#)
                                          . #2#)))
                                  (LETT |j| (QSADD1 |j|) . #2#) (GO G190) G191
                                  (EXIT (NREVERSE0 #1#))))
                            0 (QREFELT $ 18))
                  (- (SPADCALL |x| (+ |n| 2) (QREFELT $ 15))
                     (SPADCALL |x| (+ |n| 1) (QREFELT $ 15))))))))
       ('T (|GUESS;ord1| |x| |i| $))))))) 

(DEFUN |GUESS;deg1| (|x| |i| $)
  (PROG (#1=#:G3249 |k| #2=#:G3248 |j| #3=#:G3247 #4=#:G3246 |m|)
    (RETURN
     (SEQ (LETT |m| (- (LENGTH |x|) 3) . #5=(|GUESS;deg1|))
          (EXIT
           (+
            (+
             (*
              (+
               (+ (SPADCALL |x| (+ |m| 3) (QREFELT $ 15))
                  (SPADCALL |x| (+ |m| 1) (QREFELT $ 15)))
               (SPADCALL |x| (+ 1 |i|) (QREFELT $ 15)))
              (SPADCALL (ELT $ 16)
                        (PROGN
                         (LETT #4# NIL . #5#)
                         (SEQ (LETT |j| (+ 2 |i|) . #5#) G190
                              (COND ((> |j| |m|) #6=(GO G191)))
                              (SEQ
                               (EXIT
                                (LETT #4#
                                      (CONS (SPADCALL |x| |j| (QREFELT $ 15))
                                            #4#)
                                      . #5#)))
                              (LETT |j| (+ |j| 1) . #5#) #7=(GO G190) G191
                              (EXIT (NREVERSE0 #4#))))
                        0 (QREFELT $ 18)))
             (* (SPADCALL |x| (+ |m| 3) (QREFELT $ 15))
                (SPADCALL |x| (+ |m| 1) (QREFELT $ 15))))
            (SPADCALL 2
                      (SPADCALL (ELT $ 16)
                                (PROGN
                                 (LETT #3# NIL . #5#)
                                 (SEQ (LETT |j| (+ 2 |i|) . #5#) G190
                                      (COND ((> |j| |m|) #6#))
                                      (SEQ
                                       (EXIT
                                        (LETT #3#
                                              (CONS
                                               (SPADCALL (ELT $ 16)
                                                         (PROGN
                                                          (LETT #2# NIL . #5#)
                                                          (SEQ
                                                           (LETT |k| (+ 2 |i|)
                                                                 . #5#)
                                                           (LETT #1# (- |j| 1)
                                                                 . #5#)
                                                           G190
                                                           (COND
                                                            ((> |k| #1#) #6#))
                                                           (SEQ
                                                            (EXIT
                                                             (LETT #2#
                                                                   (CONS
                                                                    (*
                                                                     (SPADCALL
                                                                      |x| |k|
                                                                      (QREFELT
                                                                       $ 15))
                                                                     (SPADCALL
                                                                      |x| |j|
                                                                      (QREFELT
                                                                       $ 15)))
                                                                    #2#)
                                                                   . #5#)))
                                                           (LETT |k| (+ |k| 1)
                                                                 . #5#)
                                                           #7# G191
                                                           (EXIT
                                                            (NREVERSE0 #2#))))
                                                         0 (QREFELT $ 18))
                                               #3#)
                                              . #5#)))
                                      (LETT |j| (+ |j| 1) . #5#) #7# G191
                                      (EXIT (NREVERSE0 #3#))))
                                0 (QREFELT $ 18))
                      (QREFELT $ 20)))))))) 

(DEFUN |GUESS;deg2| (|x| |i| $)
  (PROG (|j| #1=#:G3255 |m|)
    (RETURN
     (SEQ (LETT |m| (- (LENGTH |x|) 3) . #2=(|GUESS;deg2|))
          (EXIT
           (+ (|GUESS;deg1| |x| |i| $)
              (*
               (+ (SPADCALL |x| (+ |m| 3) (QREFELT $ 15))
                  (SPADCALL (ELT $ 16)
                            (PROGN
                             (LETT #1# NIL . #2#)
                             (SEQ (LETT |j| (+ 2 |i|) . #2#) G190
                                  (COND ((> |j| |m|) (GO G191)))
                                  (SEQ
                                   (EXIT
                                    (LETT #1#
                                          (CONS
                                           (SPADCALL |x| |j| (QREFELT $ 15))
                                           #1#)
                                          . #2#)))
                                  (LETT |j| (+ |j| 1) . #2#) (GO G190) G191
                                  (EXIT (NREVERSE0 #1#))))
                            0 (QREFELT $ 18)))
               (- (SPADCALL |x| (+ |m| 2) (QREFELT $ 15))
                  (SPADCALL |x| (+ |m| 1) (QREFELT $ 15)))))))))) 

(DEFUN |GUESS;getVariables| (|lF| $)
  (PROG (|lvar| |ll|)
    (RETURN
     (SEQ (LETT |lvar| NIL . #1=(|GUESS;getVariables|))
          (COND
           ((|HasSignature| (QREFELT $ 7)
                            (LIST '|variables|
                                  (LIST (LIST '|List| '(|Symbol|))
                                        (|devaluate| (QREFELT $ 7)))))
            (SEQ
             (COND
              ((|domainEqual| (QREFELT $ 6) (QREFELT $ 7))
               (LETT |ll| (SPADCALL (ELT $ 22) |lF| (QREFELT $ 27)) . #1#))
              ((|domainEqual| (QREFELT $ 6) (|Fraction| (QREFELT $ 7)))
               (LETT |ll|
                     (SPADCALL (CONS #'|GUESS;getVariables!0| $) |lF|
                               (QREFELT $ 35))
                     . #1#))
              (#2='T
               (|error|
                "Guess: type parameter F should be either equal to S or equal                             to Fraction S")))
             (EXIT
              (LETT |lvar| (SPADCALL (ELT $ 31) |ll| (QREFELT $ 37)) . #1#))))
           (#2# (LETT |lvar| NIL . #1#)))
          (EXIT (SPADCALL (ELT $ 39) |lvar| (QREFELT $ 43))))))) 

(DEFUN |GUESS;getVariables!0| (|g| $)
  (SPADCALL (SPADCALL (SPADCALL |g| (QREFELT $ 29)) (QREFELT $ 22))
            (SPADCALL (SPADCALL |g| (QREFELT $ 30)) (QREFELT $ 22))
            (QREFELT $ 31))) 

(DEFUN |GUESS;checkResult| (|res| |n| |l| |list| $)
  (PROG (#1=#:G3269 #2=#:G3265 |num| #3=#:G3264 |den| |i|)
    (RETURN
     (SEQ
      (EXIT
       (SEQ
        (SEQ (LETT |i| |l| . #4=(|GUESS;checkResult|)) G190
             (COND ((< |i| 1) (GO G191)))
             (SEQ
              (LETT |den|
                    (SPADCALL (SPADCALL |res| (QREFELT $ 44))
                              (SPADCALL |n| (QREFELT $ 39))
                              (SPADCALL (- |i| 1) (QREFELT $ 45))
                              (QREFELT $ 46))
                    . #4#)
              (COND
               ((SPADCALL |den| (|spadConstant| $ 49) (QREFELT $ 51))
                (PROGN
                 (LETT #1#
                       (PROG1 (LETT #3# |i| . #4#)
                         (|check-subtype| (>= #3# 0) '(|NonNegativeInteger|)
                                          #3#))
                       . #4#)
                 (GO #1#))))
              (LETT |num|
                    (SPADCALL (SPADCALL |res| (QREFELT $ 52))
                              (SPADCALL |n| (QREFELT $ 39))
                              (SPADCALL (- |i| 1) (QREFELT $ 45))
                              (QREFELT $ 46))
                    . #4#)
              (EXIT
               (COND
                ((NULL
                  (SPADCALL (SPADCALL |list| |i| (QREFELT $ 53))
                            (SPADCALL (SPADCALL |num| |den| (QREFELT $ 54))
                                      (QREFELT $ 9))
                            (QREFELT $ 55)))
                 (PROGN
                  (LETT #1#
                        (PROG1 (LETT #2# |i| . #4#)
                          (|check-subtype| (>= #2# 0) '(|NonNegativeInteger|)
                                           #2#))
                        . #4#)
                  (GO #1#))))))
             (LETT |i| (+ |i| -1) . #4#) (GO G190) G191 (EXIT NIL))
        (EXIT 0)))
      #1# (EXIT #1#))))) 

(DEFUN |GUESS;SUPS2SUPF| (|p| $)
  (COND ((|domainEqual| (QREFELT $ 6) (QREFELT $ 7)) |p|)
        ((|domainEqual| (QREFELT $ 6) (|Fraction| (QREFELT $ 7)))
         (SPADCALL (ELT $ 56) |p| (QREFELT $ 61)))
        ('T
         (|error|
          "Guess: type parameter F should be either equal to S or equal                       to Fraction S")))) 

(DEFUN |GUESS;guess;LLLLL;8| (|list| |guessers| |ops| |options| $)
  (PROG (|res| #1=#:G3332 |guess| |sumGuess| |summ| |init| #2=#:G3331 |var|
         |sumList| #3=#:G3330 |i| #4=#:G3329 #5=#:G3323 #6=#:G3328 |prodGuess|
         |prod| #7=#:G3327 |prodList| #8=#:G3326 #9=#:G3325 |newMaxLevel|
         #10=#:G3283 #11=#:G3324 |guesser| |len| #12=#:G3279 |xx|)
    (RETURN
     (SEQ
      (EXIT
       (SEQ
        (LETT |newMaxLevel| (SPADCALL |options| (QREFELT $ 65))
              . #13=(|GUESS;guess;LLLLL;8|))
        (LETT |xx|
              (SPADCALL (SPADCALL |options| (QREFELT $ 66)) (QREFELT $ 39))
              . #13#)
        (COND
         ((SPADCALL |options| (QREFELT $ 67))
          (COND
           ((QEQCAR |newMaxLevel| 0)
            (SPADCALL
             (SPADCALL "Guess: guessing level "
                       (SPADCALL |newMaxLevel| (QREFELT $ 69)) (QREFELT $ 70))
             (QREFELT $ 73))))))
        (LETT |res| NIL . #13#)
        (LETT |len|
              (PROG1 (LETT #12# (LENGTH |list|) . #13#)
                (|check-subtype| (> #12# 0) '(|PositiveInteger|) #12#))
              . #13#)
        (COND ((NULL (< 1 |len|)) (PROGN (LETT #5# |res| . #13#) (GO #5#))))
        (SEQ (LETT |guesser| NIL . #13#) (LETT #11# |guessers| . #13#) G190
             (COND
              ((OR (ATOM #11#) (PROGN (LETT |guesser| (CAR #11#) . #13#) NIL))
               #14=(GO G191)))
             (SEQ
              (LETT |res| (APPEND (SPADCALL |list| |options| |guesser|) |res|)
                    . #13#)
              (EXIT
               (COND
                ((SPADCALL |options| (QREFELT $ 74))
                 (COND
                  ((NULL (NULL |res|))
                   (PROGN (LETT #5# |res| . #13#) (GO #5#))))))))
             (LETT #11# (CDR #11#) . #13#) #15=(GO G190) G191 (EXIT NIL))
        (COND
         ((QEQCAR |newMaxLevel| 0)
          (COND
           ((ZEROP (QCDR |newMaxLevel|))
            (PROGN (LETT #5# |res| . #13#) (GO #5#)))
           (#16='T
            (LETT |newMaxLevel|
                  (CONS 0
                        (PROG1 (LETT #10# (- (QCDR |newMaxLevel|) 1) . #13#)
                          (|check-subtype| (>= #10# 0) '(|NonNegativeInteger|)
                                           #10#)))
                  . #13#)))))
        (COND
         ((SPADCALL '|guessProduct| |ops| (QREFELT $ 75))
          (COND
           ((SPADCALL (|spadConstant| $ 47) |list| (QREFELT $ 76))
            (SEQ (|spadConstant| $ 47)
                 (EXIT
                  (COND
                   ((SPADCALL |options| (QREFELT $ 67))
                    (SPADCALL "Guess: cannot use guessProduct because of zeros"
                              (QREFELT $ 78)))))))
           (#16#
            (SEQ
             (LETT |prodList|
                   (PROGN
                    (LETT #9# NIL . #13#)
                    (SEQ (LETT |i| 1 . #13#) (LETT #8# (- |len| 1) . #13#) G190
                         (COND ((QSGREATERP |i| #8#) #14#))
                         (SEQ
                          (EXIT
                           (LETT #9#
                                 (CONS
                                  (SPADCALL
                                   (SPADCALL |list| (+ |i| 1) (QREFELT $ 53))
                                   (SPADCALL |list| |i| (QREFELT $ 53))
                                   (QREFELT $ 79))
                                  #9#)
                                 . #13#)))
                         (LETT |i| (QSADD1 |i|) . #13#) #15# G191
                         (EXIT (NREVERSE0 #9#))))
                   . #13#)
             (EXIT
              (COND
               ((NULL (SPADCALL (ELT $ 81) |prodList| (QREFELT $ 83)))
                (SEQ
                 (LETT |var|
                       (SPADCALL '|p| (LIST (SPADCALL |len| (QREFELT $ 84)))
                                 (QREFELT $ 86))
                       . #13#)
                 (LETT |prodGuess| NIL . #13#)
                 (SEQ (LETT |guess| NIL . #13#)
                      (LETT #7#
                            (SPADCALL |prodList| |guessers| |ops|
                                      (APPEND
                                       (LIST (SPADCALL |var| (QREFELT $ 88))
                                             (SPADCALL |newMaxLevel|
                                                       (QREFELT $ 89)))
                                       |options|)
                                      (QREFELT $ 92))
                            . #13#)
                      G190
                      (COND
                       ((OR (ATOM #7#)
                            (PROGN (LETT |guess| (CAR #7#) . #13#) NIL))
                        #14#))
                      (SEQ
                       (LETT |init|
                             (SPADCALL (SPADCALL |list| 1 (QREFELT $ 53))
                                       (QREFELT $ 10))
                             . #13#)
                       (LETT |prod|
                             (SPADCALL |guess|
                                       (SPADCALL |var|
                                                 (SPADCALL
                                                  (|spadConstant| $ 49)
                                                  (SPADCALL |xx|
                                                            (|spadConstant| $
                                                                            93)
                                                            (QREFELT $ 94))
                                                  (QREFELT $ 96))
                                                 (QREFELT $ 98))
                                       (QREFELT $ 100))
                             . #13#)
                       (EXIT
                        (LETT |prodGuess|
                              (CONS (SPADCALL |init| |prod| (QREFELT $ 104))
                                    |prodGuess|)
                              . #13#)))
                      (LETT #7# (CDR #7#) . #13#) #15# G191 (EXIT NIL))
                 (EXIT
                  (SEQ (LETT |guess| NIL . #13#) (LETT #6# |prodGuess| . #13#)
                       G190
                       (COND
                        ((OR (ATOM #6#)
                             (PROGN (LETT |guess| (CAR #6#) . #13#) NIL))
                         #14#))
                       (SEQ
                        (EXIT
                         (COND
                          ((COND
                            ((SPADCALL |guess| |res| (QREFELT $ 105)) 'NIL)
                            (#16# 'T))
                           (LETT |res| (CONS |guess| |res|) . #13#)))))
                       (LETT #6# (CDR #6#) . #13#) #15# G191
                       (EXIT NIL))))))))))))
        (COND
         ((SPADCALL |options| (QREFELT $ 74))
          (COND
           ((NULL (NULL |res|)) (PROGN (LETT #5# |res| . #13#) (GO #5#))))))
        (COND
         ((SPADCALL '|guessSum| |ops| (QREFELT $ 75))
          (SEQ
           (LETT |sumList|
                 (PROGN
                  (LETT #4# NIL . #13#)
                  (SEQ (LETT |i| 1 . #13#) (LETT #3# (- |len| 1) . #13#) G190
                       (COND ((QSGREATERP |i| #3#) #14#))
                       (SEQ
                        (EXIT
                         (LETT #4#
                               (CONS
                                (SPADCALL
                                 (SPADCALL |list| (+ |i| 1) (QREFELT $ 53))
                                 (SPADCALL |list| |i| (QREFELT $ 53))
                                 (QREFELT $ 106))
                                #4#)
                               . #13#)))
                       (LETT |i| (QSADD1 |i|) . #13#) #15# G191
                       (EXIT (NREVERSE0 #4#))))
                 . #13#)
           (EXIT
            (COND
             ((NULL
               (SPADCALL (CONS #'|GUESS;guess;LLLLL;8!0| (VECTOR $ |sumList|))
                         |sumList| (QREFELT $ 83)))
              (SEQ
               (LETT |var|
                     (SPADCALL '|s| (LIST (SPADCALL |len| (QREFELT $ 84)))
                               (QREFELT $ 86))
                     . #13#)
               (LETT |sumGuess| NIL . #13#)
               (SEQ (LETT |guess| NIL . #13#)
                    (LETT #2#
                          (SPADCALL |sumList| |guessers| |ops|
                                    (APPEND
                                     (LIST (SPADCALL |var| (QREFELT $ 88))
                                           (SPADCALL |newMaxLevel|
                                                     (QREFELT $ 89)))
                                     |options|)
                                    (QREFELT $ 92))
                          . #13#)
                    G190
                    (COND
                     ((OR (ATOM #2#)
                          (PROGN (LETT |guess| (CAR #2#) . #13#) NIL))
                      #14#))
                    (SEQ
                     (LETT |init|
                           (SPADCALL (SPADCALL |list| 1 (QREFELT $ 53))
                                     (QREFELT $ 10))
                           . #13#)
                     (LETT |summ|
                           (SPADCALL |guess|
                                     (SPADCALL |var|
                                               (SPADCALL (|spadConstant| $ 49)
                                                         (SPADCALL |xx|
                                                                   (|spadConstant|
                                                                    $ 93)
                                                                   (QREFELT $
                                                                            94))
                                                         (QREFELT $ 96))
                                               (QREFELT $ 98))
                                     (QREFELT $ 108))
                           . #13#)
                     (EXIT
                      (LETT |sumGuess|
                            (CONS (SPADCALL |init| |summ| (QREFELT $ 109))
                                  |sumGuess|)
                            . #13#)))
                    (LETT #2# (CDR #2#) . #13#) #15# G191 (EXIT NIL))
               (EXIT
                (SEQ (LETT |guess| NIL . #13#) (LETT #1# |sumGuess| . #13#)
                     G190
                     (COND
                      ((OR (ATOM #1#)
                           (PROGN (LETT |guess| (CAR #1#) . #13#) NIL))
                       #14#))
                     (SEQ
                      (EXIT
                       (COND
                        ((COND ((SPADCALL |guess| |res| (QREFELT $ 105)) 'NIL)
                               (#16# 'T))
                         (LETT |res| (CONS |guess| |res|) . #13#)))))
                     (LETT #1# (CDR #1#) . #13#) #15# G191 (EXIT NIL))))))))))
        (EXIT |res|)))
      #5# (EXIT #5#))))) 

(DEFUN |GUESS;guess;LLLLL;8!0| (|z1| $$)
  (PROG (|sumList| $)
    (LETT |sumList| (QREFELT $$ 1) . #1=(|GUESS;guess;LLLLL;8|))
    (LETT $ (QREFELT $$ 0) . #1#)
    (RETURN
     (PROGN
      (SPADCALL |z1| (SPADCALL |sumList| (|spadConstant| $ 107) (QREFELT $ 53))
                (QREFELT $ 55)))))) 

(DEFUN |GUESS;guess;LL;9| (|list| $)
  (SPADCALL |list| (LIST (ELT $ 110)) (LIST '|guessProduct| '|guessSum|) NIL
            (QREFELT $ 92))) 

(DEFUN |GUESS;guess;LLL;10| (|list| |options| $)
  (SPADCALL |list| (LIST (ELT $ 110)) (LIST '|guessProduct| '|guessSum|)
            |options| (QREFELT $ 92))) 

(DEFUN |GUESS;guess;LLLL;11| (|list| |guessers| |ops| $)
  (SPADCALL |list| |guessers| |ops| NIL (QREFELT $ 92))) 

(DEFUN |GUESS;F2FPOLYS| (|p| $)
  (COND
   ((|domainEqual| (QREFELT $ 6) (QREFELT $ 7))
    (SPADCALL (SPADCALL |p| (QREFELT $ 115)) (QREFELT $ 117)))
   ((|domainEqual| (QREFELT $ 6) (|Fraction| (QREFELT $ 7)))
    (SPADCALL (SPADCALL (SPADCALL |p| (QREFELT $ 29)) (QREFELT $ 119))
              (SPADCALL (SPADCALL |p| (QREFELT $ 30)) (QREFELT $ 119))
              (QREFELT $ 121)))
   ('T
    (|error|
     "Guess: type parameter F should be either equal to S or equal                        to Fraction S")))) 

(DEFUN |GUESS;SUPF2EXPRR| (|xx| |p| $)
  (COND ((SPADCALL |p| (QREFELT $ 122)) (|spadConstant| $ 49))
        ('T
         (SPADCALL
          (SPADCALL (SPADCALL (SPADCALL |p| (QREFELT $ 123)) (QREFELT $ 10))
                    (SPADCALL (SPADCALL |xx| (QREFELT $ 39))
                              (SPADCALL |p| (QREFELT $ 125)) (QREFELT $ 126))
                    (QREFELT $ 104))
          (|GUESS;SUPF2EXPRR| |xx| (SPADCALL |p| (QREFELT $ 127)) $)
          (QREFELT $ 109))))) 

(DEFUN |GUESS;FSUPF2EXPRR| (|xx| |p| $)
  (SPADCALL (|GUESS;SUPF2EXPRR| |xx| (SPADCALL |p| (QREFELT $ 128)) $)
            (|GUESS;SUPF2EXPRR| |xx| (SPADCALL |p| (QREFELT $ 129)) $)
            (QREFELT $ 54))) 

(DEFUN |GUESS;POLYS2POLYF| (|p| $)
  (COND ((|domainEqual| (QREFELT $ 6) (QREFELT $ 7)) |p|)
        ((|domainEqual| (QREFELT $ 6) (|Fraction| (QREFELT $ 7)))
         (SPADCALL (ELT $ 56) |p| (QREFELT $ 131)))
        ('T
         (|error|
          "Guess: type parameter F should be either equal to S or equal                       to Fraction S")))) 

(DEFUN |GUESS;SUPPOLYS2SUPF| (|p| |a1v| |Av| $)
  (PROG (|lc|)
    (RETURN
     (SEQ
      (COND ((SPADCALL |p| (QREFELT $ 133)) (|spadConstant| $ 134))
            ('T
             (SEQ
              (LETT |lc| (|GUESS;POLYS2POLYF| (SPADCALL |p| (QREFELT $ 135)) $)
                    |GUESS;SUPPOLYS2SUPF|)
              (EXIT
               (SPADCALL
                (SPADCALL
                 (SPADCALL
                  (SPADCALL |lc|
                            (LIST (SPADCALL 1 (QREFELT $ 137))
                                  (SPADCALL 2 (QREFELT $ 137)))
                            (LIST |a1v| |Av|) (QREFELT $ 139))
                  (QREFELT $ 140))
                 (SPADCALL |p| (QREFELT $ 141)) (QREFELT $ 142))
                (|GUESS;SUPPOLYS2SUPF| (SPADCALL |p| (QREFELT $ 143)) |a1v|
                 |Av| $)
                (QREFELT $ 144)))))))))) 

(DEFUN |GUESS;SUPFPOLYS2FSUPPOLYS| (|p| $)
  (PROG (|pden| |pnum| |cden|)
    (RETURN
     (SEQ
      (LETT |cden| (SPADCALL |p| (QREFELT $ 148))
            . #1=(|GUESS;SUPFPOLYS2FSUPPOLYS|))
      (LETT |pnum|
            (SPADCALL (CONS #'|GUESS;SUPFPOLYS2FSUPPOLYS!0| (VECTOR $ |cden|))
                      |p| (QREFELT $ 153))
            . #1#)
      (LETT |pden| (SPADCALL (QCDR |cden|) (QREFELT $ 154)) . #1#)
      (EXIT (SPADCALL |pnum| |pden| (QREFELT $ 156))))))) 

(DEFUN |GUESS;SUPFPOLYS2FSUPPOLYS!0| (|z1| $$)
  (PROG (|cden| $)
    (LETT |cden| (QREFELT $$ 1) . #1=(|GUESS;SUPFPOLYS2FSUPPOLYS|))
    (LETT $ (QREFELT $$ 0) . #1#)
    (RETURN
     (PROGN
      (SPADCALL (SPADCALL |z1| (QCDR |cden|) (QREFELT $ 149))
                (QREFELT $ 150)))))) 

(PUT '|GUESS;defaultD| '|SPADreplace| '(XLAM (|expr|) |expr|)) 

(DEFUN |GUESS;defaultD| (|expr| $) |expr|) 

(DEFUN |GUESS;DN2DL| (DN |i| $)
  (SPADCALL (SPADCALL (SPADCALL |i| (QREFELT $ 45)) DN) (QREFELT $ 9))) 

(DEFUN |GUESS;evalResultant| (|p1| |p2| |o| |d| |va1| |vA| $)
  (PROG (|res| #1=#:G3366 #2=#:G3361 |lead| #3=#:G3359 #4=#:G3357 |d2atk|
         |d1atk| |p2atk| |p1atk| #5=#:G3372 |k| |d2| |d1|)
    (RETURN
     (SEQ (LETT |res| NIL . #6=(|GUESS;evalResultant|))
          (LETT |d1| (SPADCALL |p1| |va1| (QREFELT $ 157)) . #6#)
          (LETT |d2| (SPADCALL |p2| |va1| (QREFELT $ 157)) . #6#)
          (SEQ (LETT |k| 1 . #6#) (LETT #5# (+ (- |d| |o|) 1) . #6#) G190
               (COND ((QSGREATERP |k| #5#) (GO G191)))
               (SEQ
                (LETT |p1atk|
                      (SPADCALL
                       (SPADCALL |p1| |vA| (SPADCALL |k| (QREFELT $ 158))
                                 (QREFELT $ 159))
                       (QREFELT $ 160))
                      . #6#)
                (LETT |p2atk|
                      (SPADCALL
                       (SPADCALL |p2| |vA| (SPADCALL |k| (QREFELT $ 158))
                                 (QREFELT $ 159))
                       (QREFELT $ 160))
                      . #6#)
                (LETT |d1atk| (SPADCALL |p1atk| (QREFELT $ 161)) . #6#)
                (LETT |d2atk| (SPADCALL |p2atk| (QREFELT $ 161)) . #6#)
                (COND
                 ((< |d2atk| |d2|)
                  (COND
                   ((< |d1atk| |d1|) (LETT |lead| (|spadConstant| $ 48) . #6#))
                   ('T
                    (LETT |lead|
                          (SPADCALL (SPADCALL |p1atk| (QREFELT $ 162))
                                    (PROG1 (LETT #4# (- |d2| |d2atk|) . #6#)
                                      (|check-subtype| (>= #4# 0)
                                                       '(|NonNegativeInteger|)
                                                       #4#))
                                    (QREFELT $ 163))
                          . #6#))))
                 ((< |d1atk| |d1|)
                  (LETT |lead|
                        (SPADCALL
                         (SPADCALL
                          (SPADCALL (|spadConstant| $ 12) (QREFELT $ 164)) |d2|
                          (QREFELT $ 163))
                         (SPADCALL (SPADCALL |p2atk| (QREFELT $ 162))
                                   (PROG1 (LETT #3# (- |d1| |d1atk|) . #6#)
                                     (|check-subtype| (>= #3# 0)
                                                      '(|NonNegativeInteger|)
                                                      #3#))
                                   (QREFELT $ 163))
                         (QREFELT $ 165))
                        . #6#))
                 ('T (LETT |lead| (|spadConstant| $ 12) . #6#)))
                (EXIT
                 (COND
                  ((SPADCALL |lead| (QREFELT $ 166))
                   (LETT |res| (CONS (|spadConstant| $ 48) |res|) . #6#))
                  ('T
                   (LETT |res|
                         (CONS
                          (SPADCALL |lead|
                                    (PROG2
                                        (LETT #1#
                                              (SPADCALL
                                               (SPADCALL |p1atk| |p2atk|
                                                         (QREFELT $ 167))
                                               (SPADCALL
                                                (SPADCALL |k| (QREFELT $ 158))
                                                (PROG1 (LETT #2# |o| . #6#)
                                                  (|check-subtype| (>= #2# 0)
                                                                   '(|NonNegativeInteger|)
                                                                   #2#))
                                                (QREFELT $ 163))
                                               (QREFELT $ 169))
                                              . #6#)
                                        (QCDR #1#)
                                      (|check-union| (QEQCAR #1# 0)
                                                     (QREFELT $ 7) #1#))
                                    (QREFELT $ 165))
                          |res|)
                         . #6#)))))
               (LETT |k| (QSADD1 |k|) . #6#) (GO G190) G191 (EXIT NIL))
          (EXIT (REVERSE |res|)))))) 

(DEFUN |GUESS;p| (|xm| |i| |va1| |vA| |basis| $)
  (SPADCALL (SPADCALL (SPADCALL |vA| (QREFELT $ 170)) (QREFELT $ 171))
            (SPADCALL
             (SPADCALL (SPADCALL |va1| (QREFELT $ 170)) (QREFELT $ 171))
             (|GUESS;F2FPOLYS|
              (SPADCALL (|GUESS;DN2DL| |basis| |i| $)
                        (|GUESS;DN2DL| |basis| |xm| $) (QREFELT $ 106))
              $)
             (QREFELT $ 172))
            (QREFELT $ 173))) 

(DEFUN |GUESS;p2| (|xm| |i| |a1v| |Av| |basis| $)
  (SPADCALL (SPADCALL |Av| (QREFELT $ 10))
            (SPADCALL (SPADCALL |a1v| (QREFELT $ 10))
                      (SPADCALL
                       (SPADCALL (SPADCALL |i| (QREFELT $ 39)) |basis|)
                       (SPADCALL (SPADCALL |xm| (QREFELT $ 45)) |basis|)
                       (QREFELT $ 94))
                      (QREFELT $ 104))
            (QREFELT $ 109))) 

(DEFUN |GUESS;guessExpRatAux| (|xx| |list| |basis| |xValues| |options| $)
  (PROG (#1=#:G3434 |res| |res4| |denr| |numr| |ri1| |t2| |t1| |a1v| #2=#:G3438
         |g| |evalPoly| |Av| #3=#:G3437 |f| |res3| |res2| |res1| |d2| |o2| |d1|
         |o1| |n| |poly3| |poly2| |poly1| |ri| #4=#:G3411 |i| |maxDeg| |maxD|
         |y3| |y2| |y1| |ylist| #5=#:G3436 |y| |x3| |x2| |x1| |xlist|
         #6=#:G3435 |len| #7=#:G3385 A |a1|)
    (RETURN
     (SEQ
      (EXIT
       (SEQ
        (LETT |a1| (SPADCALL 1 (QREFELT $ 137)) . #8=(|GUESS;guessExpRatAux|))
        (LETT A (SPADCALL 2 (QREFELT $ 137)) . #8#)
        (LETT |len| (LENGTH |list|) . #8#)
        (COND ((< |len| 4) (PROGN (LETT #1# NIL . #8#) (GO #1#)))
              (#9='T
               (LETT |len|
                     (PROG1 (LETT #7# (- |len| 3) . #8#)
                       (|check-subtype| (>= #7# 0) '(|NonNegativeInteger|)
                                        #7#))
                     . #8#)))
        (LETT |xlist|
              (PROGN
               (LETT #6# NIL . #8#)
               (SEQ (LETT |i| 1 . #8#) G190
                    (COND ((QSGREATERP |i| |len|) #10=(GO G191)))
                    (SEQ
                     (EXIT
                      (LETT #6#
                            (CONS
                             (|GUESS;F2FPOLYS|
                              (|GUESS;DN2DL| |basis|
                               (SPADCALL |xValues| |i| (QREFELT $ 15)) $)
                              $)
                             #6#)
                            . #8#)))
                    (LETT |i| (QSADD1 |i|) . #8#) #11=(GO G190) G191
                    (EXIT (NREVERSE0 #6#))))
              . #8#)
        (LETT |x1|
              (|GUESS;F2FPOLYS|
               (|GUESS;DN2DL| |basis|
                (SPADCALL |xValues| (+ |len| 1) (QREFELT $ 15)) $)
               $)
              . #8#)
        (LETT |x2|
              (|GUESS;F2FPOLYS|
               (|GUESS;DN2DL| |basis|
                (SPADCALL |xValues| (+ |len| 2) (QREFELT $ 15)) $)
               $)
              . #8#)
        (LETT |x3|
              (|GUESS;F2FPOLYS|
               (|GUESS;DN2DL| |basis|
                (SPADCALL |xValues| (+ |len| 3) (QREFELT $ 15)) $)
               $)
              . #8#)
        (LETT |y|
              (CONS #'|GUESS;guessExpRatAux!0|
                    (VECTOR |basis| A |a1| |xValues| $ |list|))
              . #8#)
        (LETT |ylist|
              (PROGN
               (LETT #5# NIL . #8#)
               (SEQ (LETT |i| 1 . #8#) G190
                    (COND ((QSGREATERP |i| |len|) #10#))
                    (SEQ (EXIT (LETT #5# (CONS (SPADCALL |i| |y|) #5#) . #8#)))
                    (LETT |i| (QSADD1 |i|) . #8#) #11# G191
                    (EXIT (NREVERSE0 #5#))))
              . #8#)
        (LETT |y1| (SPADCALL (+ |len| 1) |y|) . #8#)
        (LETT |y2| (SPADCALL (+ |len| 2) |y|) . #8#)
        (LETT |y3| (SPADCALL (+ |len| 3) |y|) . #8#) (LETT |res| NIL . #8#)
        (SEQ (LETT |maxD| (SPADCALL |options| (QREFELT $ 177)) . #8#)
             (EXIT
              (COND
               ((QEQCAR |maxD| 0)
                (LETT |maxDeg| (MIN (QCDR |maxD|) (- |len| 1)) . #8#))
               (#9# (LETT |maxDeg| (- |len| 1) . #8#)))))
        (SEQ (LETT |i| 0 . #8#) G190 (COND ((QSGREATERP |i| |maxDeg|) #10#))
             (SEQ
              (COND
               ((SPADCALL |options| (QREFELT $ 67))
                (SPADCALL
                 (SPADCALL "Guess: degree ExpRat "
                           (SPADCALL |i| (QREFELT $ 178)) (QREFELT $ 70))
                 (QREFELT $ 73))))
              (COND
               ((SPADCALL |options| (QREFELT $ 67))
                (SEQ (SPADCALL "sys date +%s" (QREFELT $ 180))
                     (EXIT
                      (SPADCALL "Guess: interpolating..." (QREFELT $ 73))))))
              (LETT |ri|
                    (SPADCALL |xlist| |ylist|
                              (PROG1 (LETT #4# (- (- |len| 1) |i|) . #8#)
                                (|check-subtype| (>= #4# 0)
                                                 '(|NonNegativeInteger|) #4#))
                              (QREFELT $ 184))
                    . #8#)
              (COND
               ((SPADCALL |options| (QREFELT $ 67))
                (SPADCALL "Guess: polynomials..." (QREFELT $ 73))))
              (LETT |poly1|
                    (SPADCALL
                     (SPADCALL (SPADCALL |ri| |x1| (QREFELT $ 186)) |y1|
                               (QREFELT $ 187))
                     (QREFELT $ 188))
                    . #8#)
              (LETT |poly2|
                    (SPADCALL
                     (SPADCALL (SPADCALL |ri| |x2| (QREFELT $ 186)) |y2|
                               (QREFELT $ 187))
                     (QREFELT $ 188))
                    . #8#)
              (LETT |poly3|
                    (SPADCALL
                     (SPADCALL (SPADCALL |ri| |x3| (QREFELT $ 186)) |y3|
                               (QREFELT $ 187))
                     (QREFELT $ 188))
                    . #8#)
              (LETT |n| (- |len| |i|) . #8#)
              (LETT |o1| (|GUESS;ord1| |xValues| |i| $) . #8#)
              (LETT |d1| (|GUESS;deg1| |xValues| |i| $) . #8#)
              (LETT |o2| (|GUESS;ord2| |xValues| |i| $) . #8#)
              (LETT |d2| (|GUESS;deg2| |xValues| |i| $) . #8#)
              (COND
               ((SPADCALL |options| (QREFELT $ 67))
                (SPADCALL "Guess: interpolating resultants..."
                          (QREFELT $ 73))))
              (LETT |res1|
                    (SPADCALL
                     (|GUESS;evalResultant| |poly1| |poly3| |o1| |d1| |a1| A $)
                     (QREFELT $ 190))
                    . #8#)
              (LETT |res2|
                    (SPADCALL
                     (|GUESS;evalResultant| |poly2| |poly3| |o2| |d2| |a1| A $)
                     (QREFELT $ 190))
                    . #8#)
              (COND
               ((SPADCALL |options| (QREFELT $ 67))
                (SPADCALL "Guess: computing gcd..." (QREFELT $ 73))))
              (LETT |res3|
                    (|GUESS;SUPS2SUPF|
                     (SPADCALL (SPADCALL |res1| |res2| (QREFELT $ 191))
                               (QREFELT $ 192))
                     $)
                    . #8#)
              (COND
               ((SPADCALL |options| (QREFELT $ 67))
                (SPADCALL "Guess: solving..." (QREFELT $ 73))))
              (SEQ (LETT |f| NIL . #8#)
                   (LETT #3#
                         (SPADCALL (SPADCALL |res3| (QREFELT $ 195))
                                   (QREFELT $ 198))
                         . #8#)
                   G190
                   (COND
                    ((OR (ATOM #3#) (PROGN (LETT |f| (CAR #3#) . #8#) NIL))
                     #10#))
                   (SEQ
                    (EXIT
                     (COND
                      ((EQL (SPADCALL (QCAR |f|) (QREFELT $ 125)) 1)
                       (SEQ
                        (LETT |Av|
                              (SPADCALL
                               (SPADCALL
                                (SPADCALL (QCAR |f|) 0 (QREFELT $ 199))
                                (SPADCALL (QCAR |f|) (QREFELT $ 123))
                                (QREFELT $ 79))
                               (QREFELT $ 200))
                              . #8#)
                        (LETT |evalPoly|
                              (SPADCALL (|GUESS;POLYS2POLYF| |poly3| $) A |Av|
                                        (QREFELT $ 201))
                              . #8#)
                        (COND
                         ((SPADCALL |evalPoly| (QREFELT $ 202))
                          (LETT |evalPoly|
                                (SPADCALL (|GUESS;POLYS2POLYF| |poly1| $) A
                                          |Av| (QREFELT $ 201))
                                . #8#)))
                        (EXIT
                         (SEQ (LETT |g| NIL . #8#)
                              (LETT #2#
                                    (SPADCALL
                                     (SPADCALL
                                      (SPADCALL |evalPoly| (QREFELT $ 203))
                                      (QREFELT $ 195))
                                     (QREFELT $ 198))
                                    . #8#)
                              G190
                              (COND
                               ((OR (ATOM #2#)
                                    (PROGN (LETT |g| (CAR #2#) . #8#) NIL))
                                #10#))
                              (SEQ
                               (EXIT
                                (COND
                                 ((EQL (SPADCALL (QCAR |g|) (QREFELT $ 125)) 1)
                                  (SEQ
                                   (LETT |a1v|
                                         (SPADCALL
                                          (SPADCALL
                                           (SPADCALL (QCAR |g|) 0
                                                     (QREFELT $ 199))
                                           (SPADCALL (QCAR |g|)
                                                     (QREFELT $ 123))
                                           (QREFELT $ 79))
                                          (QREFELT $ 200))
                                         . #8#)
                                   (LETT |t1|
                                         (SPADCALL
                                          (|GUESS;POLYS2POLYF| |poly1| $)
                                          (LIST |a1| A) (LIST |a1v| |Av|)
                                          (QREFELT $ 139))
                                         . #8#)
                                   (EXIT
                                    (COND
                                     ((SPADCALL |t1| (QREFELT $ 202))
                                      (SEQ
                                       (LETT |t2|
                                             (SPADCALL
                                              (|GUESS;POLYS2POLYF| |poly2| $)
                                              (LIST |a1| A) (LIST |a1v| |Av|)
                                              (QREFELT $ 139))
                                             . #8#)
                                       (EXIT
                                        (COND
                                         ((SPADCALL |t2| (QREFELT $ 202))
                                          (SEQ
                                           (LETT |ri1|
                                                 (SPADCALL
                                                  (|GUESS;SUPFPOLYS2FSUPPOLYS|
                                                   (SPADCALL |ri|
                                                             (QREFELT $ 204))
                                                   $)
                                                  (|GUESS;SUPFPOLYS2FSUPPOLYS|
                                                   (SPADCALL |ri|
                                                             (QREFELT $ 205))
                                                   $)
                                                  (QREFELT $ 206))
                                                 . #8#)
                                           (LETT |numr|
                                                 (|GUESS;SUPPOLYS2SUPF|
                                                  (SPADCALL |ri1|
                                                            (QREFELT $ 207))
                                                  |a1v| |Av| $)
                                                 . #8#)
                                           (LETT |denr|
                                                 (|GUESS;SUPPOLYS2SUPF|
                                                  (SPADCALL |ri1|
                                                            (QREFELT $ 208))
                                                  |a1v| |Av| $)
                                                 . #8#)
                                           (EXIT
                                            (COND
                                             ((SPADCALL |denr| (QREFELT $ 122))
                                              (COND
                                               ((SPADCALL |numr|
                                                          (QREFELT $ 122))
                                                (COND
                                                 ((SPADCALL |options|
                                                            (QREFELT $ 67))
                                                  (SPADCALL
                                                   "Guess: numerator and denominator vanish!"
                                                   (QREFELT $ 78)))))))
                                             ('T
                                              (SEQ
                                               (LETT |res4|
                                                     (SPADCALL
                                                      (SPADCALL
                                                       (|GUESS;FSUPF2EXPRR|
                                                        |xx|
                                                        (SPADCALL |numr| |denr|
                                                                  (QREFELT $
                                                                           209))
                                                        $)
                                                       (SPADCALL |xx|
                                                                 (QREFELT $
                                                                          211))
                                                       (SPADCALL
                                                        (SPADCALL |xx|
                                                                  (QREFELT $
                                                                           39))
                                                        |basis|)
                                                       (QREFELT $ 213))
                                                      (SPADCALL
                                                       (|GUESS;p2|
                                                        (SPADCALL |xValues|
                                                                  (QREFELT $
                                                                           174))
                                                        |xx| |a1v| |Av| |basis|
                                                        $)
                                                       (SPADCALL |xx|
                                                                 (QREFELT $
                                                                          39))
                                                       (QREFELT $ 214))
                                                      (QREFELT $ 104))
                                                     . #8#)
                                               (EXIT
                                                (LETT |res| (CONS |res4| |res|)
                                                      . #8#)))))))))))))))))))
                              (LETT #2# (CDR #2#) . #8#) #11# G191
                              (EXIT NIL))))))))
                   (LETT #3# (CDR #3#) . #8#) #11# G191 (EXIT NIL))
              (EXIT
               (COND
                ((NULL (NULL |res|))
                 (COND
                  ((SPADCALL |options| (QREFELT $ 74))
                   (PROGN (LETT #1# |res| . #8#) (GO #1#))))))))
             (LETT |i| (QSADD1 |i|) . #8#) #11# G191 (EXIT NIL))
        (EXIT |res|)))
      #1# (EXIT #1#))))) 

(DEFUN |GUESS;guessExpRatAux!0| (|z1| $$)
  (PROG (|list| $ |xValues| |a1| A |basis|)
    (LETT |list| (QREFELT $$ 5) . #1=(|GUESS;guessExpRatAux|))
    (LETT $ (QREFELT $$ 4) . #1#)
    (LETT |xValues| (QREFELT $$ 3) . #1#)
    (LETT |a1| (QREFELT $$ 2) . #1#)
    (LETT A (QREFELT $$ 1) . #1#)
    (LETT |basis| (QREFELT $$ 0) . #1#)
    (RETURN
     (PROGN
      (SPADCALL (|GUESS;F2FPOLYS| (SPADCALL |list| |z1| (QREFELT $ 53)) $)
                (SPADCALL
                 (|GUESS;p| (SPADCALL |xValues| (QREFELT $ 174))
                  (SPADCALL |xValues| |z1| (QREFELT $ 15)) |a1| A |basis| $)
                 (SPADCALL (SPADCALL |xValues| |z1| (QREFELT $ 15))
                           (QREFELT $ 175))
                 (QREFELT $ 176))
                (QREFELT $ 172)))))) 

(DEFUN |GUESS;guessExpRatAux0| (|list| |basis| |options| $)
  (PROG (|res| #1=#:G3456 |f| #2=#:G3455 |xValues| |newlist| |i| #3=#:G3454 |x|
         |zeros| #4=#:G3453 |shortlist| #5=#:G3441 #6=#:G3452 |len| |xx|)
    (RETURN
     (SEQ
      (EXIT
       (SEQ
        (COND
         ((ZEROP (SPADCALL |options| (QREFELT $ 215)))
          (|error| "Guess: guessExpRat does not support zero safety")))
        (LETT |xx| (SPADCALL |options| (QREFELT $ 66))
              . #7=(|GUESS;guessExpRatAux0|))
        (LETT |len| (LENGTH |list|) . #7#)
        (COND
         ((< (+ (- |len| (SPADCALL |options| (QREFELT $ 215))) 1) 0)
          (PROGN (LETT #6# NIL . #7#) (GO #6#))))
        (LETT |shortlist|
              (SPADCALL |list|
                        (PROG1
                            (LETT #5#
                                  (+
                                   (- |len|
                                      (SPADCALL |options| (QREFELT $ 215)))
                                   1)
                                  . #7#)
                          (|check-subtype| (>= #5# 0) '(|NonNegativeInteger|)
                                           #5#))
                        (QREFELT $ 216))
              . #7#)
        (LETT |zeros| (|spadConstant| $ 93) . #7#) (LETT |i| -1 . #7#)
        (SEQ (LETT |x| NIL . #7#) (LETT #4# |shortlist| . #7#) G190
             (COND
              ((OR (ATOM #4#) (PROGN (LETT |x| (CAR #4#) . #7#) NIL))
               #8=(GO G191)))
             (SEQ (LETT |i| (+ |i| 1) . #7#)
                  (EXIT
                   (COND
                    ((SPADCALL |x| (|spadConstant| $ 47) (QREFELT $ 55))
                     (LETT |zeros|
                           (SPADCALL |zeros|
                                     (SPADCALL
                                      (SPADCALL (SPADCALL |xx| (QREFELT $ 39))
                                                |basis|)
                                      (SPADCALL (SPADCALL |i| (QREFELT $ 45))
                                                |basis|)
                                      (QREFELT $ 94))
                                     (QREFELT $ 104))
                           . #7#)))))
             (LETT #4# (CDR #4#) . #7#) #9=(GO G190) G191 (EXIT NIL))
        (LETT |i| -1 . #7#)
        (SEQ (LETT |x| NIL . #7#) (LETT #3# |shortlist| . #7#) G190
             (COND
              ((OR (ATOM #3#) (PROGN (LETT |x| (CAR #3#) . #7#) NIL)) #8#))
             (SEQ (LETT |i| (+ |i| 1) . #7#)
                  (EXIT
                   (COND
                    ((NULL (SPADCALL |x| (|spadConstant| $ 47) (QREFELT $ 55)))
                     (SEQ
                      (LETT |newlist|
                            (CONS
                             (SPADCALL |x|
                                       (SPADCALL
                                        (SPADCALL |zeros|
                                                  (SPADCALL |xx|
                                                            (QREFELT $ 39))
                                                  (SPADCALL |i| (QREFELT $ 45))
                                                  (QREFELT $ 46))
                                        (QREFELT $ 9))
                                       (QREFELT $ 79))
                             |newlist|)
                            . #7#)
                      (EXIT (LETT |xValues| (CONS |i| |xValues|) . #7#)))))))
             (LETT #3# (CDR #3#) . #7#) #9# G191 (EXIT NIL))
        (LETT |newlist| (REVERSE |newlist|) . #7#)
        (LETT |xValues| (REVERSE |xValues|) . #7#)
        (LETT |res|
              (PROGN
               (LETT #2# NIL . #7#)
               (SEQ (LETT |f| NIL . #7#)
                    (LETT #1#
                          (|GUESS;guessExpRatAux| |xx| |newlist| |basis|
                           |xValues| |options| $)
                          . #7#)
                    G190
                    (COND
                     ((OR (ATOM #1#) (PROGN (LETT |f| (CAR #1#) . #7#) NIL))
                      #8#))
                    (SEQ
                     (EXIT
                      (LETT #2#
                            (CONS
                             (SPADCALL (SPADCALL |zeros| |f| (QREFELT $ 104))
                                       (SPADCALL |xx| (QREFELT $ 39))
                                       (SPADCALL |xx| (QREFELT $ 39))
                                       (QREFELT $ 46))
                             #2#)
                            . #7#)))
                    (LETT #1# (CDR #1#) . #7#) #9# G191
                    (EXIT (NREVERSE0 #2#))))
              . #7#)
        (EXIT
         (SPADCALL
          (CONS #'|GUESS;guessExpRatAux0!0|
                (VECTOR |options| $ |list| |len| |xx|))
          |res| (QREFELT $ 220)))))
      #6# (EXIT #6#))))) 

(DEFUN |GUESS;guessExpRatAux0!0| (|z1| $$)
  (PROG (|xx| |len| |list| $ |options|)
    (LETT |xx| (QREFELT $$ 4) . #1=(|GUESS;guessExpRatAux0|))
    (LETT |len| (QREFELT $$ 3) . #1#)
    (LETT |list| (QREFELT $$ 2) . #1#)
    (LETT $ (QREFELT $$ 1) . #1#)
    (LETT |options| (QREFELT $$ 0) . #1#)
    (RETURN
     (PROGN
      (SPADCALL (|GUESS;checkResult| |z1| |xx| |len| |list| $)
                (SPADCALL |len| (SPADCALL |options| (QREFELT $ 215))
                          (QREFELT $ 217))
                (QREFELT $ 218)))))) 

(DEFUN |GUESS;guessExpRat;LL;25| (|list| $)
  (|GUESS;guessExpRatAux0| |list| (CONS (|function| |GUESS;defaultD|) $) NIL $)) 

(DEFUN |GUESS;guessExpRat;LLL;26| (|list| |options| $)
  (|GUESS;guessExpRatAux0| |list| (CONS (|function| |GUESS;defaultD|) $)
   |options| $)) 

(DEFUN |GUESS;guessExpRat;SM;27| (|q| $)
  (PROG () (RETURN (CONS #'|GUESS;guessExpRat;SM;27!1| (VECTOR |q| $))))) 

(DEFUN |GUESS;guessExpRat;SM;27!1| (|z1| |z2| $$)
  (PROG ($ |q|)
    (LETT $ (QREFELT $$ 1) . #1=(|GUESS;guessExpRat;SM;27|))
    (LETT |q| (QREFELT $$ 0) . #1#)
    (RETURN
     (PROGN
      (PROG ()
        (RETURN
         (|GUESS;guessExpRatAux0| |z1|
          (CONS #'|GUESS;guessExpRat;SM;27!0| (VECTOR $ |q|)) |z2| $))))))) 

(DEFUN |GUESS;guessExpRat;SM;27!0| (|i1| $$)
  (PROG (|q| $)
    (LETT |q| (QREFELT $$ 1) NIL)
    (LETT $ (QREFELT $$ 0) NIL)
    (RETURN
     (PROGN (SPADCALL (SPADCALL |q| (QREFELT $ 39)) |i1| (QREFELT $ 214)))))) 

(DEFUN |GUESS;binExt| (|i| |va1| |vA| $)
  (PROG (|num| |numl| #1=#:G3471 |l| #2=#:G3470)
    (RETURN
     (SEQ
      (LETT |numl|
            (PROGN
             (LETT #2# NIL . #3=(|GUESS;binExt|))
             (SEQ (LETT |l| 0 . #3#) (LETT #1# (- |i| 1) . #3#) G190
                  (COND ((QSGREATERP |l| #1#) (GO G191)))
                  (SEQ
                   (EXIT
                    (LETT #2#
                          (CONS
                           (SPADCALL
                            (SPADCALL (SPADCALL |vA| (QREFELT $ 170))
                                      (SPADCALL |i|
                                                (SPADCALL |va1|
                                                          (QREFELT $ 170))
                                                (QREFELT $ 224))
                                      (QREFELT $ 225))
                            (SPADCALL |l| (QREFELT $ 226)) (QREFELT $ 227))
                           #2#)
                          . #3#)))
                  (LETT |l| (QSADD1 |l|) . #3#) (GO G190) G191
                  (EXIT (NREVERSE0 #2#))))
            . #3#)
      (LETT |num|
            (SPADCALL (ELT $ 228) |numl| (|spadConstant| $ 229)
                      (QREFELT $ 232))
            . #3#)
      (EXIT
       (SPADCALL |num|
                 (SPADCALL (SPADCALL |i| (QREFELT $ 233)) (QREFELT $ 226))
                 (QREFELT $ 121))))))) 

(DEFUN |GUESS;binExtEXPR| (|i| |a1v| |Av| $)
  (SPADCALL
   (SPADCALL (SPADCALL |Av| (QREFELT $ 10))
             (SPADCALL (SPADCALL |a1v| (QREFELT $ 10))
                       (SPADCALL |i| (QREFELT $ 39)) (QREFELT $ 104))
             (QREFELT $ 109))
   (SPADCALL |i| (QREFELT $ 39)) (QREFELT $ 234))) 

(DEFUN |GUESS;guessBinRatAux|
       (|xx| |list| |basis| |ext| |extEXPR| |xValues| |options| $)
  (PROG (#1=#:G3502 |res| |res4| |denr| |numr| |ri1| |t2| |t1| |a1v| #2=#:G3506
         |g| |evalPoly| |Av| #3=#:G3505 |f| |res3| |res2| |res1| |n| |poly3|
         |poly2| |poly1| |ri| #4=#:G3485 |i| |maxDeg| |maxD| |y3| |y2| |y1|
         |ylist| #5=#:G3504 |y| |x3| |x2| |x1| |xlist| #6=#:G3503 |len|
         #7=#:G3473 A |a1|)
    (RETURN
     (SEQ
      (EXIT
       (SEQ
        (LETT |a1| (SPADCALL 1 (QREFELT $ 137)) . #8=(|GUESS;guessBinRatAux|))
        (LETT A (SPADCALL 2 (QREFELT $ 137)) . #8#)
        (LETT |len| (LENGTH |list|) . #8#)
        (COND ((< |len| 4) (PROGN (LETT #1# NIL . #8#) (GO #1#)))
              (#9='T
               (LETT |len|
                     (PROG1 (LETT #7# (- |len| 3) . #8#)
                       (|check-subtype| (>= #7# 0) '(|NonNegativeInteger|)
                                        #7#))
                     . #8#)))
        (LETT |xlist|
              (PROGN
               (LETT #6# NIL . #8#)
               (SEQ (LETT |i| 1 . #8#) G190
                    (COND ((QSGREATERP |i| |len|) #10=(GO G191)))
                    (SEQ
                     (EXIT
                      (LETT #6#
                            (CONS
                             (|GUESS;F2FPOLYS|
                              (|GUESS;DN2DL| |basis|
                               (SPADCALL |xValues| |i| (QREFELT $ 15)) $)
                              $)
                             #6#)
                            . #8#)))
                    (LETT |i| (QSADD1 |i|) . #8#) #11=(GO G190) G191
                    (EXIT (NREVERSE0 #6#))))
              . #8#)
        (LETT |x1|
              (|GUESS;F2FPOLYS|
               (|GUESS;DN2DL| |basis|
                (SPADCALL |xValues| (+ |len| 1) (QREFELT $ 15)) $)
               $)
              . #8#)
        (LETT |x2|
              (|GUESS;F2FPOLYS|
               (|GUESS;DN2DL| |basis|
                (SPADCALL |xValues| (+ |len| 2) (QREFELT $ 15)) $)
               $)
              . #8#)
        (LETT |x3|
              (|GUESS;F2FPOLYS|
               (|GUESS;DN2DL| |basis|
                (SPADCALL |xValues| (+ |len| 3) (QREFELT $ 15)) $)
               $)
              . #8#)
        (LETT |y|
              (CONS #'|GUESS;guessBinRatAux!0|
                    (VECTOR |ext| A |a1| |xValues| $ |list|))
              . #8#)
        (LETT |ylist|
              (PROGN
               (LETT #5# NIL . #8#)
               (SEQ (LETT |i| 1 . #8#) G190
                    (COND ((QSGREATERP |i| |len|) #10#))
                    (SEQ (EXIT (LETT #5# (CONS (SPADCALL |i| |y|) #5#) . #8#)))
                    (LETT |i| (QSADD1 |i|) . #8#) #11# G191
                    (EXIT (NREVERSE0 #5#))))
              . #8#)
        (LETT |y1| (SPADCALL (+ |len| 1) |y|) . #8#)
        (LETT |y2| (SPADCALL (+ |len| 2) |y|) . #8#)
        (LETT |y3| (SPADCALL (+ |len| 3) |y|) . #8#) (LETT |res| NIL . #8#)
        (SEQ (LETT |maxD| (SPADCALL |options| (QREFELT $ 177)) . #8#)
             (EXIT
              (COND
               ((QEQCAR |maxD| 0)
                (LETT |maxDeg| (MIN (QCDR |maxD|) (- |len| 1)) . #8#))
               (#9# (LETT |maxDeg| (- |len| 1) . #8#)))))
        (SEQ (LETT |i| 0 . #8#) G190 (COND ((QSGREATERP |i| |maxDeg|) #10#))
             (SEQ
              (LETT |ri|
                    (SPADCALL |xlist| |ylist|
                              (PROG1 (LETT #4# (- (- |len| 1) |i|) . #8#)
                                (|check-subtype| (>= #4# 0)
                                                 '(|NonNegativeInteger|) #4#))
                              (QREFELT $ 184))
                    . #8#)
              (LETT |poly1|
                    (SPADCALL
                     (SPADCALL (SPADCALL |ri| |x1| (QREFELT $ 186)) |y1|
                               (QREFELT $ 187))
                     (QREFELT $ 188))
                    . #8#)
              (LETT |poly2|
                    (SPADCALL
                     (SPADCALL (SPADCALL |ri| |x2| (QREFELT $ 186)) |y2|
                               (QREFELT $ 187))
                     (QREFELT $ 188))
                    . #8#)
              (LETT |poly3|
                    (SPADCALL
                     (SPADCALL (SPADCALL |ri| |x3| (QREFELT $ 186)) |y3|
                               (QREFELT $ 187))
                     (QREFELT $ 188))
                    . #8#)
              (LETT |n| (- |len| |i|) . #8#)
              (LETT |res1|
                    (SPADCALL (SPADCALL |poly1| |poly3| |a1| (QREFELT $ 236))
                              (QREFELT $ 160))
                    . #8#)
              (LETT |res2|
                    (SPADCALL (SPADCALL |poly2| |poly3| |a1| (QREFELT $ 236))
                              (QREFELT $ 160))
                    . #8#)
              (COND
               ((SPADCALL |options| (QREFELT $ 67))
                (SPADCALL "Guess: computing gcd..." (QREFELT $ 73))))
              (LETT |res3|
                    (|GUESS;SUPS2SUPF|
                     (SPADCALL (SPADCALL |res1| |res2| (QREFELT $ 191))
                               (QREFELT $ 192))
                     $)
                    . #8#)
              (SEQ (LETT |f| NIL . #8#)
                   (LETT #3#
                         (SPADCALL (SPADCALL |res3| (QREFELT $ 195))
                                   (QREFELT $ 198))
                         . #8#)
                   G190
                   (COND
                    ((OR (ATOM #3#) (PROGN (LETT |f| (CAR #3#) . #8#) NIL))
                     #10#))
                   (SEQ
                    (EXIT
                     (COND
                      ((EQL (SPADCALL (QCAR |f|) (QREFELT $ 125)) 1)
                       (SEQ
                        (LETT |Av|
                              (SPADCALL
                               (SPADCALL
                                (SPADCALL (QCAR |f|) 0 (QREFELT $ 199))
                                (SPADCALL (QCAR |f|) (QREFELT $ 123))
                                (QREFELT $ 79))
                               (QREFELT $ 200))
                              . #8#)
                        (LETT |evalPoly|
                              (SPADCALL (|GUESS;POLYS2POLYF| |poly3| $) A |Av|
                                        (QREFELT $ 201))
                              . #8#)
                        (COND
                         ((SPADCALL |evalPoly| (QREFELT $ 202))
                          (LETT |evalPoly|
                                (SPADCALL (|GUESS;POLYS2POLYF| |poly1| $) A
                                          |Av| (QREFELT $ 201))
                                . #8#)))
                        (EXIT
                         (SEQ (LETT |g| NIL . #8#)
                              (LETT #2#
                                    (SPADCALL
                                     (SPADCALL
                                      (SPADCALL |evalPoly| (QREFELT $ 203))
                                      (QREFELT $ 195))
                                     (QREFELT $ 198))
                                    . #8#)
                              G190
                              (COND
                               ((OR (ATOM #2#)
                                    (PROGN (LETT |g| (CAR #2#) . #8#) NIL))
                                #10#))
                              (SEQ
                               (EXIT
                                (COND
                                 ((EQL (SPADCALL (QCAR |g|) (QREFELT $ 125)) 1)
                                  (SEQ
                                   (LETT |a1v|
                                         (SPADCALL
                                          (SPADCALL
                                           (SPADCALL (QCAR |g|) 0
                                                     (QREFELT $ 199))
                                           (SPADCALL (QCAR |g|)
                                                     (QREFELT $ 123))
                                           (QREFELT $ 79))
                                          (QREFELT $ 200))
                                         . #8#)
                                   (LETT |t1|
                                         (SPADCALL
                                          (|GUESS;POLYS2POLYF| |poly1| $)
                                          (LIST |a1| A) (LIST |a1v| |Av|)
                                          (QREFELT $ 139))
                                         . #8#)
                                   (EXIT
                                    (COND
                                     ((SPADCALL |t1| (QREFELT $ 202))
                                      (SEQ
                                       (LETT |t2|
                                             (SPADCALL
                                              (|GUESS;POLYS2POLYF| |poly2| $)
                                              (LIST |a1| A) (LIST |a1v| |Av|)
                                              (QREFELT $ 139))
                                             . #8#)
                                       (EXIT
                                        (COND
                                         ((SPADCALL |t2| (QREFELT $ 202))
                                          (SEQ
                                           (LETT |ri1|
                                                 (SPADCALL
                                                  (|GUESS;SUPFPOLYS2FSUPPOLYS|
                                                   (SPADCALL |ri|
                                                             (QREFELT $ 204))
                                                   $)
                                                  (|GUESS;SUPFPOLYS2FSUPPOLYS|
                                                   (SPADCALL |ri|
                                                             (QREFELT $ 205))
                                                   $)
                                                  (QREFELT $ 206))
                                                 . #8#)
                                           (LETT |numr|
                                                 (|GUESS;SUPPOLYS2SUPF|
                                                  (SPADCALL |ri1|
                                                            (QREFELT $ 207))
                                                  |a1v| |Av| $)
                                                 . #8#)
                                           (LETT |denr|
                                                 (|GUESS;SUPPOLYS2SUPF|
                                                  (SPADCALL |ri1|
                                                            (QREFELT $ 208))
                                                  |a1v| |Av| $)
                                                 . #8#)
                                           (EXIT
                                            (COND
                                             ((SPADCALL |denr| (QREFELT $ 122))
                                              (COND
                                               ((SPADCALL |numr|
                                                          (QREFELT $ 122))
                                                (COND
                                                 ((SPADCALL |options|
                                                            (QREFELT $ 67))
                                                  (SPADCALL
                                                   "Guess: numerator and denominator vanish!"
                                                   (QREFELT $ 78)))))))
                                             ('T
                                              (SEQ
                                               (LETT |res4|
                                                     (SPADCALL
                                                      (SPADCALL
                                                       (|GUESS;FSUPF2EXPRR|
                                                        |xx|
                                                        (SPADCALL |numr| |denr|
                                                                  (QREFELT $
                                                                           209))
                                                        $)
                                                       (SPADCALL |xx|
                                                                 (QREFELT $
                                                                          211))
                                                       (SPADCALL
                                                        (SPADCALL |xx|
                                                                  (QREFELT $
                                                                           39))
                                                        |basis|)
                                                       (QREFELT $ 213))
                                                      (SPADCALL |xx| |a1v| |Av|
                                                                |extEXPR|)
                                                      (QREFELT $ 104))
                                                     . #8#)
                                               (EXIT
                                                (LETT |res| (CONS |res4| |res|)
                                                      . #8#)))))))))))))))))))
                              (LETT #2# (CDR #2#) . #8#) #11# G191
                              (EXIT NIL))))))))
                   (LETT #3# (CDR #3#) . #8#) #11# G191 (EXIT NIL))
              (EXIT
               (COND
                ((NULL (NULL |res|))
                 (COND
                  ((SPADCALL |options| (QREFELT $ 74))
                   (PROGN (LETT #1# |res| . #8#) (GO #1#))))))))
             (LETT |i| (QSADD1 |i|) . #8#) #11# G191 (EXIT NIL))
        (EXIT |res|)))
      #1# (EXIT #1#))))) 

(DEFUN |GUESS;guessBinRatAux!0| (|z1| $$)
  (PROG (|list| $ |xValues| |a1| A |ext|)
    (LETT |list| (QREFELT $$ 5) . #1=(|GUESS;guessBinRatAux|))
    (LETT $ (QREFELT $$ 4) . #1#)
    (LETT |xValues| (QREFELT $$ 3) . #1#)
    (LETT |a1| (QREFELT $$ 2) . #1#)
    (LETT A (QREFELT $$ 1) . #1#)
    (LETT |ext| (QREFELT $$ 0) . #1#)
    (RETURN
     (PROGN
      (SPADCALL (|GUESS;F2FPOLYS| (SPADCALL |list| |z1| (QREFELT $ 53)) $)
                (SPADCALL (SPADCALL |xValues| |z1| (QREFELT $ 15)) |a1| A
                          |ext|)
                (QREFELT $ 235)))))) 

(DEFUN |GUESS;guessBinRatAux0| (|list| |basis| |ext| |extEXPR| |options| $)
  (PROG (|res| #1=#:G3529 |f| #2=#:G3528 |xValues| |newlist| |i| #3=#:G3527 |x|
         |zeros| #4=#:G3526 |shortlist| #5=#:G3509 #6=#:G3525 |len| |xx|)
    (RETURN
     (SEQ
      (EXIT
       (SEQ
        (COND
         ((ZEROP (SPADCALL |options| (QREFELT $ 215)))
          (|error| "Guess: guessBinRat does not support zero safety")))
        (LETT |xx| (SPADCALL |options| (QREFELT $ 66))
              . #7=(|GUESS;guessBinRatAux0|))
        (LETT |len| (LENGTH |list|) . #7#)
        (COND
         ((< (+ (- |len| (SPADCALL |options| (QREFELT $ 215))) 1) 0)
          (PROGN (LETT #6# NIL . #7#) (GO #6#))))
        (LETT |shortlist|
              (SPADCALL |list|
                        (PROG1
                            (LETT #5#
                                  (+
                                   (- |len|
                                      (SPADCALL |options| (QREFELT $ 215)))
                                   1)
                                  . #7#)
                          (|check-subtype| (>= #5# 0) '(|NonNegativeInteger|)
                                           #5#))
                        (QREFELT $ 216))
              . #7#)
        (LETT |zeros| (|spadConstant| $ 93) . #7#) (LETT |i| -1 . #7#)
        (SEQ (LETT |x| NIL . #7#) (LETT #4# |shortlist| . #7#) G190
             (COND
              ((OR (ATOM #4#) (PROGN (LETT |x| (CAR #4#) . #7#) NIL))
               #8=(GO G191)))
             (SEQ (LETT |i| (+ |i| 1) . #7#)
                  (EXIT
                   (COND
                    ((SPADCALL |x| (|spadConstant| $ 47) (QREFELT $ 55))
                     (LETT |zeros|
                           (SPADCALL |zeros|
                                     (SPADCALL
                                      (SPADCALL (SPADCALL |xx| (QREFELT $ 39))
                                                |basis|)
                                      (SPADCALL (SPADCALL |i| (QREFELT $ 45))
                                                |basis|)
                                      (QREFELT $ 94))
                                     (QREFELT $ 104))
                           . #7#)))))
             (LETT #4# (CDR #4#) . #7#) #9=(GO G190) G191 (EXIT NIL))
        (LETT |i| -1 . #7#)
        (SEQ (LETT |x| NIL . #7#) (LETT #3# |shortlist| . #7#) G190
             (COND
              ((OR (ATOM #3#) (PROGN (LETT |x| (CAR #3#) . #7#) NIL)) #8#))
             (SEQ (LETT |i| (+ |i| 1) . #7#)
                  (EXIT
                   (COND
                    ((NULL (SPADCALL |x| (|spadConstant| $ 47) (QREFELT $ 55)))
                     (SEQ
                      (LETT |newlist|
                            (CONS
                             (SPADCALL |x|
                                       (SPADCALL
                                        (SPADCALL |zeros|
                                                  (SPADCALL |xx|
                                                            (QREFELT $ 39))
                                                  (SPADCALL |i| (QREFELT $ 45))
                                                  (QREFELT $ 46))
                                        (QREFELT $ 9))
                                       (QREFELT $ 79))
                             |newlist|)
                            . #7#)
                      (EXIT (LETT |xValues| (CONS |i| |xValues|) . #7#)))))))
             (LETT #3# (CDR #3#) . #7#) #9# G191 (EXIT NIL))
        (LETT |newlist| (REVERSE |newlist|) . #7#)
        (LETT |xValues| (REVERSE |xValues|) . #7#)
        (LETT |res|
              (PROGN
               (LETT #2# NIL . #7#)
               (SEQ (LETT |f| NIL . #7#)
                    (LETT #1#
                          (|GUESS;guessBinRatAux| |xx| |newlist| |basis| |ext|
                           |extEXPR| |xValues| |options| $)
                          . #7#)
                    G190
                    (COND
                     ((OR (ATOM #1#) (PROGN (LETT |f| (CAR #1#) . #7#) NIL))
                      #8#))
                    (SEQ
                     (EXIT
                      (LETT #2#
                            (CONS
                             (SPADCALL (SPADCALL |zeros| |f| (QREFELT $ 104))
                                       (SPADCALL |xx| (QREFELT $ 39))
                                       (SPADCALL |xx| (QREFELT $ 39))
                                       (QREFELT $ 46))
                             #2#)
                            . #7#)))
                    (LETT #1# (CDR #1#) . #7#) #9# G191
                    (EXIT (NREVERSE0 #2#))))
              . #7#)
        (EXIT
         (SPADCALL
          (CONS #'|GUESS;guessBinRatAux0!0|
                (VECTOR |options| $ |list| |len| |xx|))
          |res| (QREFELT $ 220)))))
      #6# (EXIT #6#))))) 

(DEFUN |GUESS;guessBinRatAux0!0| (|z1| $$)
  (PROG (|xx| |len| |list| $ |options|)
    (LETT |xx| (QREFELT $$ 4) . #1=(|GUESS;guessBinRatAux0|))
    (LETT |len| (QREFELT $$ 3) . #1#)
    (LETT |list| (QREFELT $$ 2) . #1#)
    (LETT $ (QREFELT $$ 1) . #1#)
    (LETT |options| (QREFELT $$ 0) . #1#)
    (RETURN
     (PROGN
      (SPADCALL (|GUESS;checkResult| |z1| |xx| |len| |list| $)
                (SPADCALL |len| (SPADCALL |options| (QREFELT $ 215))
                          (QREFELT $ 217))
                (QREFELT $ 218)))))) 

(DEFUN |GUESS;guessBinRat;LL;32| (|list| $)
  (|GUESS;guessBinRatAux0| |list| (CONS (|function| |GUESS;defaultD|) $)
   (CONS (|function| |GUESS;binExt|) $)
   (CONS (|function| |GUESS;binExtEXPR|) $) NIL $)) 

(DEFUN |GUESS;guessBinRat;LLL;33| (|list| |options| $)
  (|GUESS;guessBinRatAux0| |list| (CONS (|function| |GUESS;defaultD|) $)
   (CONS (|function| |GUESS;binExt|) $)
   (CONS (|function| |GUESS;binExtEXPR|) $) |options| $)) 

(DEFUN |GUESS;qD| (|q| $)
  (PROG () (RETURN (CONS #'|GUESS;qD!0| (VECTOR $ |q|))))) 

(DEFUN |GUESS;qD!0| (|z1| $$)
  (PROG (|q| $)
    (LETT |q| (QREFELT $$ 1) . #1=(|GUESS;qD|))
    (LETT $ (QREFELT $$ 0) . #1#)
    (RETURN
     (PROGN (SPADCALL (SPADCALL |q| (QREFELT $ 39)) |z1| (QREFELT $ 214)))))) 

(DEFUN |GUESS;qBinExtAux| (|q| |i| |va1| |vA| $)
  (PROG (|fl| |l| #1=#:G3554)
    (RETURN
     (SEQ
      (LETT |fl|
            (PROGN
             (LETT #1# NIL . #2=(|GUESS;qBinExtAux|))
             (SEQ (LETT |l| 1 . #2#) G190
                  (COND ((QSGREATERP |l| |i|) (GO G191)))
                  (SEQ
                   (EXIT
                    (LETT #1#
                          (CONS
                           (SPADCALL
                            (SPADCALL (|spadConstant| $ 239)
                                      (SPADCALL
                                       (SPADCALL
                                        (SPADCALL
                                         (SPADCALL |va1| (QREFELT $ 170))
                                         (QREFELT $ 171))
                                        (SPADCALL
                                         (SPADCALL
                                          (SPADCALL |vA| (QREFELT $ 170))
                                          (QREFELT $ 171))
                                         (- |i| 1) (QREFELT $ 176))
                                        (QREFELT $ 172))
                                       (SPADCALL
                                        (|GUESS;F2FPOLYS|
                                         (SPADCALL |q| (QREFELT $ 240)) $)
                                        |l| (QREFELT $ 176))
                                       (QREFELT $ 172))
                                      (QREFELT $ 187))
                            (SPADCALL (|spadConstant| $ 239)
                                      (SPADCALL
                                       (|GUESS;F2FPOLYS|
                                        (SPADCALL |q| (QREFELT $ 240)) $)
                                       |l| (QREFELT $ 176))
                                      (QREFELT $ 187))
                            (QREFELT $ 235))
                           #1#)
                          . #2#)))
                  (LETT |l| (QSADD1 |l|) . #2#) (GO G190) G191
                  (EXIT (NREVERSE0 #1#))))
            . #2#)
      (EXIT
       (SPADCALL (ELT $ 172) |fl| (|spadConstant| $ 239) (QREFELT $ 242))))))) 

(DEFUN |GUESS;qBinExt| (|q| $)
  (PROG () (RETURN (CONS #'|GUESS;qBinExt!0| (VECTOR $ |q|))))) 

(DEFUN |GUESS;qBinExt!0| (|z1| |z2| |z3| $$)
  (PROG (|q| $)
    (LETT |q| (QREFELT $$ 1) . #1=(|GUESS;qBinExt|))
    (LETT $ (QREFELT $$ 0) . #1#)
    (RETURN (PROGN (|GUESS;qBinExtAux| |q| |z1| |z2| |z3| $))))) 

(DEFUN |GUESS;qBinExtEXPRaux| (|q| |i| |a1v| |Av| $)
  (PROG (|l|)
    (RETURN
     (SEQ (LETT |l| '|l| |GUESS;qBinExtEXPRaux|)
          (EXIT
           (SPADCALL
            (SPADCALL
             (SPADCALL (|spadConstant| $ 93)
                       (SPADCALL
                        (SPADCALL (SPADCALL |a1v| (QREFELT $ 10))
                                  (SPADCALL (SPADCALL |Av| (QREFELT $ 10))
                                            (SPADCALL
                                             (SPADCALL |i| (QREFELT $ 39))
                                             (|spadConstant| $ 93)
                                             (QREFELT $ 94))
                                            (QREFELT $ 214))
                                  (QREFELT $ 104))
                        (SPADCALL (SPADCALL |q| (QREFELT $ 39))
                                  (SPADCALL |l| (QREFELT $ 39))
                                  (QREFELT $ 214))
                        (QREFELT $ 104))
                       (QREFELT $ 94))
             (SPADCALL (|spadConstant| $ 93)
                       (SPADCALL (SPADCALL |q| (QREFELT $ 39))
                                 (SPADCALL |l| (QREFELT $ 39)) (QREFELT $ 214))
                       (QREFELT $ 94))
             (QREFELT $ 54))
            (SPADCALL |l|
                      (SPADCALL (|spadConstant| $ 93)
                                (SPADCALL |i| (QREFELT $ 39)) (QREFELT $ 96))
                      (QREFELT $ 98))
            (QREFELT $ 100))))))) 

(DEFUN |GUESS;qBinExtEXPR| (|q| $)
  (PROG () (RETURN (CONS #'|GUESS;qBinExtEXPR!0| (VECTOR $ |q|))))) 

(DEFUN |GUESS;qBinExtEXPR!0| (|z1| |z2| |z3| $$)
  (PROG (|q| $)
    (LETT |q| (QREFELT $$ 1) . #1=(|GUESS;qBinExtEXPR|))
    (LETT $ (QREFELT $$ 0) . #1#)
    (RETURN (PROGN (|GUESS;qBinExtEXPRaux| |q| |z1| |z2| |z3| $))))) 

(DEFUN |GUESS;guessBinRat;SM;39| (|q| $)
  (PROG () (RETURN (CONS #'|GUESS;guessBinRat;SM;39!0| (VECTOR $ |q|))))) 

(DEFUN |GUESS;guessBinRat;SM;39!0| (|z1| |z2| $$)
  (PROG (|q| $)
    (LETT |q| (QREFELT $$ 1) . #1=(|GUESS;guessBinRat;SM;39|))
    (LETT $ (QREFELT $$ 0) . #1#)
    (RETURN
     (PROGN
      (|GUESS;guessBinRatAux0| |z1| (|GUESS;qD| |q| $) (|GUESS;qBinExt| |q| $)
       (|GUESS;qBinExtEXPR| |q| $) |z2| $))))) 

(DEFUN |GUESS;FilteredPartitionStream| (|options| $)
  (PROG (|s| |s3| |s2| |s1| |maxD| |Somo| |maxP| |homo|)
    (RETURN
     (SEQ
      (LETT |maxP| (SPADCALL |options| (QREFELT $ 245))
            . #1=(|GUESS;FilteredPartitionStream|))
      (LETT |homo| (SPADCALL |options| (QREFELT $ 247)) . #1#)
      (COND
       ((QEQCAR |homo| 1)
        (COND
         ((QCDR |homo|)
          (EXIT
           (|error|
            "Guess: internal error - homogeneous should not be true in FilteredPartitionStream")))))
       (#2='T (LETT |maxP| (CONS 0 (QCDR |homo|)) . #1#)))
      (LETT |maxD| (SPADCALL |options| (QREFELT $ 248)) . #1#)
      (LETT |Somo| (SPADCALL |options| (QREFELT $ 249)) . #1#)
      (COND
       ((QEQCAR |Somo| 1)
        (COND
         ((QCDR |Somo|)
          (EXIT
           (|error|
            "Guess: internal error - Somos should not be true in FilteredPartitionStream")))))
       ((QEQCAR |maxD| 0)
        (LETT |maxD| (CONS 0 (MIN (QCDR |maxD|) (QCDR |Somo|))) . #1#))
       (#2# (LETT |maxD| (CONS 0 (QCDR |Somo|)) . #1#)))
      (COND
       ((QEQCAR |maxD| 0)
        (COND
         ((QEQCAR |maxP| 0)
          (LETT |s|
                (SPADCALL (+ (QCDR |maxD|) 1) (QCDR |maxP|) (QREFELT $ 252))
                . #1#))
         (#2#
          (SEQ (LETT |s1| (SPADCALL (ELT $ 253) 1 (QREFELT $ 256)) . #1#)
               (LETT |s2|
                     (COND
                      ((QEQCAR |maxD| 0)
                       (SPADCALL
                        (CONS #'|GUESS;FilteredPartitionStream!0|
                              (VECTOR $ |maxD|))
                        |s1| (QREFELT $ 262)))
                      ((QEQCAR |maxP| 0)
                       (SPADCALL
                        (CONS #'|GUESS;FilteredPartitionStream!1|
                              (VECTOR $ |maxP|))
                        |s1| (QREFELT $ 262)))
                      (#2# (SPADCALL (ELT $ 263) |s1| (QREFELT $ 262))))
                     . #1#)
               (LETT |s3| (SPADCALL |s2| (QREFELT $ 265)) . #1#)
               (EXIT (LETT |s| (SPADCALL NIL |s3| (QREFELT $ 266)) . #1#))))))
       (#2#
        (SEQ (LETT |s1| (SPADCALL (ELT $ 253) 1 (QREFELT $ 256)) . #1#)
             (LETT |s2|
                   (COND
                    ((QEQCAR |maxD| 0)
                     (SPADCALL
                      (CONS #'|GUESS;FilteredPartitionStream!2|
                            (VECTOR $ |maxD|))
                      |s1| (QREFELT $ 262)))
                    ((QEQCAR |maxP| 0)
                     (SPADCALL
                      (CONS #'|GUESS;FilteredPartitionStream!3|
                            (VECTOR $ |maxP|))
                      |s1| (QREFELT $ 262)))
                    (#2# (SPADCALL (ELT $ 263) |s1| (QREFELT $ 262))))
                   . #1#)
             (LETT |s3| (SPADCALL |s2| (QREFELT $ 265)) . #1#)
             (EXIT (LETT |s| (SPADCALL NIL |s3| (QREFELT $ 266)) . #1#)))))
      (LETT |s| (SPADCALL |s| (QREFELT $ 267)) . #1#)
      (COND
       ((QEQCAR |homo| 0)
        (LETT |s|
              (SPADCALL
               (CONS #'|GUESS;FilteredPartitionStream!4| (VECTOR |maxP| $)) |s|
               (QREFELT $ 271))
              . #1#)))
      (COND
       ((QEQCAR |Somo| 0)
        (LETT |s|
              (SPADCALL
               (CONS #'|GUESS;FilteredPartitionStream!5| (VECTOR |Somo| $)) |s|
               (QREFELT $ 271))
              . #1#)))
      (EXIT |s|))))) 

(DEFUN |GUESS;FilteredPartitionStream!5| (|z1| $$)
  (PROG ($ |Somo|)
    (LETT $ (QREFELT $$ 1) . #1=(|GUESS;FilteredPartitionStream|))
    (LETT |Somo| (QREFELT $$ 0) . #1#)
    (RETURN
     (PROGN
      (SPADCALL
       (SPADCALL (ELT $ 16) |z1| (|spadConstant| $ 273) (QREFELT $ 18))
       (SPADCALL (QCDR |Somo|) (SPADCALL |z1| (QREFELT $ 268)) (QREFELT $ 257))
       (QREFELT $ 274)))))) 

(DEFUN |GUESS;FilteredPartitionStream!4| (|z1| $$)
  (PROG ($ |maxP|)
    (LETT $ (QREFELT $$ 1) . #1=(|GUESS;FilteredPartitionStream|))
    (LETT |maxP| (QREFELT $$ 0) . #1#)
    (RETURN
     (PROGN
      (PROG (#2=#:G3574)
        (RETURN
         (SPADCALL (SPADCALL |z1| (QREFELT $ 268))
                   (PROG2
                       (LETT #2# |maxP| NIL)
                       (QCDR #2#)
                     (|check-union| (QEQCAR #2# 0) (|PositiveInteger|) #2#))
                   (QREFELT $ 269)))))))) 

(DEFUN |GUESS;FilteredPartitionStream!3| (|z1| $$)
  (PROG (|maxP| $)
    (LETT |maxP| (QREFELT $$ 1) . #1=(|GUESS;FilteredPartitionStream|))
    (LETT $ (QREFELT $$ 0) . #1#)
    (RETURN (PROGN (SPADCALL |z1| (QCDR |maxP|) |z1| (QREFELT $ 258)))))) 

(DEFUN |GUESS;FilteredPartitionStream!2| (|z1| $$)
  (PROG (|maxD| $)
    (LETT |maxD| (QREFELT $$ 1) . #1=(|GUESS;FilteredPartitionStream|))
    (LETT $ (QREFELT $$ 0) . #1#)
    (RETURN
     (PROGN
      (SPADCALL (SPADCALL (QCDR |maxD|) (|spadConstant| $ 107) (QREFELT $ 257))
                |z1| |z1| (QREFELT $ 258)))))) 

(DEFUN |GUESS;FilteredPartitionStream!1| (|z1| $$)
  (PROG (|maxP| $)
    (LETT |maxP| (QREFELT $$ 1) . #1=(|GUESS;FilteredPartitionStream|))
    (LETT $ (QREFELT $$ 0) . #1#)
    (RETURN (PROGN (SPADCALL |z1| (QCDR |maxP|) |z1| (QREFELT $ 258)))))) 

(DEFUN |GUESS;FilteredPartitionStream!0| (|z1| $$)
  (PROG (|maxD| $)
    (LETT |maxD| (QREFELT $$ 1) . #1=(|GUESS;FilteredPartitionStream|))
    (LETT $ (QREFELT $$ 0) . #1#)
    (RETURN
     (PROGN
      (SPADCALL (SPADCALL (QCDR |maxD|) (|spadConstant| $ 107) (QREFELT $ 257))
                |z1| |z1| (QREFELT $ 258)))))) 

(DEFUN |GUESS;termAsEXPRR| (|f| |xx| |partition| DX D1X $)
  (PROG (|fl| #1=#:G3618 #2=#:G3617 #3=#:G3627 |part| #4=#:G3626 |ll|)
    (RETURN
     (SEQ
      (COND ((NULL |partition|) (SPADCALL |xx| D1X))
            ('T
             (SEQ
              (LETT |ll| (SPADCALL |partition| (QREFELT $ 277))
                    . #5=(|GUESS;termAsEXPRR|))
              (LETT |fl|
                    (PROGN
                     (LETT #4# NIL . #5#)
                     (SEQ (LETT |part| NIL . #5#) (LETT #3# |ll| . #5#) G190
                          (COND
                           ((OR (ATOM #3#)
                                (PROGN (LETT |part| (CAR #3#) . #5#) NIL))
                            (GO G191)))
                          (SEQ
                           (EXIT
                            (LETT #4#
                                  (CONS
                                   (SPADCALL
                                    (SPADCALL |f| |xx|
                                              (PROG1
                                                  (LETT #2#
                                                        (- (|SPADfirst| |part|)
                                                           1)
                                                        . #5#)
                                                (|check-subtype| (>= #2# 0)
                                                                 '(|NonNegativeInteger|)
                                                                 #2#))
                                              DX)
                                    (PROG1
                                        (LETT #1#
                                              (SPADCALL |part| (QREFELT $ 278))
                                              . #5#)
                                      (|check-subtype| (>= #1# 0)
                                                       '(|NonNegativeInteger|)
                                                       #1#))
                                    (QREFELT $ 126))
                                   #4#)
                                  . #5#)))
                          (LETT #3# (CDR #3#) . #5#) (GO G190) G191
                          (EXIT (NREVERSE0 #4#))))
                    . #5#)
              (EXIT (SPADCALL (ELT $ 104) |fl| (QREFELT $ 280)))))))))) 

(DEFUN |GUESS;termAsU32VectorDiff| (|f| |partition| |prime| |degreeLoss| $)
  (PROG (|fl| #1=#:G3631 #2=#:G3630 #3=#:G3641 |part| #4=#:G3640 |ll| |d|
         #5=#:G3629 #6=#:G3639 |i| #7=#:G3638)
    (RETURN
     (SEQ
      (COND
       ((NULL |partition|)
        (SPADCALL
         (CONS 1
               (PROGN
                (LETT #7# NIL . #8=(|GUESS;termAsU32VectorDiff|))
                (SEQ (LETT |i| (+ |degreeLoss| 2) . #8#)
                     (LETT #6# (QV32LEN |f|) . #8#) G190
                     (COND ((> |i| #6#) #9=(GO G191)))
                     (SEQ (EXIT (LETT #7# (CONS 0 #7#) . #8#)))
                     (LETT |i| (+ |i| 1) . #8#) #10=(GO G190) G191
                     (EXIT (NREVERSE0 #7#)))))
         (QREFELT $ 282)))
       ('T
        (SEQ
         (LETT |d|
               (PROG1 (LETT #5# (- (- (QV32LEN |f|) |degreeLoss|) 1) . #8#)
                 (|check-subtype| (>= #5# 0) '(|NonNegativeInteger|) #5#))
               . #8#)
         (LETT |ll| (SPADCALL |partition| (QREFELT $ 277)) . #8#)
         (LETT |fl|
               (PROGN
                (LETT #4# NIL . #8#)
                (SEQ (LETT |part| NIL . #8#) (LETT #3# |ll| . #8#) G190
                     (COND
                      ((OR (ATOM #3#)
                           (PROGN (LETT |part| (CAR #3#) . #8#) NIL))
                       #9#))
                     (SEQ
                      (EXIT
                       (LETT #4#
                             (CONS
                              (SPADCALL
                               (SPADCALL |f|
                                         (PROG1
                                             (LETT #2#
                                                   (- (|SPADfirst| |part|) 1)
                                                   . #8#)
                                           (|check-subtype| (>= #2# 0)
                                                            '(|NonNegativeInteger|)
                                                            #2#))
                                         |prime| (QREFELT $ 284))
                               (PROG1
                                   (LETT #1# (SPADCALL |part| (QREFELT $ 278))
                                         . #8#)
                                 (|check-subtype| (> #1# 0)
                                                  '(|PositiveInteger|) #1#))
                               |d| |prime| (QREFELT $ 285))
                              #4#)
                             . #8#)))
                     (LETT #3# (CDR #3#) . #8#) #10# G191
                     (EXIT (NREVERSE0 #4#))))
               . #8#)
         (EXIT
          (SPADCALL
           (CONS #'|GUESS;termAsU32VectorDiff!0| (VECTOR $ |prime| |d|)) |fl|
           (QREFELT $ 289)))))))))) 

(DEFUN |GUESS;termAsU32VectorDiff!0| (|f1| |f2| $$)
  (PROG (|d| |prime| $)
    (LETT |d| (QREFELT $$ 2) . #1=(|GUESS;termAsU32VectorDiff|))
    (LETT |prime| (QREFELT $$ 1) . #1#)
    (LETT $ (QREFELT $$ 0) . #1#)
    (RETURN (PROGN (SPADCALL |f1| |f2| |d| |prime| (QREFELT $ 286)))))) 

(DEFUN |GUESS;termAsU32VectorShift| (|f| |partition| |prime| |degreeLoss| $)
  (PROG (#1=#:G3658 |e| |i| |r| |fl| #2=#:G3644 #3=#:G3657 |j| #4=#:G3656
         #5=#:G3655 |part| #6=#:G3654 |ll| |d| #7=#:G3643 #8=#:G3653
         #9=#:G3652)
    (RETURN
     (SEQ
      (COND
       ((NULL |partition|)
        (SPADCALL
         (PROGN
          (LETT #9# NIL . #10=(|GUESS;termAsU32VectorShift|))
          (SEQ (LETT |i| (+ |degreeLoss| 1) . #10#)
               (LETT #8# (QV32LEN |f|) . #10#) G190
               (COND ((> |i| #8#) #11=(GO G191)))
               (SEQ (EXIT (LETT #9# (CONS 1 #9#) . #10#)))
               (LETT |i| (+ |i| 1) . #10#) #12=(GO G190) G191
               (EXIT (NREVERSE0 #9#))))
         (QREFELT $ 282)))
       ('T
        (SEQ
         (LETT |d|
               (PROG1 (LETT #7# (- (- (QV32LEN |f|) |degreeLoss|) 1) . #10#)
                 (|check-subtype| (>= #7# 0) '(|NonNegativeInteger|) #7#))
               . #10#)
         (LETT |ll| (SPADCALL |partition| (QREFELT $ 277)) . #10#)
         (LETT |fl|
               (PROGN
                (LETT #6# NIL . #10#)
                (SEQ (LETT |part| NIL . #10#) (LETT #5# |ll| . #10#) G190
                     (COND
                      ((OR (ATOM #5#)
                           (PROGN (LETT |part| (CAR #5#) . #10#) NIL))
                       #11#))
                     (SEQ
                      (EXIT
                       (LETT #6#
                             (CONS
                              (SPADCALL
                               (PROGN
                                (LETT #4# NIL . #10#)
                                (SEQ
                                 (LETT |j| (- (|SPADfirst| |part|) 1) . #10#)
                                 (LETT #3# (+ (- (|SPADfirst| |part|) 1) |d|)
                                       . #10#)
                                 G190 (COND ((> |j| #3#) #11#))
                                 (SEQ
                                  (EXIT
                                   (LETT #4#
                                         (CONS
                                          (REMAINDER2
                                           (EXPT (ELT32 |f| |j|)
                                                 (PROG1
                                                     (LETT #2#
                                                           (SPADCALL |part|
                                                                     (QREFELT $
                                                                              278))
                                                           . #10#)
                                                   (|check-subtype| (> #2# 0)
                                                                    '(|PositiveInteger|)
                                                                    #2#)))
                                           |prime|)
                                          #4#)
                                         . #10#)))
                                 (LETT |j| (+ |j| 1) . #10#) #12# G191
                                 (EXIT (NREVERSE0 #4#))))
                               (QREFELT $ 282))
                              #6#)
                             . #10#)))
                     (LETT #5# (CDR #5#) . #10#) #12# G191
                     (EXIT (NREVERSE0 #6#))))
               . #10#)
         (LETT |r| (GETREFV32 (+ |d| 1) 0) . #10#)
         (SPADCALL |r| (|SPADfirst| |fl|) (+ |d| 1) (QREFELT $ 290))
         (SEQ (LETT |i| 0 . #10#) G190 (COND ((QSGREATERP |i| |d|) #11#))
              (SEQ
               (EXIT
                (SEQ (LETT |e| NIL . #10#) (LETT #1# (CDR |fl|) . #10#) G190
                     (COND
                      ((OR (ATOM #1#) (PROGN (LETT |e| (CAR #1#) . #10#) NIL))
                       #11#))
                     (SEQ
                      (EXIT
                       (SETELT32 |r| |i|
                                 (QSMULMOD32 (ELT32 |r| |i|) (ELT32 |e| |i|)
                                             |prime|))))
                     (LETT #1# (CDR #1#) . #10#) #12# G191 (EXIT NIL))))
              (LETT |i| (QSADD1 |i|) . #10#) #12# G191 (EXIT NIL))
         (EXIT |r|)))))))) 

(DEFUN |GUESS;termAsUFPSF| (|f| |partition| DS D1 $)
  (PROG (|fl| #1=#:G3667 #2=#:G3666 #3=#:G3676 |part| #4=#:G3675 |ll|)
    (RETURN
     (SEQ
      (COND ((NULL |partition|) D1)
            ('T
             (SEQ
              (LETT |ll| (SPADCALL |partition| (QREFELT $ 277))
                    . #5=(|GUESS;termAsUFPSF|))
              (LETT |fl|
                    (PROGN
                     (LETT #4# NIL . #5#)
                     (SEQ (LETT |part| NIL . #5#) (LETT #3# |ll| . #5#) G190
                          (COND
                           ((OR (ATOM #3#)
                                (PROGN (LETT |part| (CAR #3#) . #5#) NIL))
                            (GO G191)))
                          (SEQ
                           (EXIT
                            (LETT #4#
                                  (CONS
                                   (SPADCALL
                                    (SPADCALL |f|
                                              (PROG1
                                                  (LETT #2#
                                                        (- (|SPADfirst| |part|)
                                                           1)
                                                        . #5#)
                                                (|check-subtype| (>= #2# 0)
                                                                 '(|NonNegativeInteger|)
                                                                 #2#))
                                              DS)
                                    (PROG1
                                        (LETT #1#
                                              (SPADCALL |part| (QREFELT $ 278))
                                              . #5#)
                                      (|check-subtype| (>= #1# 0)
                                                       '(|NonNegativeInteger|)
                                                       #1#))
                                    (QREFELT $ 292))
                                   #4#)
                                  . #5#)))
                          (LETT #3# (CDR #3#) . #5#) (GO G190) G191
                          (EXIT (NREVERSE0 #4#))))
                    . #5#)
              (EXIT (SPADCALL (ELT $ 293) |fl| (QREFELT $ 296)))))))))) 

(DEFUN |GUESS;termAsUFPSF2| (|f| |partition| DS D1 $)
  (PROG (|fl| #1=#:G3680 #2=#:G3689 |part| #3=#:G3688 |ll|)
    (RETURN
     (SEQ
      (COND ((NULL |partition|) D1)
            ('T
             (SEQ
              (LETT |ll| (SPADCALL |partition| (QREFELT $ 277))
                    . #4=(|GUESS;termAsUFPSF2|))
              (LETT |fl|
                    (PROGN
                     (LETT #3# NIL . #4#)
                     (SEQ (LETT |part| NIL . #4#) (LETT #2# |ll| . #4#) G190
                          (COND
                           ((OR (ATOM #2#)
                                (PROGN (LETT |part| (CAR #2#) . #4#) NIL))
                            (GO G191)))
                          (SEQ
                           (EXIT
                            (LETT #3#
                                  (CONS
                                   (SPADCALL
                                    (CONS #'|GUESS;termAsUFPSF2!0|
                                          (VECTOR $ |part|))
                                    (SPADCALL |f|
                                              (PROG1
                                                  (LETT #1#
                                                        (- (|SPADfirst| |part|)
                                                           1)
                                                        . #4#)
                                                (|check-subtype| (>= #1# 0)
                                                                 '(|NonNegativeInteger|)
                                                                 #1#))
                                              DS)
                                    (QREFELT $ 299))
                                   #3#)
                                  . #4#)))
                          (LETT #2# (CDR #2#) . #4#) (GO G190) G191
                          (EXIT (NREVERSE0 #3#))))
                    . #4#)
              (EXIT (SPADCALL (ELT $ 301) |fl| (QREFELT $ 296)))))))))) 

(DEFUN |GUESS;termAsUFPSF2!0| (|z1| $$)
  (PROG (|part| $)
    (LETT |part| (QREFELT $$ 1) . #1=(|GUESS;termAsUFPSF2|))
    (LETT $ (QREFELT $$ 0) . #1#)
    (RETURN
     (PROGN
      (PROG (#2=#:G3678)
        (RETURN
         (SPADCALL |z1|
                   (PROG1 (LETT #2# (SPADCALL |part| (QREFELT $ 278)) NIL)
                     (|check-subtype| (>= #2# 0) '(|NonNegativeInteger|) #2#))
                   (QREFELT $ 297)))))))) 

(DEFUN |GUESS;termAsUFPSSUPF2| (|f| |partition| DSF D1F $)
  (PROG (|fl| #1=#:G3692 #2=#:G3702 |part| #3=#:G3701 |ll|)
    (RETURN
     (SEQ
      (COND ((NULL |partition|) D1F)
            ('T
             (SEQ
              (LETT |ll| (SPADCALL |partition| (QREFELT $ 277))
                    . #4=(|GUESS;termAsUFPSSUPF2|))
              (LETT |fl|
                    (PROGN
                     (LETT #3# NIL . #4#)
                     (SEQ (LETT |part| NIL . #4#) (LETT #2# |ll| . #4#) G190
                          (COND
                           ((OR (ATOM #2#)
                                (PROGN (LETT |part| (CAR #2#) . #4#) NIL))
                            (GO G191)))
                          (SEQ
                           (EXIT
                            (LETT #3#
                                  (CONS
                                   (SPADCALL
                                    (CONS #'|GUESS;termAsUFPSSUPF2!0|
                                          (VECTOR $ |part|))
                                    (SPADCALL |f|
                                              (PROG1
                                                  (LETT #1#
                                                        (- (|SPADfirst| |part|)
                                                           1)
                                                        . #4#)
                                                (|check-subtype| (>= #1# 0)
                                                                 '(|NonNegativeInteger|)
                                                                 #1#))
                                              DSF)
                                    (QREFELT $ 306))
                                   #3#)
                                  . #4#)))
                          (LETT #2# (CDR #2#) . #4#) (GO G190) G191
                          (EXIT (NREVERSE0 #3#))))
                    . #4#)
              (EXIT (SPADCALL (ELT $ 308) |fl| (QREFELT $ 311)))))))))) 

(DEFUN |GUESS;termAsUFPSSUPF2!0| (|z1| $$)
  (PROG (|part| $)
    (LETT |part| (QREFELT $$ 1) . #1=(|GUESS;termAsUFPSSUPF2|))
    (LETT $ (QREFELT $$ 0) . #1#)
    (RETURN
     (PROGN
      (PROG (#2=#:G3690)
        (RETURN
         (SPADCALL |z1|
                   (PROG1 (LETT #2# (SPADCALL |part| (QREFELT $ 278)) NIL)
                     (|check-subtype| (>= #2# 0) '(|NonNegativeInteger|) #2#))
                   (QREFELT $ 303)))))))) 

(DEFUN |GUESS;ADEguessStream| (|f| |partitions| DS D1 $)
  (PROG ()
    (RETURN
     (SPADCALL (CONS #'|GUESS;ADEguessStream!0| (VECTOR $ D1 DS |f|))
               |partitions| (QREFELT $ 315))))) 

(DEFUN |GUESS;ADEguessStream!0| (|z1| $$)
  (PROG (|f| DS D1 $)
    (LETT |f| (QREFELT $$ 3) . #1=(|GUESS;ADEguessStream|))
    (LETT DS (QREFELT $$ 2) . #1#)
    (LETT D1 (QREFELT $$ 1) . #1#)
    (LETT $ (QREFELT $$ 0) . #1#)
    (RETURN (PROGN (|GUESS;termAsUFPSF| |f| |z1| DS D1 $))))) 

(DEFUN |GUESS;ADEguessStream2| (|f| |partitions| DS D1 $)
  (PROG ()
    (RETURN
     (SPADCALL (CONS #'|GUESS;ADEguessStream2!0| (VECTOR $ D1 DS |f|))
               |partitions| (QREFELT $ 315))))) 

(DEFUN |GUESS;ADEguessStream2!0| (|z1| $$)
  (PROG (|f| DS D1 $)
    (LETT |f| (QREFELT $$ 3) . #1=(|GUESS;ADEguessStream2|))
    (LETT DS (QREFELT $$ 2) . #1#)
    (LETT D1 (QREFELT $$ 1) . #1#)
    (LETT $ (QREFELT $$ 0) . #1#)
    (RETURN (PROGN (|GUESS;termAsUFPSF2| |f| |z1| DS D1 $))))) 

(DEFUN |GUESS;guessModGenCached|
       (|cache| |np| |sigma| |addOne| |maxD| |prodl| |terml| |prime| $)
  (PROG (|i| #1=#:G3725 |r| |res| #2=#:G3723 #3=#:G3724 |res1| #4=#:G3714 |nt|
         #5=#:G3721 #6=#:G3722 |pp|)
    (RETURN
     (SEQ
      (SEQ (LETT |pp| NIL . #7=(|GUESS;guessModGenCached|))
           (LETT #6# |prodl| . #7#) (LETT |i| (+ |maxD| 1) . #7#)
           (LETT #5# (+ |maxD| |np|) . #7#) G190
           (COND
            ((OR (> |i| #5#) (ATOM #6#)
                 (PROGN (LETT |pp| (CAR #6#) . #7#) NIL))
             #8=(GO G191)))
           (SEQ
            (EXIT
             (QSETAREF1 |cache| |i|
                        (SPADCALL (QAREF1 |cache| (|SPADfirst| |pp|))
                                  (QAREF1 |cache|
                                          (SPADCALL |pp| (QREFELT $ 278)))
                                  (- |sigma| 1) |prime| (QREFELT $ 286)))))
           (LETT |i| (PROG1 (+ |i| 1) (LETT #6# (CDR #6#) . #7#)) . #7#)
           #9=(GO G190) G191 (EXIT NIL))
      (LETT |nt| (LENGTH |terml|) . #7#)
      (COND
       (|addOne|
        (SEQ (LETT |res| (MAKEARR1 (+ |nt| 1) (GETREFV32 0 0)) . #7#)
             (LETT |res1|
                   (GETREFV32
                    (PROG1 (LETT #4# |sigma| . #7#)
                      (|check-subtype| (>= #4# 0) '(|NonNegativeInteger|) #4#))
                    0)
                   . #7#)
             (SETELT32 |res1| 0 1) (SPADCALL |res| 1 |res1| (QREFELT $ 327))
             (EXIT
              (SEQ (LETT |r| NIL . #7#) (LETT #3# |terml| . #7#)
                   (LETT |i| 2 . #7#) (LETT #2# (+ |nt| 1) . #7#) G190
                   (COND
                    ((OR (QSGREATERP |i| #2#) (ATOM #3#)
                         (PROGN (LETT |r| (CAR #3#) . #7#) NIL))
                     #8#))
                   (SEQ
                    (EXIT
                     (SPADCALL |res| |i| (QAREF1 |cache| |r|)
                               (QREFELT $ 327))))
                   (LETT |i| (PROG1 (QSADD1 |i|) (LETT #3# (CDR #3#) . #7#))
                         . #7#)
                   #9# G191 (EXIT NIL)))))
       ('T
        (SEQ (LETT |res| (MAKEARR1 |nt| (GETREFV32 0 0)) . #7#)
             (EXIT
              (SEQ (LETT |r| NIL . #7#) (LETT #1# |terml| . #7#)
                   (LETT |i| 1 . #7#) G190
                   (COND
                    ((OR (QSGREATERP |i| |nt|) (ATOM #1#)
                         (PROGN (LETT |r| (CAR #1#) . #7#) NIL))
                     #8#))
                   (SEQ
                    (EXIT
                     (SPADCALL |res| |i| (QAREF1 |cache| |r|)
                               (QREFELT $ 327))))
                   (LETT |i| (PROG1 (QSADD1 |i|) (LETT #1# (CDR #1#) . #7#))
                         . #7#)
                   #9# G191 (EXIT NIL))))))
      (EXIT |res|))))) 

(DEFUN |GUESS;DEPguessModGenCached|
       (|fl| |addOne| |maxD| |prodl| |terml| |prime| $)
  (PROG (|i| #1=#:G3730 |f| |cache| |np| |sigma|)
    (RETURN
     (SEQ
      (COND
       ((< (LENGTH |fl|) (+ |maxD| 1))
        (|error| "DEPguessModGenCached: #fl < maxD + 1"))
       ('T
        (SEQ (LETT |f| (|SPADfirst| |fl|) . #2=(|GUESS;DEPguessModGenCached|))
             (LETT |sigma| (QV32LEN |f|) . #2#)
             (LETT |np| (LENGTH |prodl|) . #2#)
             (LETT |cache| (MAKEARR1 (+ (+ |maxD| 1) |np|) (GETREFV32 0 0))
                   . #2#)
             (SEQ (LETT |f| NIL . #2#) (LETT #1# |fl| . #2#) (LETT |i| 0 . #2#)
                  G190
                  (COND
                   ((OR (QSGREATERP |i| |maxD|) (ATOM #1#)
                        (PROGN (LETT |f| (CAR #1#) . #2#) NIL))
                    (GO G191)))
                  (SEQ (EXIT (QSETAREF1 |cache| |i| |f|)))
                  (LETT |i| (PROG1 (QSADD1 |i|) (LETT #1# (CDR #1#) . #2#))
                        . #2#)
                  (GO G190) G191 (EXIT NIL))
             (EXIT
              (|GUESS;guessModGenCached| |cache| |np| |sigma| |addOne| |maxD|
               |prodl| |terml| |prime| $))))))))) 

(DEFUN |GUESS;ADEguessModGenCached|
       (|fl| |addOne| |maxD| |prodl| |terml| |prime| $)
  (PROG (|i| |cache| |np| |sigma| |f|)
    (RETURN
     (SEQ
      (COND
       ((NULL (EQL (LENGTH |fl|) 1))
        (|error| "ADEguessModGenCached: #fl ~= 1"))
       ('T
        (SEQ (LETT |f| (|SPADfirst| |fl|) . #1=(|GUESS;ADEguessModGenCached|))
             (LETT |sigma| (- (QV32LEN |f|) |maxD|) . #1#)
             (LETT |np| (LENGTH |prodl|) . #1#)
             (LETT |cache| (MAKEARR1 (+ (+ |maxD| 1) |np|) (GETREFV32 0 0))
                   . #1#)
             (QSETAREF1 |cache| 0 |f|)
             (SEQ (LETT |i| 1 . #1#) G190
                  (COND ((QSGREATERP |i| |maxD|) (GO G191)))
                  (SEQ
                   (EXIT
                    (QSETAREF1 |cache| |i|
                               (SPADCALL (QAREF1 |cache| (- |i| 1)) |prime|
                                         (QREFELT $ 328)))))
                  (LETT |i| (QSADD1 |i|) . #1#) (GO G190) G191 (EXIT NIL))
             (EXIT
              (|GUESS;guessModGenCached| |cache| |np| |sigma| |addOne| |maxD|
               |prodl| |terml| |prime| $))))))))) 

(DEFUN |GUESS;ADEtestGenCached| (|f| |addOne| |maxD| |prodl| |terml| DSF D1F $)
  (PROG (|i| #1=#:G3747 |r| |res| #2=#:G3745 #3=#:G3746 |nt| #4=#:G3743
         #5=#:G3744 |pp| |cache| |np|)
    (RETURN
     (SEQ (LETT |np| (LENGTH |prodl|) . #6=(|GUESS;ADEtestGenCached|))
          (LETT |cache| (MAKEARR1 (+ (+ |maxD| 1) |np|) (|spadConstant| $ 320))
                . #6#)
          (QSETAREF1 |cache| 0 |f|)
          (SEQ (LETT |i| 1 . #6#) G190
               (COND ((QSGREATERP |i| |maxD|) #7=(GO G191)))
               (SEQ
                (EXIT
                 (QSETAREF1 |cache| |i|
                            (SPADCALL (QAREF1 |cache| 0) |i| DSF))))
               (LETT |i| (QSADD1 |i|) . #6#) #8=(GO G190) G191 (EXIT NIL))
          (SEQ (LETT |pp| NIL . #6#) (LETT #5# |prodl| . #6#)
               (LETT |i| (+ |maxD| 1) . #6#) (LETT #4# (+ |maxD| |np|) . #6#)
               G190
               (COND
                ((OR (> |i| #4#) (ATOM #5#)
                     (PROGN (LETT |pp| (CAR #5#) . #6#) NIL))
                 #7#))
               (SEQ
                (EXIT
                 (QSETAREF1 |cache| |i|
                            (SPADCALL (QAREF1 |cache| (|SPADfirst| |pp|))
                                      (QAREF1 |cache|
                                              (SPADCALL |pp| (QREFELT $ 278)))
                                      (QREFELT $ 329)))))
               (LETT |i| (PROG1 (+ |i| 1) (LETT #5# (CDR #5#) . #6#)) . #6#)
               #8# G191 (EXIT NIL))
          (LETT |nt| (LENGTH |terml|) . #6#)
          (COND
           (|addOne|
            (SEQ
             (LETT |res| (MAKEARR1 (+ |nt| 1) (|spadConstant| $ 320)) . #6#)
             (SPADCALL |res| 1 D1F (QREFELT $ 334))
             (EXIT
              (SEQ (LETT |r| NIL . #6#) (LETT #3# |terml| . #6#)
                   (LETT |i| 2 . #6#) (LETT #2# (+ |nt| 1) . #6#) G190
                   (COND
                    ((OR (QSGREATERP |i| #2#) (ATOM #3#)
                         (PROGN (LETT |r| (CAR #3#) . #6#) NIL))
                     #7#))
                   (SEQ
                    (EXIT
                     (SPADCALL |res| |i| (QAREF1 |cache| |r|)
                               (QREFELT $ 334))))
                   (LETT |i| (PROG1 (QSADD1 |i|) (LETT #3# (CDR #3#) . #6#))
                         . #6#)
                   #8# G191 (EXIT NIL)))))
           ('T
            (SEQ (LETT |res| (MAKEARR1 |nt| (|spadConstant| $ 320)) . #6#)
                 (EXIT
                  (SEQ (LETT |r| NIL . #6#) (LETT #1# |terml| . #6#)
                       (LETT |i| 1 . #6#) G190
                       (COND
                        ((OR (QSGREATERP |i| |nt|) (ATOM #1#)
                             (PROGN (LETT |r| (CAR #1#) . #6#) NIL))
                         #7#))
                       (SEQ
                        (EXIT
                         (SPADCALL |res| |i| (QAREF1 |cache| |r|)
                                   (QREFELT $ 334))))
                       (LETT |i|
                             (PROG1 (QSADD1 |i|) (LETT #1# (CDR #1#) . #6#))
                             . #6#)
                       #8# G191 (EXIT NIL))))))
          (EXIT |res|))))) 

(DEFUN |GUESS;multiplyExponents| (|f| |n| $)
  (PROG (|i| |deg| |f0| |nn|)
    (RETURN
     (SEQ (LETT |nn| (QV32LEN |f|) . #1=(|GUESS;multiplyExponents|))
          (LETT |f0| (GETREFV32 |nn| 0) . #1#) (LETT |deg| (- |nn| 1) . #1#)
          (SEQ (LETT |i| 0 . #1#) G190
               (COND
                ((OR (QSGREATERP |i| |deg|)
                     (NULL (COND ((< |deg| (* |n| |i|)) 'NIL) ('T 'T))))
                 (GO G191)))
               (SEQ (EXIT (SETELT32 |f0| (* |n| |i|) (ELT32 |f| |i|))))
               (LETT |i| (QSADD1 |i|) . #1#) (GO G190) G191 (EXIT NIL))
          (EXIT |f0|))))) 

(DEFUN |GUESS;FEguessModGenCached|
       (|fl| |addOne| |maxD| |prodl| |terml| |prime| $)
  (PROG (|i| |cache| |np| |sigma| |f|)
    (RETURN
     (SEQ
      (COND
       ((NULL (EQL (LENGTH |fl|) 1)) (|error| "FEguessModGenCached: #fl ~= 1"))
       ('T
        (SEQ (LETT |f| (|SPADfirst| |fl|) . #1=(|GUESS;FEguessModGenCached|))
             (LETT |sigma| (QV32LEN |f|) . #1#)
             (LETT |np| (LENGTH |prodl|) . #1#)
             (LETT |cache| (MAKEARR1 (+ (+ |maxD| 1) |np|) (GETREFV32 0 0))
                   . #1#)
             (QSETAREF1 |cache| 0 |f|)
             (SEQ (LETT |i| 1 . #1#) G190
                  (COND ((QSGREATERP |i| |maxD|) (GO G191)))
                  (SEQ
                   (EXIT
                    (QSETAREF1 |cache| |i|
                               (|GUESS;multiplyExponents| (QAREF1 |cache| 0)
                                (+ |i| 1) $))))
                  (LETT |i| (QSADD1 |i|) . #1#) (GO G190) G191 (EXIT NIL))
             (EXIT
              (|GUESS;guessModGenCached| |cache| |np| |sigma| |addOne| |maxD|
               |prodl| |terml| |prime| $))))))))) 

(DEFUN |GUESS;optimiseFactor| (|partition| |partitions| $)
  (PROG (#1=#:G3773 |j| |r| #2=#:G3774 |p| |i| |n|)
    (RETURN
     (SEQ
      (EXIT
       (SEQ (LETT |n| (LENGTH |partitions|) . #3=(|GUESS;optimiseFactor|))
            (SEQ (LETT |i| 1 . #3#) (LETT |p| NIL . #3#)
                 (LETT #2# |partitions| . #3#) G190
                 (COND
                  ((OR (ATOM #2#) (PROGN (LETT |p| (CAR #2#) . #3#) NIL)
                       (QSGREATERP |i| |n|))
                   (GO G191)))
                 (SEQ
                  (LETT |r| (SPADCALL |partition| |p| (QREFELT $ 335)) . #3#)
                  (EXIT
                   (COND
                    ((QEQCAR |r| 0)
                     (SEQ
                      (LETT |j|
                            (SPADCALL (QCDR |r|) |partitions| (QREFELT $ 337))
                            . #3#)
                      (EXIT
                       (COND
                        ((< 0 |j|)
                         (PROGN
                          (LETT #1# (CONS 0 (LIST |i| |j|)) . #3#)
                          (GO #1#))))))))))
                 (LETT #2# (PROG1 (CDR #2#) (LETT |i| (QSADD1 |i|) . #3#))
                       . #3#)
                 (GO G190) G191 (EXIT NIL))
            (EXIT (CONS 1 "failed"))))
      #1# (EXIT #1#))))) 

(DEFUN |GUESS;optimiseProducts1| (|p| |prods0| |parts0| $)
  (PROG (|lp0| |r|)
    (RETURN
     (SEQ
      (SEQ
       (LETT |r|
             (|GUESS;optimiseFactor| |p| (SPADCALL |parts0| (QREFELT $ 339)) $)
             . #1=(|GUESS;optimiseProducts1|))
       (EXIT
        (COND
         ((QEQCAR |r| 1)
          (SEQ
           (|GUESS;optimiseProducts1|
            (SPADCALL (CDR (SPADCALL |p| (QREFELT $ 340))) (QREFELT $ 341))
            |prods0| |parts0| $)
           (EXIT
            (LETT |r|
                  (|GUESS;optimiseFactor| |p|
                   (SPADCALL |parts0| (QREFELT $ 339)) $)
                  . #1#)))))))
      (EXIT
       (COND
        ((QEQCAR |r| 1)
         (|error| "Internal error: failed adding intermediate partition"))
        ('T
         (SEQ (LETT |lp0| (LENGTH (SPADCALL |parts0| (QREFELT $ 339))) . #1#)
              (SPADCALL |prods0|
                        (CONS
                         (LIST (- |lp0| (|SPADfirst| (QCDR |r|)))
                               (- |lp0| (SPADCALL (QCDR |r|) (QREFELT $ 278))))
                         (SPADCALL |prods0| (QREFELT $ 343)))
                        (QREFELT $ 344))
              (EXIT
               (SPADCALL |parts0|
                         (CONS |p| (SPADCALL |parts0| (QREFELT $ 339)))
                         (QREFELT $ 345))))))))))) 

(DEFUN |GUESS;optimiseProducts| (|partitions| $)
  (PROG (#1=#:G3791 |terms0| #2=#:G3795 |p| |parts0| |i| #3=#:G3794 |prods0|
         |maxD0| #4=#:G3793 |addOne0|)
    (RETURN
     (SEQ
      (EXIT
       (SEQ
        (LETT |addOne0| (NULL (|SPADfirst| |partitions|))
              . #5=(|GUESS;optimiseProducts|))
        (COND
         (|addOne0|
          (SEQ (LETT |partitions| (CDR |partitions|) . #5#)
               (EXIT
                (COND
                 ((NULL |partitions|)
                  (PROGN
                   (LETT #4# (VECTOR |addOne0| 0 NIL NIL) . #5#)
                   (GO #4#))))))))
        (LETT |maxD0|
              (SPADCALL (ELT $ 346)
                        (SPADCALL (ELT $ 347) |partitions| (QREFELT $ 350))
                        (QREFELT $ 351))
              . #5#)
        (LETT |prods0| (SPADCALL NIL (QREFELT $ 352)) . #5#)
        (LETT |terms0| NIL . #5#)
        (LETT |parts0|
              (SPADCALL
               (PROGN
                (LETT #3# NIL . #5#)
                (SEQ (LETT |i| |maxD0| . #5#) G190
                     (COND ((< |i| 1) #6=(GO G191)))
                     (SEQ
                      (EXIT
                       (LETT #3#
                             (CONS (SPADCALL (LIST |i|) (QREFELT $ 341)) #3#)
                             . #5#)))
                     (LETT |i| (+ |i| -1) . #5#) #7=(GO G190) G191
                     (EXIT (NREVERSE0 #3#))))
               (QREFELT $ 353))
              . #5#)
        (SEQ (LETT |p| NIL . #5#) (LETT #2# |partitions| . #5#) G190
             (COND
              ((OR (ATOM #2#) (PROGN (LETT |p| (CAR #2#) . #5#) NIL)) #6#))
             (SEQ
              (EXIT
               (COND
                ((EQL (LENGTH |p|) 1)
                 (LETT |terms0| (CONS (- (|SPADfirst| |p|) 1) |terms0|) . #5#))
                ('T
                 (SEQ
                  (|GUESS;optimiseProducts1| (SPADCALL |p| (QREFELT $ 341))
                   |prods0| |parts0| $)
                  (EXIT
                   (LETT |terms0|
                         (CONS
                          (- (LENGTH (SPADCALL |parts0| (QREFELT $ 339))) 1)
                          |terms0|)
                         . #5#)))))))
             (LETT #2# (CDR #2#) . #5#) #7# G191 (EXIT NIL))
        (EXIT
         (VECTOR |addOne0|
                 (PROG1 (LETT #1# (- |maxD0| 1) . #5#)
                   (|check-subtype| (>= #1# 0) '(|NonNegativeInteger|) #1#))
                 (NREVERSE (SPADCALL |prods0| (QREFELT $ 343)))
                 (NREVERSE |terms0|)))))
      #4# (EXIT #4#))))) 

(DEFUN |GUESS;ADEguessModOptimisedGen| (|partitions| $)
  (PROG (|r|)
    (RETURN
     (SEQ
      (LETT |r| (|GUESS;optimiseProducts| |partitions| $)
            |GUESS;ADEguessModOptimisedGen|)
      (EXIT (CONS #'|GUESS;ADEguessModOptimisedGen!0| (VECTOR $ |r|))))))) 

(DEFUN |GUESS;ADEguessModOptimisedGen!0| (|fl| |prime| |q| $$)
  (PROG (|r| $)
    (LETT |r| (QREFELT $$ 1) . #1=(|GUESS;ADEguessModOptimisedGen|))
    (LETT $ (QREFELT $$ 0) . #1#)
    (RETURN
     (PROGN
      (|GUESS;ADEguessModGenCached| |fl| (QVELT |r| 0) (QVELT |r| 1)
       (QVELT |r| 2) (QVELT |r| 3) |prime| $))))) 

(DEFUN |GUESS;FEguessModOptimisedGen| (|partitions| $)
  (PROG (|r|)
    (RETURN
     (SEQ
      (LETT |r| (|GUESS;optimiseProducts| |partitions| $)
            |GUESS;FEguessModOptimisedGen|)
      (EXIT (CONS #'|GUESS;FEguessModOptimisedGen!0| (VECTOR $ |r|))))))) 

(DEFUN |GUESS;FEguessModOptimisedGen!0| (|fl| |prime| |q| $$)
  (PROG (|r| $)
    (LETT |r| (QREFELT $$ 1) . #1=(|GUESS;FEguessModOptimisedGen|))
    (LETT $ (QREFELT $$ 0) . #1#)
    (RETURN
     (PROGN
      (|GUESS;FEguessModGenCached| |fl| (QVELT |r| 0) (QVELT |r| 1)
       (QVELT |r| 2) (QVELT |r| 3) |prime| $))))) 

(DEFUN |GUESS;DEPguessModOptimisedGen| (|partitions| $)
  (PROG (|r|)
    (RETURN
     (SEQ
      (LETT |r| (|GUESS;optimiseProducts| |partitions| $)
            |GUESS;DEPguessModOptimisedGen|)
      (EXIT (CONS #'|GUESS;DEPguessModOptimisedGen!0| (VECTOR $ |r|))))))) 

(DEFUN |GUESS;DEPguessModOptimisedGen!0| (|fl| |prime| |q| $$)
  (PROG (|r| $)
    (LETT |r| (QREFELT $$ 1) . #1=(|GUESS;DEPguessModOptimisedGen|))
    (LETT $ (QREFELT $$ 0) . #1#)
    (RETURN
     (PROGN
      (|GUESS;DEPguessModGenCached| |fl| (QVELT |r| 0) (QVELT |r| 1)
       (QVELT |r| 2) (QVELT |r| 3) |prime| $))))) 

(DEFUN |GUESS;ADEguessModGen2| (|partitions| |d| $)
  (PROG ()
    (RETURN
     (SEQ (CONS #'|GUESS;ADEguessModGen2!0| (VECTOR |d| |partitions| $)))))) 

(DEFUN |GUESS;ADEguessModGen2!0| (|fl| |prime| |q| $$)
  (PROG ($ |partitions| |d|)
    (LETT $ (QREFELT $$ 2) . #1=(|GUESS;ADEguessModGen2|))
    (LETT |partitions| (QREFELT $$ 1) . #1#)
    (LETT |d| (QREFELT $$ 0) . #1#)
    (RETURN
     (PROGN
      (PROG (#2=#:G3819 |p| #3=#:G3818 |f|)
        (RETURN
         (SEQ
          (COND
           ((NULL
             (SPADCALL (SPADCALL |fl| (QREFELT $ 354)) (|spadConstant| $ 355)
                       (QREFELT $ 269)))
            (|error| "ADEguessModGen2, lambda: #fl ~= 1"))
           ('T
            (SEQ (LETT |f| (SPADCALL |fl| (QREFELT $ 356)) NIL)
                 (EXIT
                  (SPADCALL
                   (PROGN
                    (LETT #3# NIL NIL)
                    (SEQ (LETT |p| NIL NIL) (LETT #2# |partitions| NIL) G190
                         (COND
                          ((OR (ATOM #2#) (PROGN (LETT |p| (CAR #2#) NIL) NIL))
                           (GO G191)))
                         (SEQ
                          (EXIT
                           (LETT #3#
                                 (CONS
                                  (|GUESS;termAsU32VectorShift| |f| |p| |prime|
                                   |d| $)
                                  #3#)
                                 NIL)))
                         (LETT #2# (CDR #2#) NIL) (GO G190) G191
                         (EXIT (NREVERSE0 #3#))))
                   (QREFELT $ 357))))))))))))) 

(DEFUN |GUESS;ADEtestOptimisedGen| (|partitions| DSF D1F $)
  (PROG (|r|)
    (RETURN
     (SEQ
      (LETT |r| (|GUESS;optimiseProducts| |partitions| $)
            |GUESS;ADEtestOptimisedGen|)
      (EXIT (CONS #'|GUESS;ADEtestOptimisedGen!0| (VECTOR $ D1F DSF |r|))))))) 

(DEFUN |GUESS;ADEtestOptimisedGen!0| (|f| $$)
  (PROG (|r| DSF D1F $)
    (LETT |r| (QREFELT $$ 3) . #1=(|GUESS;ADEtestOptimisedGen|))
    (LETT DSF (QREFELT $$ 2) . #1#)
    (LETT D1F (QREFELT $$ 1) . #1#)
    (LETT $ (QREFELT $$ 0) . #1#)
    (RETURN
     (PROGN
      (|GUESS;ADEtestGenCached| |f| (QVELT |r| 0) (QVELT |r| 1) (QVELT |r| 2)
       (QVELT |r| 3) DSF D1F $))))) 

(DEFUN |GUESS;ADEtestGen2| (|partitions| DSF D1F $)
  (PROG ()
    (RETURN
     (SEQ (CONS #'|GUESS;ADEtestGen2!0| (VECTOR $ D1F DSF |partitions|)))))) 

(DEFUN |GUESS;ADEtestGen2!0| (|f| $$)
  (PROG (|partitions| DSF D1F $)
    (LETT |partitions| (QREFELT $$ 3) . #1=(|GUESS;ADEtestGen2|))
    (LETT DSF (QREFELT $$ 2) . #1#)
    (LETT D1F (QREFELT $$ 1) . #1#)
    (LETT $ (QREFELT $$ 0) . #1#)
    (RETURN
     (PROGN
      (PROG (#2=#:G3832 |p| #3=#:G3831)
        (RETURN
         (SEQ
          (SPADCALL
           (PROGN
            (LETT #3# NIL NIL)
            (SEQ (LETT |p| NIL NIL) (LETT #2# |partitions| NIL) G190
                 (COND
                  ((OR (ATOM #2#) (PROGN (LETT |p| (CAR #2#) NIL) NIL))
                   (GO G191)))
                 (SEQ
                  (EXIT
                   (LETT #3#
                         (CONS (|GUESS;termAsUFPSSUPF2| |f| |p| DSF D1F $) #3#)
                         NIL)))
                 (LETT #2# (CDR #2#) NIL) (GO G190) G191
                 (EXIT (NREVERSE0 #3#))))
           (QREFELT $ 358))))))))) 

(DEFUN |GUESS;ADEEXPRRStream| (|f| |xx| |partitions| DX D1X $)
  (PROG ()
    (RETURN
     (SPADCALL (CONS #'|GUESS;ADEEXPRRStream!0| (VECTOR $ D1X DX |xx| |f|))
               |partitions| (QREFELT $ 362))))) 

(DEFUN |GUESS;ADEEXPRRStream!0| (|z1| $$)
  (PROG (|f| |xx| DX D1X $)
    (LETT |f| (QREFELT $$ 4) . #1=(|GUESS;ADEEXPRRStream|))
    (LETT |xx| (QREFELT $$ 3) . #1#)
    (LETT DX (QREFELT $$ 2) . #1#)
    (LETT D1X (QREFELT $$ 1) . #1#)
    (LETT $ (QREFELT $$ 0) . #1#)
    (RETURN (PROGN (|GUESS;termAsEXPRR| |f| |xx| |z1| DX D1X $))))) 

(DEFUN |GUESS;ADEdegreeStream| (|partitions| $)
  (PROG ()
    (RETURN
     (SPADCALL 0 (CONS #'|GUESS;ADEdegreeStream!0| $) |partitions|
               (QREFELT $ 368))))) 

(DEFUN |GUESS;ADEdegreeStream!0| (|z1| |z2| $)
  (PROG (#1=#:G3841)
    (RETURN
     (SPADCALL
      (COND ((SPADCALL |z1| (QREFELT $ 363)) (|spadConstant| $ 273))
            ('T
             (PROG1
                 (LETT #1#
                       (SPADCALL (SPADCALL |z1| (QREFELT $ 347))
                                 (|spadConstant| $ 355) (QREFELT $ 217))
                       NIL)
               (|check-subtype| (>= #1# 0) '(|NonNegativeInteger|) #1#))))
      |z2| (QREFELT $ 364))))) 

(DEFUN |GUESS;diffDX| (|expr| |x| |n| $)
  (SPADCALL |expr| |x| |n| (QREFELT $ 369))) 

(DEFUN |GUESS;diffDS| (|s| |n| $) (SPADCALL |s| |n| (QREFELT $ 370))) 

(DEFUN |GUESS;diffDSF| (|s| |n| $)
  (COND
   ((|HasSignature|
     (|SparseMultivariatePolynomial| (QREFELT $ 6) (|NonNegativeInteger|))
     (LIST '*
           (LIST
            (LIST '|SparseMultivariatePolynomial| (|devaluate| (QREFELT $ 6))
                  '(|NonNegativeInteger|))
            '(|NonNegativeInteger|)
            (LIST '|SparseMultivariatePolynomial| (|devaluate| (QREFELT $ 6))
                  '(|NonNegativeInteger|)))))
    (SPADCALL |s| |n| (QREFELT $ 371))))) 

(DEFUN |GUESS;diffAX| (|l| |x| |f| $)
  (SPADCALL (SPADCALL (SPADCALL |x| (QREFELT $ 39)) |l| (QREFELT $ 126)) |f|
            (QREFELT $ 104))) 

(DEFUN |GUESS;diffA| (|k| |l| |f| $) (SPADCALL |k| |l| |f| (QREFELT $ 373))) 

(DEFUN |GUESS;diffAF| (|k| |l| |f| $) (SPADCALL |k| |l| |f| (QREFELT $ 375))) 

(DEFUN |GUESS;diffC| (|total| $) (SPADCALL |total| (QREFELT $ 376))) 

(DEFUN |GUESS;diff1X| (|x| $) (|spadConstant| $ 93)) 

(DEFUN |GUESS;diffHP;LR;74| (|options| $)
  (PROG (|degrees| |partitions| |dk|)
    (RETURN
     (SEQ
      (COND
       ((NULL (ZEROP (SPADCALL |options| (QREFELT $ 377))))
        (|error|
         "Guess: no support for mixed shifts in differential equations")))
      (LETT |dk| (SPADCALL |options| (QREFELT $ 378))
            . #1=(|GUESS;diffHP;LR;74|))
      (EXIT
       (COND
        ((EQUAL |dk| '|displayAsGF|)
         (SEQ
          (LETT |partitions| (|GUESS;FilteredPartitionStream| |options| $)
                . #1#)
          (LETT |degrees| (|GUESS;ADEdegreeStream| |partitions| $) . #1#)
          (EXIT
           (VECTOR |degrees|
                   (CONS #'|GUESS;diffHP;LR;74!0| (VECTOR $ |partitions|))
                   (CONS #'|GUESS;diffHP;LR;74!1| (VECTOR $ |partitions|))
                   (CONS #'|GUESS;diffHP;LR;74!2| (VECTOR $ |partitions|))
                   (CONS #'|GUESS;diffHP;LR;74!3| (VECTOR $ |partitions|))
                   '|diffHP| '|dummy| (CONS (|function| |GUESS;diffA|) $)
                   (CONS (|function| |GUESS;diffAF|) $)
                   (CONS (|function| |GUESS;diffAX|) $)
                   (CONS (|function| |GUESS;diffC|) $)))))
        ('T (|error| "Guess: guessADE supports only displayAsGF")))))))) 

(DEFUN |GUESS;diffHP;LR;74!3| (|z1| |z2| $$)
  (PROG (|partitions| $)
    (LETT |partitions| (QREFELT $$ 1) . #1=(|GUESS;diffHP;LR;74|))
    (LETT $ (QREFELT $$ 0) . #1#)
    (RETURN
     (PROGN
      (|GUESS;ADEEXPRRStream| |z1| |z2| |partitions|
       (CONS (|function| |GUESS;diffDX|) $)
       (CONS (|function| |GUESS;diff1X|) $) $))))) 

(DEFUN |GUESS;diffHP;LR;74!2| (|l| $$)
  (PROG (|partitions| $)
    (LETT |partitions| (QREFELT $$ 1) . #1=(|GUESS;diffHP;LR;74|))
    (LETT $ (QREFELT $$ 0) . #1#)
    (RETURN
     (PROGN
      (PROG (#2=#:G3869 |i| #3=#:G3868)
        (RETURN
         (SEQ
          (|GUESS;ADEtestOptimisedGen|
           (PROGN
            (LETT #3# NIL NIL)
            (SEQ (LETT |i| NIL NIL) (LETT #2# |l| NIL) G190
                 (COND
                  ((OR (ATOM #2#) (PROGN (LETT |i| (CAR #2#) NIL) NIL))
                   (GO G191)))
                 (SEQ
                  (EXIT
                   (LETT #3#
                         (CONS (SPADCALL |partitions| |i| (QREFELT $ 382)) #3#)
                         NIL)))
                 (LETT #2# (CDR #2#) NIL) (GO G190) G191
                 (EXIT (NREVERSE0 #3#))))
           (CONS (|function| |GUESS;diffDSF|) $) (|spadConstant| $ 325)
           $)))))))) 

(DEFUN |GUESS;diffHP;LR;74!1| (|o| $$)
  (PROG (|partitions| $)
    (LETT |partitions| (QREFELT $$ 1) . #1=(|GUESS;diffHP;LR;74|))
    (LETT $ (QREFELT $$ 0) . #1#)
    (RETURN
     (PROGN
      (|GUESS;ADEguessModOptimisedGen|
       (SPADCALL
        (SPADCALL (SPADCALL |partitions| |o| (QREFELT $ 379)) (QREFELT $ 380))
        (QREFELT $ 381))
       $))))) 

(DEFUN |GUESS;diffHP;LR;74!0| (|z1| $$)
  (PROG (|partitions| $)
    (LETT |partitions| (QREFELT $$ 1) . #1=(|GUESS;diffHP;LR;74|))
    (LETT $ (QREFELT $$ 0) . #1#)
    (RETURN
     (PROGN
      (|GUESS;ADEguessStream| |z1| |partitions|
       (CONS (|function| |GUESS;diffDS|) $) (|spadConstant| $ 324) $))))) 

(DEFUN |GUESS;monomialAsEXPRR| (|fl0| |partition| $)
  (PROG (|fl| #1=#:G3905 #2=#:G3904 #3=#:G3913 |part| #4=#:G3912 |ll|)
    (RETURN
     (SEQ
      (COND ((NULL |partition|) (|spadConstant| $ 93))
            ('T
             (SEQ
              (LETT |ll| (SPADCALL |partition| (QREFELT $ 277))
                    . #5=(|GUESS;monomialAsEXPRR|))
              (LETT |fl|
                    (PROGN
                     (LETT #4# NIL . #5#)
                     (SEQ (LETT |part| NIL . #5#) (LETT #3# |ll| . #5#) G190
                          (COND
                           ((OR (ATOM #3#)
                                (PROGN (LETT |part| (CAR #3#) . #5#) NIL))
                            (GO G191)))
                          (SEQ
                           (EXIT
                            (LETT #4#
                                  (CONS
                                   (SPADCALL
                                    (SPADCALL |fl0|
                                              (PROG1
                                                  (LETT #2#
                                                        (|SPADfirst| |part|)
                                                        . #5#)
                                                (|check-subtype| (> #2# 0)
                                                                 '(|PositiveInteger|)
                                                                 #2#))
                                              (QREFELT $ 395))
                                    (PROG1
                                        (LETT #1#
                                              (SPADCALL |part| (QREFELT $ 278))
                                              . #5#)
                                      (|check-subtype| (>= #1# 0)
                                                       '(|NonNegativeInteger|)
                                                       #1#))
                                    (QREFELT $ 126))
                                   #4#)
                                  . #5#)))
                          (LETT #3# (CDR #3#) . #5#) (GO G190) G191
                          (EXIT (NREVERSE0 #4#))))
                    . #5#)
              (EXIT (SPADCALL (ELT $ 104) |fl| (QREFELT $ 280)))))))))) 

(DEFUN |GUESS;DEPEXPRRStream| (|fl| |partitions| $)
  (PROG ()
    (RETURN
     (SPADCALL (CONS #'|GUESS;DEPEXPRRStream!0| (VECTOR $ |fl|)) |partitions|
               (QREFELT $ 362))))) 

(DEFUN |GUESS;DEPEXPRRStream!0| (|z1| $$)
  (PROG (|fl| $)
    (LETT |fl| (QREFELT $$ 1) . #1=(|GUESS;DEPEXPRRStream|))
    (LETT $ (QREFELT $$ 0) . #1#)
    (RETURN (PROGN (|GUESS;monomialAsEXPRR| |fl| |z1| $))))) 

(DEFUN |GUESS;getfnames| (|n| |options| $)
  (PROG (#1=#:G3926 |sym| #2=#:G3925 |syms| #3=#:G3924 |i| #4=#:G3923 |snums|
         |q| #5=#:G3922 |n1|)
    (RETURN
     (SEQ
      (LETT |syms| (SPADCALL |options| (QREFELT $ 396))
            . #6=(|GUESS;getfnames|))
      (LETT |n1| (LENGTH |syms|) . #6#)
      (COND
       ((< 0 |n1|)
        (COND
         ((NULL (EQL |n1| |n|))
          (EXIT (|error| "numbers of sequences and names are different"))))))
      (COND
       ((EQL |n1| 0)
        (SEQ
         (LETT |snums|
               (PROGN
                (LETT #5# NIL . #6#)
                (SEQ (LETT |q| 1 . #6#) G190
                     (COND ((QSGREATERP |q| |n|) #7=(GO G191)))
                     (SEQ (EXIT (LETT #5# (CONS (STRINGIMAGE |q|) #5#) . #6#)))
                     (LETT |q| (QSADD1 |q|) . #6#) #8=(GO G190) G191
                     (EXIT (NREVERSE0 #5#))))
               . #6#)
         (EXIT
          (LETT |syms|
                (PROGN
                 (LETT #4# NIL . #6#)
                 (SEQ (LETT |i| NIL . #6#) (LETT #3# |snums| . #6#) G190
                      (COND
                       ((OR (ATOM #3#) (PROGN (LETT |i| (CAR #3#) . #6#) NIL))
                        #7#))
                      (SEQ
                       (EXIT
                        (LETT #4#
                              (CONS
                               (SPADCALL (STRCONC "%" (STRCONC "f" |i|))
                                         (QREFELT $ 397))
                               #4#)
                              . #6#)))
                      (LETT #3# (CDR #3#) . #6#) #8# G191
                      (EXIT (NREVERSE0 #4#))))
                . #6#)))))
      (EXIT
       (PROGN
        (LETT #2# NIL . #6#)
        (SEQ (LETT |sym| NIL . #6#) (LETT #1# |syms| . #6#) G190
             (COND
              ((OR (ATOM #1#) (PROGN (LETT |sym| (CAR #1#) . #6#) NIL)) #7#))
             (SEQ
              (EXIT
               (LETT #2# (CONS (SPADCALL |sym| (QREFELT $ 39)) #2#) . #6#)))
             (LETT #1# (CDR #1#) . #6#) #8# G191 (EXIT (NREVERSE0 #2#))))))))) 

(DEFUN |GUESS;algDepHP;LLR;78| (|lists| |options| $)
  (PROG (|fakeDSF| |fakeDS| |fl| |degrees| |partitions| |dk|)
    (RETURN
     (SEQ
      (COND
       ((NULL (ZEROP (SPADCALL |options| (QREFELT $ 377))))
        (|error|
         "Guess: no support for mixed shifts in algebraic dependencies")))
      (LETT |dk| (SPADCALL |options| (QREFELT $ 378))
            . #1=(|GUESS;algDepHP;LLR;78|))
      (COND
       ((NULL (EQUAL |dk| '|displayAsEQ|))
        (EXIT (|error| "Guess: guessAlgDep supports only displayAsEQ"))))
      (LETT |partitions| (|GUESS;FilteredPartitionStream| |options| $) . #1#)
      (LETT |degrees| (|GUESS;ADEdegreeStream| |partitions| $) . #1#)
      (LETT |fl| (|GUESS;getfnames| (LENGTH |lists|) |options| $) . #1#)
      (LETT |fakeDS| (CONS #'|GUESS;algDepHP;LLR;78!0| (VECTOR $ |lists|))
            . #1#)
      (LETT |fakeDSF| (CONS #'|GUESS;algDepHP;LLR;78!1| (VECTOR $ |lists|))
            . #1#)
      (EXIT
       (VECTOR
        (SPADCALL (CONS #'|GUESS;algDepHP;LLR;78!2| $) |partitions|
                  (QREFELT $ 401))
        (CONS #'|GUESS;algDepHP;LLR;78!3| (VECTOR $ |fakeDS| |partitions|))
        (CONS #'|GUESS;algDepHP;LLR;78!4| (VECTOR $ |partitions|))
        (CONS #'|GUESS;algDepHP;LLR;78!5| (VECTOR |fakeDSF| $ |partitions|))
        (CONS #'|GUESS;algDepHP;LLR;78!6| (VECTOR $ |partitions| |fl|))
        '|diffHP| '|dummy| (CONS (|function| |GUESS;diffA|) $)
        (CONS (|function| |GUESS;diffAF|) $)
        (CONS (|function| |GUESS;diffAX|) $)
        (CONS (|function| |GUESS;diffC|) $))))))) 

(DEFUN |GUESS;algDepHP;LLR;78!6| (|z1| |z2| $$)
  (PROG (|fl| |partitions| $)
    (LETT |fl| (QREFELT $$ 2) . #1=(|GUESS;algDepHP;LLR;78|))
    (LETT |partitions| (QREFELT $$ 1) . #1#)
    (LETT $ (QREFELT $$ 0) . #1#)
    (RETURN (PROGN (|GUESS;DEPEXPRRStream| |fl| |partitions| $))))) 

(DEFUN |GUESS;algDepHP;LLR;78!5| (|l| $$)
  (PROG (|partitions| $ |fakeDSF|)
    (LETT |partitions| (QREFELT $$ 2) . #1=(|GUESS;algDepHP;LLR;78|))
    (LETT $ (QREFELT $$ 1) . #1#)
    (LETT |fakeDSF| (QREFELT $$ 0) . #1#)
    (RETURN
     (PROGN
      (PROG (#2=#:G3947 |i| #3=#:G3946)
        (RETURN
         (SEQ
          (|GUESS;ADEtestOptimisedGen|
           (PROGN
            (LETT #3# NIL NIL)
            (SEQ (LETT |i| NIL NIL) (LETT #2# |l| NIL) G190
                 (COND
                  ((OR (ATOM #2#) (PROGN (LETT |i| (CAR #2#) NIL) NIL))
                   (GO G191)))
                 (SEQ
                  (EXIT
                   (LETT #3#
                         (CONS (SPADCALL |partitions| |i| (QREFELT $ 382)) #3#)
                         NIL)))
                 (LETT #2# (CDR #2#) NIL) (GO G190) G191
                 (EXIT (NREVERSE0 #3#))))
           |fakeDSF| (|spadConstant| $ 325) $)))))))) 

(DEFUN |GUESS;algDepHP;LLR;78!4| (|o| $$)
  (PROG (|partitions| $)
    (LETT |partitions| (QREFELT $$ 1) . #1=(|GUESS;algDepHP;LLR;78|))
    (LETT $ (QREFELT $$ 0) . #1#)
    (RETURN
     (PROGN
      (|GUESS;DEPguessModOptimisedGen|
       (SPADCALL
        (SPADCALL (SPADCALL |partitions| |o| (QREFELT $ 379)) (QREFELT $ 380))
        (QREFELT $ 381))
       $))))) 

(DEFUN |GUESS;algDepHP;LLR;78!3| (|z1| $$)
  (PROG (|partitions| |fakeDS| $)
    (LETT |partitions| (QREFELT $$ 2) . #1=(|GUESS;algDepHP;LLR;78|))
    (LETT |fakeDS| (QREFELT $$ 1) . #1#)
    (LETT $ (QREFELT $$ 0) . #1#)
    (RETURN
     (PROGN
      (|GUESS;ADEguessStream| |z1| |partitions| |fakeDS| (|spadConstant| $ 324)
       $))))) 

(DEFUN |GUESS;algDepHP;LLR;78!2| (|c| $) (|spadConstant| $ 273)) 

(DEFUN |GUESS;algDepHP;LLR;78!1| (|w1| |w2| $$)
  (PROG (|lists| $)
    (LETT |lists| (QREFELT $$ 1) . #1=(|GUESS;algDepHP;LLR;78|))
    (LETT $ (QREFELT $$ 0) . #1#)
    (RETURN
     (PROGN
      (|GUESS;list2UFPSSUPF|
       (SPADCALL |lists| (SPADCALL |w2| (|spadConstant| $ 355) (QREFELT $ 257))
                 (QREFELT $ 399))
       $))))) 

(DEFUN |GUESS;algDepHP;LLR;78!0| (|w1| |w2| $$)
  (PROG (|lists| $)
    (LETT |lists| (QREFELT $$ 1) . #1=(|GUESS;algDepHP;LLR;78|))
    (LETT $ (QREFELT $$ 0) . #1#)
    (RETURN
     (PROGN
      (|GUESS;list2UFPSF|
       (SPADCALL |lists| (SPADCALL |w2| (|spadConstant| $ 355) (QREFELT $ 257))
                 (QREFELT $ 399))
       $))))) 

(DEFUN |GUESS;substDX| (|expr| |x| |n| $)
  (SPADCALL |expr| (SPADCALL |x| (QREFELT $ 39))
            (SPADCALL (SPADCALL |x| (QREFELT $ 39)) (+ |n| 1) (QREFELT $ 126))
            (QREFELT $ 46))) 

(DEFUN |GUESS;substDS| (|s| |n| $)
  (PROG (#1=#:G3962)
    (RETURN
     (SPADCALL |s|
               (PROG1 (LETT #1# (+ |n| 1) |GUESS;substDS|)
                 (|check-subtype| (> #1# 0) '(|PositiveInteger|) #1#))
               (QREFELT $ 403))))) 

(DEFUN |GUESS;substDSF| (|s| |n| $)
  (PROG (#1=#:G3964)
    (RETURN
     (SPADCALL |s|
               (PROG1 (LETT #1# (+ |n| 1) |GUESS;substDSF|)
                 (|check-subtype| (> #1# 0) '(|PositiveInteger|) #1#))
               (QREFELT $ 404))))) 

(DEFUN |GUESS;substHP;LR;82| (|options| $)
  (PROG (|partitions| |dk|)
    (RETURN
     (SEQ
      (COND
       ((NULL (ZEROP (SPADCALL |options| (QREFELT $ 377))))
        (|error|
         "Guess: no support for mixed shifts in functional equations")))
      (LETT |dk| (SPADCALL |options| (QREFELT $ 378))
            . #1=(|GUESS;substHP;LR;82|))
      (EXIT
       (COND
        ((EQUAL |dk| '|displayAsGF|)
         (SEQ
          (LETT |partitions| (|GUESS;FilteredPartitionStream| |options| $)
                . #1#)
          (EXIT
           (VECTOR
            (SPADCALL (CONS #'|GUESS;substHP;LR;82!0| $) |partitions|
                      (QREFELT $ 401))
            (CONS #'|GUESS;substHP;LR;82!1| (VECTOR $ |partitions|))
            (CONS #'|GUESS;substHP;LR;82!2| (VECTOR $ |partitions|))
            (CONS #'|GUESS;substHP;LR;82!3| (VECTOR $ |partitions|))
            (CONS #'|GUESS;substHP;LR;82!4| (VECTOR $ |partitions|)) '|diffHP|
            '|dummy| (CONS (|function| |GUESS;diffA|) $)
            (CONS (|function| |GUESS;diffAF|) $)
            (CONS (|function| |GUESS;diffAX|) $)
            (CONS (|function| |GUESS;diffC|) $)))))
        ('T (|error| "Guess: guessSubst supports only displayAsGF")))))))) 

(DEFUN |GUESS;substHP;LR;82!4| (|z1| |z2| $$)
  (PROG (|partitions| $)
    (LETT |partitions| (QREFELT $$ 1) . #1=(|GUESS;substHP;LR;82|))
    (LETT $ (QREFELT $$ 0) . #1#)
    (RETURN
     (PROGN
      (|GUESS;ADEEXPRRStream| |z1| |z2| |partitions|
       (CONS (|function| |GUESS;substDX|) $)
       (CONS (|function| |GUESS;diff1X|) $) $))))) 

(DEFUN |GUESS;substHP;LR;82!3| (|l| $$)
  (PROG (|partitions| $)
    (LETT |partitions| (QREFELT $$ 1) . #1=(|GUESS;substHP;LR;82|))
    (LETT $ (QREFELT $$ 0) . #1#)
    (RETURN
     (PROGN
      (PROG (#2=#:G3982 |i| #3=#:G3981)
        (RETURN
         (SEQ
          (|GUESS;ADEtestOptimisedGen|
           (PROGN
            (LETT #3# NIL NIL)
            (SEQ (LETT |i| NIL NIL) (LETT #2# |l| NIL) G190
                 (COND
                  ((OR (ATOM #2#) (PROGN (LETT |i| (CAR #2#) NIL) NIL))
                   (GO G191)))
                 (SEQ
                  (EXIT
                   (LETT #3#
                         (CONS (SPADCALL |partitions| |i| (QREFELT $ 382)) #3#)
                         NIL)))
                 (LETT #2# (CDR #2#) NIL) (GO G190) G191
                 (EXIT (NREVERSE0 #3#))))
           (CONS (|function| |GUESS;substDSF|) $) (|spadConstant| $ 325)
           $)))))))) 

(DEFUN |GUESS;substHP;LR;82!2| (|o| $$)
  (PROG (|partitions| $)
    (LETT |partitions| (QREFELT $$ 1) . #1=(|GUESS;substHP;LR;82|))
    (LETT $ (QREFELT $$ 0) . #1#)
    (RETURN
     (PROGN
      (|GUESS;FEguessModOptimisedGen|
       (SPADCALL
        (SPADCALL (SPADCALL |partitions| |o| (QREFELT $ 379)) (QREFELT $ 380))
        (QREFELT $ 381))
       $))))) 

(DEFUN |GUESS;substHP;LR;82!1| (|z1| $$)
  (PROG (|partitions| $)
    (LETT |partitions| (QREFELT $$ 1) . #1=(|GUESS;substHP;LR;82|))
    (LETT $ (QREFELT $$ 0) . #1#)
    (RETURN
     (PROGN
      (|GUESS;ADEguessStream| |z1| |partitions|
       (CONS (|function| |GUESS;substDS|) $) (|spadConstant| $ 324) $))))) 

(DEFUN |GUESS;substHP;LR;82!0| (|c| $) (|spadConstant| $ 273)) 

(DEFUN |GUESS;qDiffDX| (|q| |expr| |x| |n| $)
  (SPADCALL |expr| (SPADCALL |x| (QREFELT $ 39))
            (SPADCALL
             (SPADCALL (SPADCALL |q| (QREFELT $ 39)) |n| (QREFELT $ 126))
             (SPADCALL |x| (QREFELT $ 39)) (QREFELT $ 104))
            (QREFELT $ 46))) 

(DEFUN |GUESS;qDiffDS| (|q| |s| |n| $)
  (PROG ()
    (RETURN
     (SPADCALL (CONS #'|GUESS;qDiffDS!0| (VECTOR |n| $ |q|)) |s|
               (QREFELT $ 408))))) 

(DEFUN |GUESS;qDiffDS!0| (|z1| $$)
  (PROG (|q| $ |n|)
    (LETT |q| (QREFELT $$ 2) . #1=(|GUESS;qDiffDS|))
    (LETT $ (QREFELT $$ 1) . #1#)
    (LETT |n| (QREFELT $$ 0) . #1#)
    (RETURN
     (PROGN
      (PROG (#2=#:G4003)
        (RETURN
         (SPADCALL (SPADCALL |q| (QREFELT $ 240))
                   (PROG1 (LETT #2# (SPADCALL |n| |z1| (QREFELT $ 406)) NIL)
                     (|check-subtype| (>= #2# 0) '(|NonNegativeInteger|) #2#))
                   (QREFELT $ 297)))))))) 

(DEFUN |GUESS;qDiffDSV| (|f| |n| |prime| |q| $)
  (PROG (Q |i| |qn| |r| #1=#:G4008 |d|)
    (RETURN
     (SEQ
      (COND ((ZEROP |n|) |f|)
            ('T
             (SEQ (LETT |d| (- (QV32LEN |f|) 1) . #2=(|GUESS;qDiffDSV|))
                  (LETT |r|
                        (GETREFV32
                         (+
                          (PROG1 (LETT #1# |d| . #2#)
                            (|check-subtype| (>= #1# 0) '(|NonNegativeInteger|)
                                             #1#))
                          1)
                         0)
                        . #2#)
                  (SETELT32 |r| 0 (ELT32 |f| 0))
                  (COND
                   ((< 0 |d|)
                    (SEQ (LETT Q 1 . #2#)
                         (LETT |qn| (REMAINDER2 (EXPT |q| |n|) |prime|) . #2#)
                         (EXIT
                          (SEQ (LETT |i| 1 . #2#) G190
                               (COND ((QSGREATERP |i| |d|) (GO G191)))
                               (SEQ (LETT Q (QSMULMOD32 |qn| Q |prime|) . #2#)
                                    (EXIT
                                     (SETELT32 |r| |i|
                                               (QSMULMOD32 (ELT32 |f| |i|) Q
                                                           |prime|))))
                               (LETT |i| (QSADD1 |i|) . #2#) (GO G190) G191
                               (EXIT NIL))))))
                  (EXIT |r|)))))))) 

(DEFUN |GUESS;qDiffDSF| (|q| |s| |n| $)
  (PROG ()
    (RETURN
     (SPADCALL (CONS #'|GUESS;qDiffDSF!0| (VECTOR |n| $ |q|)) |s|
               (QREFELT $ 412))))) 

(DEFUN |GUESS;qDiffDSF!0| (|z1| $$)
  (PROG (|q| $ |n|)
    (LETT |q| (QREFELT $$ 2) . #1=(|GUESS;qDiffDSF|))
    (LETT $ (QREFELT $$ 1) . #1#)
    (LETT |n| (QREFELT $$ 0) . #1#)
    (RETURN
     (PROGN
      (PROG (#2=#:G4015)
        (RETURN
         (SPADCALL (SPADCALL (SPADCALL |q| (QREFELT $ 240)) (QREFELT $ 410))
                   (PROG1 (LETT #2# (SPADCALL |n| |z1| (QREFELT $ 406)) NIL)
                     (|check-subtype| (>= #2# 0) '(|NonNegativeInteger|) #2#))
                   (QREFELT $ 303)))))))) 

(DEFUN |GUESS;termAsU32VectorqDiff| (|f| |partition| |prime| |q| |dl| $)
  (PROG (|fl| #1=#:G4022 #2=#:G4021 #3=#:G4032 |part| #4=#:G4031 |ll| |d|
         #5=#:G4020 #6=#:G4030 |i| #7=#:G4029)
    (RETURN
     (SEQ
      (COND
       ((NULL |partition|)
        (SPADCALL
         (CONS 1
               (PROGN
                (LETT #7# NIL . #8=(|GUESS;termAsU32VectorqDiff|))
                (SEQ (LETT |i| (+ |dl| 2) . #8#) (LETT #6# (QV32LEN |f|) . #8#)
                     G190 (COND ((> |i| #6#) #9=(GO G191)))
                     (SEQ (EXIT (LETT #7# (CONS 0 #7#) . #8#)))
                     (LETT |i| (+ |i| 1) . #8#) #10=(GO G190) G191
                     (EXIT (NREVERSE0 #7#)))))
         (QREFELT $ 282)))
       ('T
        (SEQ
         (LETT |d|
               (PROG1 (LETT #5# (- (- (QV32LEN |f|) |dl|) 1) . #8#)
                 (|check-subtype| (>= #5# 0) '(|NonNegativeInteger|) #5#))
               . #8#)
         (LETT |ll| (SPADCALL |partition| (QREFELT $ 277)) . #8#)
         (LETT |fl|
               (PROGN
                (LETT #4# NIL . #8#)
                (SEQ (LETT |part| NIL . #8#) (LETT #3# |ll| . #8#) G190
                     (COND
                      ((OR (ATOM #3#)
                           (PROGN (LETT |part| (CAR #3#) . #8#) NIL))
                       #9#))
                     (SEQ
                      (EXIT
                       (LETT #4#
                             (CONS
                              (SPADCALL
                               (|GUESS;qDiffDSV| |f|
                                (PROG1
                                    (LETT #2# (- (|SPADfirst| |part|) 1) . #8#)
                                  (|check-subtype| (>= #2# 0)
                                                   '(|NonNegativeInteger|)
                                                   #2#))
                                |prime| |q| $)
                               (PROG1
                                   (LETT #1# (SPADCALL |part| (QREFELT $ 278))
                                         . #8#)
                                 (|check-subtype| (> #1# 0)
                                                  '(|PositiveInteger|) #1#))
                               |d| |prime| (QREFELT $ 285))
                              #4#)
                             . #8#)))
                     (LETT #3# (CDR #3#) . #8#) #10# G191
                     (EXIT (NREVERSE0 #4#))))
               . #8#)
         (EXIT
          (SPADCALL
           (CONS #'|GUESS;termAsU32VectorqDiff!0| (VECTOR $ |prime| |d|)) |fl|
           (QREFELT $ 289)))))))))) 

(DEFUN |GUESS;termAsU32VectorqDiff!0| (|f1| |f2| $$)
  (PROG (|d| |prime| $)
    (LETT |d| (QREFELT $$ 2) . #1=(|GUESS;termAsU32VectorqDiff|))
    (LETT |prime| (QREFELT $$ 1) . #1#)
    (LETT $ (QREFELT $$ 0) . #1#)
    (RETURN (PROGN (SPADCALL |f1| |f2| |d| |prime| (QREFELT $ 286)))))) 

(DEFUN |GUESS;ADEguessModGenq| (|partitions| |d| $)
  (PROG ()
    (RETURN
     (SEQ (CONS #'|GUESS;ADEguessModGenq!0| (VECTOR |d| |partitions| $)))))) 

(DEFUN |GUESS;ADEguessModGenq!0| (|fl| |prime| |q| $$)
  (PROG ($ |partitions| |d|)
    (LETT $ (QREFELT $$ 2) . #1=(|GUESS;ADEguessModGenq|))
    (LETT |partitions| (QREFELT $$ 1) . #1#)
    (LETT |d| (QREFELT $$ 0) . #1#)
    (RETURN
     (PROGN
      (PROG (#2=#:G4038 |p| #3=#:G4037 |f|)
        (RETURN
         (SEQ
          (COND
           ((NULL
             (SPADCALL (SPADCALL |fl| (QREFELT $ 354)) (|spadConstant| $ 355)
                       (QREFELT $ 269)))
            (|error| "ADEguessModGenq, lambda: #fl ~= 1"))
           ('T
            (SEQ (LETT |f| (SPADCALL |fl| (QREFELT $ 356)) NIL)
                 (EXIT
                  (SPADCALL
                   (PROGN
                    (LETT #3# NIL NIL)
                    (SEQ (LETT |p| NIL NIL) (LETT #2# |partitions| NIL) G190
                         (COND
                          ((OR (ATOM #2#) (PROGN (LETT |p| (CAR #2#) NIL) NIL))
                           (GO G191)))
                         (SEQ
                          (EXIT
                           (LETT #3#
                                 (CONS
                                  (|GUESS;termAsU32VectorqDiff| |f| |p| |prime|
                                   |q| |d| $)
                                  #3#)
                                 NIL)))
                         (LETT #2# (CDR #2#) NIL) (GO G190) G191
                         (EXIT (NREVERSE0 #3#))))
                   (QREFELT $ 357))))))))))))) 

(DEFUN |GUESS;diffHP;SM;89| (|q| $)
  (PROG () (RETURN (SEQ (CONS #'|GUESS;diffHP;SM;89!8| (VECTOR |q| $)))))) 

(DEFUN |GUESS;diffHP;SM;89!8| (|l1| $$)
  (PROG ($ |q|)
    (LETT $ (QREFELT $$ 1) . #1=(|GUESS;diffHP;SM;89|))
    (LETT |q| (QREFELT $$ 0) . #1#)
    (RETURN
     (PROGN
      (PROG (|partitions|)
        (RETURN
         (SEQ
          (COND
           ((NULL (SPADCALL (SPADCALL |l1| (QREFELT $ 377)) (QREFELT $ 413)))
            (|error|
             "Guess: no support for mixed shifts in differential equations")))
          (EXIT
           (COND
            ((SPADCALL (SPADCALL |l1| (QREFELT $ 378)) '|displayAsGF|
                       (QREFELT $ 414))
             (SEQ
              (LETT |partitions| (|GUESS;FilteredPartitionStream| |l1| $) NIL)
              (EXIT
               (VECTOR
                (SPADCALL (CONS #'|GUESS;diffHP;SM;89!0| $) |partitions|
                          (QREFELT $ 401))
                (CONS #'|GUESS;diffHP;SM;89!2| (VECTOR |q| $ |partitions|))
                (CONS #'|GUESS;diffHP;SM;89!3| (VECTOR $ |partitions|))
                (CONS #'|GUESS;diffHP;SM;89!5| (VECTOR |q| $ |partitions|))
                (CONS #'|GUESS;diffHP;SM;89!7| (VECTOR |q| $ |partitions|))
                '|qdiffHP| |q| (CONS (|function| |GUESS;diffA|) $)
                (CONS (|function| |GUESS;diffAF|) $)
                (CONS (|function| |GUESS;diffAX|) $)
                (CONS (|function| |GUESS;diffC|) $)))))
            ('T (|error| "Guess: guessADE supports only displayAsGF"))))))))))) 

(DEFUN |GUESS;diffHP;SM;89!7| (|z1| |z2| $$)
  (PROG (|partitions| $ |q|)
    (LETT |partitions| (QREFELT $$ 2) NIL)
    (LETT $ (QREFELT $$ 1) NIL)
    (LETT |q| (QREFELT $$ 0) NIL)
    (RETURN
     (PROGN
      (PROG ()
        (RETURN
         (|GUESS;ADEEXPRRStream| |z1| |z2| |partitions|
          (CONS #'|GUESS;diffHP;SM;89!6| (VECTOR $ |q|))
          (CONS (|function| |GUESS;diff1X|) $) $))))))) 

(DEFUN |GUESS;diffHP;SM;89!6| (|w1| |w2| |w3| $$)
  (PROG (|q| $)
    (LETT |q| (QREFELT $$ 1) NIL)
    (LETT $ (QREFELT $$ 0) NIL)
    (RETURN (PROGN (|GUESS;qDiffDX| |q| |w1| |w2| |w3| $))))) 

(DEFUN |GUESS;diffHP;SM;89!5| (|l| $$)
  (PROG (|partitions| $ |q|)
    (LETT |partitions| (QREFELT $$ 2) NIL)
    (LETT $ (QREFELT $$ 1) NIL)
    (LETT |q| (QREFELT $$ 0) NIL)
    (RETURN
     (PROGN
      (PROG (#1=#:G4054 |i| #2=#:G4053)
        (RETURN
         (SEQ
          (|GUESS;ADEtestOptimisedGen|
           (PROGN
            (LETT #2# NIL NIL)
            (SEQ (LETT |i| NIL NIL) (LETT #1# |l| NIL) G190
                 (COND
                  ((OR (ATOM #1#) (PROGN (LETT |i| (CAR #1#) NIL) NIL))
                   (GO G191)))
                 (SEQ
                  (EXIT
                   (LETT #2#
                         (CONS (SPADCALL |partitions| |i| (QREFELT $ 382)) #2#)
                         NIL)))
                 (LETT #1# (CDR #1#) NIL) (GO G190) G191
                 (EXIT (NREVERSE0 #2#))))
           (CONS #'|GUESS;diffHP;SM;89!4| (VECTOR $ |q|))
           (|spadConstant| $ 325) $)))))))) 

(DEFUN |GUESS;diffHP;SM;89!4| (|w1| |w2| $$)
  (PROG (|q| $)
    (LETT |q| (QREFELT $$ 1) NIL)
    (LETT $ (QREFELT $$ 0) NIL)
    (RETURN (PROGN (|GUESS;qDiffDSF| |q| |w1| |w2| $))))) 

(DEFUN |GUESS;diffHP;SM;89!3| (|o| $$)
  (PROG (|partitions| $)
    (LETT |partitions| (QREFELT $$ 1) NIL)
    (LETT $ (QREFELT $$ 0) NIL)
    (RETURN
     (PROGN
      (|GUESS;ADEguessModGenq|
       (SPADCALL
        (SPADCALL (SPADCALL |partitions| |o| (QREFELT $ 379)) (QREFELT $ 380))
        (QREFELT $ 381))
       (|spadConstant| $ 273) $))))) 

(DEFUN |GUESS;diffHP;SM;89!2| (|z1| $$)
  (PROG (|partitions| $ |q|)
    (LETT |partitions| (QREFELT $$ 2) NIL)
    (LETT $ (QREFELT $$ 1) NIL)
    (LETT |q| (QREFELT $$ 0) NIL)
    (RETURN
     (PROGN
      (PROG ()
        (RETURN
         (|GUESS;ADEguessStream| |z1| |partitions|
          (CONS #'|GUESS;diffHP;SM;89!1| (VECTOR $ |q|)) (|spadConstant| $ 324)
          $))))))) 

(DEFUN |GUESS;diffHP;SM;89!1| (|w1| |w2| $$)
  (PROG (|q| $)
    (LETT |q| (QREFELT $$ 1) NIL)
    (LETT $ (QREFELT $$ 0) NIL)
    (RETURN (PROGN (|GUESS;qDiffDS| |q| |w1| |w2| $))))) 

(DEFUN |GUESS;diffHP;SM;89!0| (|c| $) (|spadConstant| $ 273)) 

(DEFUN |GUESS;ShiftSX| (|expr| |x| |n| $)
  (SPADCALL |expr| (SPADCALL |x| (QREFELT $ 39))
            (SPADCALL (SPADCALL |x| (QREFELT $ 39))
                      (SPADCALL |n| (QREFELT $ 45)) (QREFELT $ 109))
            (QREFELT $ 46))) 

(DEFUN |GUESS;ShiftSXGF| (|expr| |x| |n| $)
  (PROG (|l| #1=#:G4081 |i| #2=#:G4080)
    (RETURN
     (SEQ
      (COND ((ZEROP |n|) |expr|)
            ('T
             (SEQ
              (LETT |l|
                    (PROGN
                     (LETT #2# NIL . #3=(|GUESS;ShiftSXGF|))
                     (SEQ (LETT |i| 0 . #3#) (LETT #1# (- |n| 1) . #3#) G190
                          (COND ((QSGREATERP |i| #1#) (GO G191)))
                          (SEQ
                           (EXIT
                            (LETT #2#
                                  (CONS
                                   (SPADCALL
                                    (SPADCALL
                                     (SPADCALL
                                      (SPADCALL |expr| |x| |i| (QREFELT $ 369))
                                      (SPADCALL (SPADCALL |i| (QREFELT $ 233))
                                                (QREFELT $ 45))
                                      (QREFELT $ 54))
                                     (SPADCALL |x| (QREFELT $ 39))
                                     (|spadConstant| $ 49) (QREFELT $ 46))
                                    (SPADCALL (SPADCALL |x| (QREFELT $ 39)) |i|
                                              (QREFELT $ 126))
                                    (QREFELT $ 104))
                                   #2#)
                                  . #3#)))
                          (LETT |i| (QSADD1 |i|) . #3#) (GO G190) G191
                          (EXIT (NREVERSE0 #2#))))
                    . #3#)
              (EXIT
               (SPADCALL
                (SPADCALL |expr| (SPADCALL (ELT $ 109) |l| (QREFELT $ 280))
                          (QREFELT $ 94))
                (SPADCALL (SPADCALL |x| (QREFELT $ 39)) |n| (QREFELT $ 126))
                (QREFELT $ 54)))))))))) 

(DEFUN |GUESS;ShiftSS| (|s| |n| $)
  (SPADCALL |s| (SPADCALL (ELT $ 417) |n| (QREFELT $ 420)))) 

(DEFUN |GUESS;ShiftSF| (|s| |n| $)
  (SPADCALL |s| (SPADCALL (ELT $ 421) |n| (QREFELT $ 424)))) 

(DEFUN |GUESS;ShiftAX| (|l| |n| |f| $)
  (SPADCALL (SPADCALL (SPADCALL |n| (QREFELT $ 39)) |l| (QREFELT $ 126)) |f|
            (QREFELT $ 104))) 

(DEFUN |GUESS;ShiftAXGF| (|l| |x| |f| $)
  (PROG (|s| |i| #1=#:G4093)
    (RETURN
     (SEQ
      (COND ((ZEROP |l|) |f|)
            ('T
             (SEQ
              (LETT |s|
                    (PROGN
                     (LETT #1# NIL . #2=(|GUESS;ShiftAXGF|))
                     (SEQ (LETT |i| 1 . #2#) G190
                          (COND ((QSGREATERP |i| |l|) (GO G191)))
                          (SEQ
                           (EXIT
                            (LETT #1#
                                  (CONS
                                   (SPADCALL
                                    (SPADCALL
                                     (SPADCALL
                                      (SPADCALL |l| |i| (QREFELT $ 426))
                                      (QREFELT $ 45))
                                     (SPADCALL (SPADCALL |x| (QREFELT $ 39))
                                               |i| (QREFELT $ 126))
                                     (QREFELT $ 104))
                                    (SPADCALL |f| |x| |i| (QREFELT $ 369))
                                    (QREFELT $ 104))
                                   #1#)
                                  . #2#)))
                          (LETT |i| (QSADD1 |i|) . #2#) (GO G190) G191
                          (EXIT (NREVERSE0 #1#))))
                    . #2#)
              (EXIT (SPADCALL (ELT $ 109) |s| (QREFELT $ 280)))))))))) 

(DEFUN |GUESS;ShiftA| (|k| |l| |f| $) (SPADCALL |k| |l| |f| (QREFELT $ 427))) 

(DEFUN |GUESS;ShiftAF| (|k| |l| |f| $) (SPADCALL |k| |l| |f| (QREFELT $ 428))) 

(DEFUN |GUESS;ShiftC| (|total| $) (SPADCALL |total| (QREFELT $ 429))) 

(DEFUN |GUESS;shiftHP;LR;99| (|options| $)
  (PROG (|degrees| |dk| |partitions|)
    (RETURN
     (SEQ
      (COND
       ((NULL (ZEROP (SPADCALL |options| (QREFELT $ 377))))
        (|error| "Guess: need a symbol for mixed Shifting")))
      (LETT |partitions| (|GUESS;FilteredPartitionStream| |options| $)
            . #1=(|GUESS;shiftHP;LR;99|))
      (LETT |dk| (SPADCALL |options| (QREFELT $ 378)) . #1#)
      (COND
       ((NULL (EQUAL |dk| '|displayAsRec|))
        (EXIT
         (|error|
          "Guess: no support for the Shift operator with displayAsGF"))))
      (LETT |degrees| (|GUESS;ADEdegreeStream| |partitions| $) . #1#)
      (EXIT
       (VECTOR |degrees|
               (CONS #'|GUESS;shiftHP;LR;99!0| (VECTOR $ |partitions|))
               (CONS #'|GUESS;shiftHP;LR;99!1|
                     (VECTOR |degrees| $ |partitions|))
               (CONS #'|GUESS;shiftHP;LR;99!2| (VECTOR $ |partitions|))
               (CONS #'|GUESS;shiftHP;LR;99!3| (VECTOR $ |partitions|))
               '|shiftHP| '|dummy| (CONS (|function| |GUESS;ShiftA|) $)
               (CONS (|function| |GUESS;ShiftAF|) $)
               (CONS (|function| |GUESS;ShiftAX|) $)
               (CONS (|function| |GUESS;ShiftC|) $))))))) 

(DEFUN |GUESS;shiftHP;LR;99!3| (|z1| |z2| $$)
  (PROG (|partitions| $)
    (LETT |partitions| (QREFELT $$ 1) . #1=(|GUESS;shiftHP;LR;99|))
    (LETT $ (QREFELT $$ 0) . #1#)
    (RETURN
     (PROGN
      (|GUESS;ADEEXPRRStream| |z1| |z2| |partitions|
       (CONS (|function| |GUESS;ShiftSX|) $)
       (CONS (|function| |GUESS;diff1X|) $) $))))) 

(DEFUN |GUESS;shiftHP;LR;99!2| (|l| $$)
  (PROG (|partitions| $)
    (LETT |partitions| (QREFELT $$ 1) . #1=(|GUESS;shiftHP;LR;99|))
    (LETT $ (QREFELT $$ 0) . #1#)
    (RETURN
     (PROGN
      (PROG (#2=#:G4113 |i| #3=#:G4112)
        (RETURN
         (SEQ
          (|GUESS;ADEtestGen2|
           (PROGN
            (LETT #3# NIL NIL)
            (SEQ (LETT |i| NIL NIL) (LETT #2# |l| NIL) G190
                 (COND
                  ((OR (ATOM #2#) (PROGN (LETT |i| (CAR #2#) NIL) NIL))
                   (GO G191)))
                 (SEQ
                  (EXIT
                   (LETT #3#
                         (CONS (SPADCALL |partitions| |i| (QREFELT $ 382)) #3#)
                         NIL)))
                 (LETT #2# (CDR #2#) NIL) (GO G190) G191
                 (EXIT (NREVERSE0 #3#))))
           (CONS (|function| |GUESS;ShiftSF|) $)
           (SPADCALL
            (SPADCALL (|spadConstant| $ 325)
                      (SPADCALL (|spadConstant| $ 332) (|spadConstant| $ 107)
                                (QREFELT $ 435))
                      (QREFELT $ 436))
            (SPADCALL (|spadConstant| $ 331) (QREFELT $ 432)) (QREFELT $ 437))
           $)))))))) 

(DEFUN |GUESS;shiftHP;LR;99!1| (|o| $$)
  (PROG (|partitions| $ |degrees|)
    (LETT |partitions| (QREFELT $$ 2) . #1=(|GUESS;shiftHP;LR;99|))
    (LETT $ (QREFELT $$ 1) . #1#)
    (LETT |degrees| (QREFELT $$ 0) . #1#)
    (RETURN
     (PROGN
      (|GUESS;ADEguessModGen2|
       (SPADCALL
        (SPADCALL (SPADCALL |partitions| |o| (QREFELT $ 379)) (QREFELT $ 380))
        (QREFELT $ 381))
       (SPADCALL |degrees| |o| (QREFELT $ 434)) $))))) 

(DEFUN |GUESS;shiftHP;LR;99!0| (|z1| $$)
  (PROG (|partitions| $)
    (LETT |partitions| (QREFELT $$ 1) . #1=(|GUESS;shiftHP;LR;99|))
    (LETT $ (QREFELT $$ 0) . #1#)
    (RETURN
     (PROGN
      (|GUESS;ADEguessStream2| |z1| |partitions|
       (CONS (|function| |GUESS;ShiftSS|) $)
       (SPADCALL
        (SPADCALL (|spadConstant| $ 324)
                  (SPADCALL (|spadConstant| $ 11) (|spadConstant| $ 355)
                            (QREFELT $ 430))
                  (QREFELT $ 431))
        (SPADCALL (|spadConstant| $ 331) (QREFELT $ 432)) (QREFELT $ 433))
       $))))) 

(DEFUN |GUESS;qShiftAX| (|q| |l| |n| |f| $)
  (SPADCALL
   (SPADCALL (SPADCALL |q| (QREFELT $ 39))
             (SPADCALL |l| (SPADCALL |n| (QREFELT $ 39)) (QREFELT $ 439))
             (QREFELT $ 214))
   |f| (QREFELT $ 104))) 

(DEFUN |GUESS;qShiftA| (|q| |k| |l| |f| $)
  (SPADCALL (SPADCALL |q| (QREFELT $ 440)) |k| |l| |f| (QREFELT $ 441))) 

(DEFUN |GUESS;qShiftAF| (|q| |k| |l| |f| $)
  (SPADCALL (SPADCALL (SPADCALL |q| (QREFELT $ 240)) (QREFELT $ 410)) |k| |l|
            |f| (QREFELT $ 442))) 

(DEFUN |GUESS;qShiftC| (|q| |total| $)
  (SPADCALL (SPADCALL |q| (QREFELT $ 440)) |total| (QREFELT $ 443))) 

(DEFUN |GUESS;qSubstUFPSF| (|q| |s| |maxMD| $)
  (PROG (|i| #1=#:G4137)
    (RETURN
     (SEQ
      (PROGN
       (LETT #1# NIL . #2=(|GUESS;qSubstUFPSF|))
       (SEQ (LETT |i| 0 . #2#) G190 (COND ((QSGREATERP |i| |maxMD|) (GO G191)))
            (SEQ
             (EXIT
              (LETT #1#
                    (CONS
                     (SPADCALL |s|
                               (SPADCALL
                                (SPADCALL (SPADCALL |q| (QREFELT $ 240)) |i|
                                          (QREFELT $ 297))
                                (SPADCALL (|spadConstant| $ 11) 1
                                          (QREFELT $ 430))
                                (QREFELT $ 444))
                               (QREFELT $ 445))
                     #1#)
                    . #2#)))
            (LETT |i| (QSADD1 |i|) . #2#) (GO G190) G191
            (EXIT (NREVERSE0 #1#)))))))) 

(DEFUN |GUESS;qSubstEXPRR| (|q| |xx| |s| |maxMD| $)
  (PROG (|i| #1=#:G4140)
    (RETURN
     (SEQ
      (PROGN
       (LETT #1# NIL . #2=(|GUESS;qSubstEXPRR|))
       (SEQ (LETT |i| 0 . #2#) G190 (COND ((QSGREATERP |i| |maxMD|) (GO G191)))
            (SEQ
             (EXIT
              (LETT #1#
                    (CONS
                     (SPADCALL
                      (SPADCALL (SPADCALL |q| (QREFELT $ 39))
                                (SPADCALL |i| (SPADCALL |xx| (QREFELT $ 39))
                                          (QREFELT $ 439))
                                (QREFELT $ 214))
                      |s| (QREFELT $ 104))
                     #1#)
                    . #2#)))
            (LETT |i| (QSADD1 |i|) . #2#) (GO G190) G191
            (EXIT (NREVERSE0 #1#)))))))) 

(DEFUN |GUESS;ADEguessStreamMixShift| (|q| |f| |partitions| |maxMD| $)
  (PROG (|s|)
    (RETURN
     (SEQ
      (LETT |s|
            (|GUESS;ADEguessStream2| |f| |partitions|
             (CONS (|function| |GUESS;ShiftSS|) $)
             (SPADCALL
              (SPADCALL (|spadConstant| $ 324)
                        (SPADCALL (|spadConstant| $ 11) 1 (QREFELT $ 430))
                        (QREFELT $ 431))
              (SPADCALL (|spadConstant| $ 331) (QREFELT $ 432))
              (QREFELT $ 433))
             $)
            |GUESS;ADEguessStreamMixShift|)
      (EXIT
       (SPADCALL |s|
                 (CONS #'|GUESS;ADEguessStreamMixShift!0|
                       (VECTOR $ |maxMD| |q|))
                 (QREFELT $ 448))))))) 

(DEFUN |GUESS;ADEguessStreamMixShift!0| (|z1| $$)
  (PROG (|q| |maxMD| $)
    (LETT |q| (QREFELT $$ 2) . #1=(|GUESS;ADEguessStreamMixShift|))
    (LETT |maxMD| (QREFELT $$ 1) . #1#)
    (LETT $ (QREFELT $$ 0) . #1#)
    (RETURN (PROGN (|GUESS;qSubstUFPSF| |q| |z1| |maxMD| $))))) 

(DEFUN |GUESS;ADEguessModGen2Mixed| (|partitions| |dl| |maxMD| |o| $)
  (PROG ()
    (RETURN
     (SEQ
      (CONS #'|GUESS;ADEguessModGen2Mixed!0|
            (VECTOR |partitions| |maxMD| |o| |dl| $)))))) 

(DEFUN |GUESS;ADEguessModGen2Mixed!0| (|fl| |prime| |q| $$)
  (PROG ($ |dl| |o| |maxMD| |partitions|)
    (LETT $ (QREFELT $$ 4) . #1=(|GUESS;ADEguessModGen2Mixed|))
    (LETT |dl| (QREFELT $$ 3) . #1#)
    (LETT |o| (QREFELT $$ 2) . #1#)
    (LETT |maxMD| (QREFELT $$ 1) . #1#)
    (LETT |partitions| (QREFELT $$ 0) . #1#)
    (RETURN
     (PROGN
      (PROG (|l| |vv| |e| |vn| |i| |r| |lastv| #2=#:G4165 |v| #3=#:G4166 |w|
             |vv1| #4=#:G4164 |p| #5=#:G4163 O #6=#:G4150 |qv| |d| #7=#:G4148
             |f|)
        (RETURN
         (SEQ
          (COND
           ((NULL
             (SPADCALL (SPADCALL |fl| (QREFELT $ 354)) (|spadConstant| $ 355)
                       (QREFELT $ 269)))
            (|error| "ADEguessModGen2Mixed: #fl ~= 1"))
           ('T
            (SEQ (LETT |f| (SPADCALL |fl| (QREFELT $ 356)) NIL)
                 (LETT |d|
                       (PROG1
                           (LETT #7#
                                 (SPADCALL
                                  (SPADCALL (SPADCALL |f| (QREFELT $ 449)) |dl|
                                            (QREFELT $ 217))
                                  (|spadConstant| $ 355) (QREFELT $ 217))
                                 NIL)
                         (|check-subtype| (>= #7# 0) '(|NonNegativeInteger|)
                                          #7#))
                       NIL)
                 (LETT |qv|
                       (SPADCALL
                        (SPADCALL |d| (|spadConstant| $ 355) (QREFELT $ 257))
                        (|spadConstant| $ 355) (QREFELT $ 450))
                       NIL)
                 (SEQ (LETT |i| (|spadConstant| $ 355) NIL) G190
                      (COND ((> |i| |d|) (GO G191)))
                      (SEQ
                       (EXIT
                        (SPADCALL |qv| |i|
                                  (SPADCALL (SPADCALL |q| |i| (QREFELT $ 453))
                                            |prime| (QREFELT $ 454))
                                  (QREFELT $ 455))))
                      (LETT |i| (+ |i| 1) NIL) (GO G190) G191 (EXIT NIL))
                 (LETT O
                       (PROG1
                           (LETT #6#
                                 (SPADCALL
                                  (SPADCALL |o|
                                            (SPADCALL |maxMD|
                                                      (|spadConstant| $ 355)
                                                      (QREFELT $ 257))
                                            (QREFELT $ 456))
                                  (QREFELT $ 457))
                                 NIL)
                         (|check-subtype| (>= #6# 0) '(|NonNegativeInteger|)
                                          #6#))
                       NIL)
                 (LETT |vv1|
                       (PROGN
                        (LETT #5# NIL NIL)
                        (SEQ (LETT |p| NIL NIL)
                             (LETT #4#
                                   (SPADCALL
                                    (SPADCALL
                                     (SPADCALL |partitions| O (QREFELT $ 379))
                                     (QREFELT $ 380))
                                    (QREFELT $ 381))
                                   NIL)
                             G190
                             (COND
                              ((OR (ATOM #4#)
                                   (PROGN (LETT |p| (CAR #4#) NIL) NIL))
                               (GO G191)))
                             (SEQ
                              (EXIT
                               (LETT #5#
                                     (CONS
                                      (|GUESS;termAsU32VectorShift| |f| |p|
                                       |prime| |dl| $)
                                      #5#)
                                     NIL)))
                             (LETT #4# (CDR #4#) NIL) (GO G190) G191
                             (EXIT (NREVERSE0 #5#))))
                       NIL)
                 (LETT |l| NIL NIL)
                 (LETT |lastv| (SPADCALL |vv1| (QREFELT $ 356)) NIL)
                 (SEQ (LETT |w| NIL NIL)
                      (LETT #3# (SPADCALL |vv1| (QREFELT $ 458)) NIL)
                      (LETT |v| NIL NIL) (LETT #2# |vv1| NIL) G190
                      (COND
                       ((OR (ATOM #2#) (PROGN (LETT |v| (CAR #2#) NIL) NIL)
                            (ATOM #3#) (PROGN (LETT |w| (CAR #3#) NIL) NIL))
                        (GO G191)))
                      (SEQ (LETT |lastv| |w| NIL) (LETT |vv| (LIST |v|) NIL)
                           (LETT |vn| |v| NIL)
                           (SEQ (LETT |i| (|spadConstant| $ 355) NIL) G190
                                (COND ((> |i| |maxMD|) (GO G191)))
                                (SEQ
                                 (LETT |vn| (SPADCALL |vn| (QREFELT $ 459))
                                       NIL)
                                 (SEQ (LETT |e| (|spadConstant| $ 355) NIL)
                                      G190 (COND ((> |e| |d|) (GO G191)))
                                      (SEQ
                                       (EXIT
                                        (SPADCALL |vn| |e|
                                                  (QSMULMOD32
                                                   (SPADCALL |vn| |e|
                                                             (QREFELT $ 460))
                                                   (SPADCALL |qv| |e|
                                                             (QREFELT $ 460))
                                                   |prime|)
                                                  (QREFELT $ 455))))
                                      (LETT |e| (+ |e| 1) NIL) (GO G190) G191
                                      (EXIT NIL))
                                 (EXIT
                                  (LETT |vv|
                                        (SPADCALL |vn| |vv| (QREFELT $ 461))
                                        NIL)))
                                (LETT |i| (+ |i| 1) NIL) (GO G190) G191
                                (EXIT NIL))
                           (EXIT
                            (LETT |l|
                                  (SPADCALL
                                   (SPADCALL (SPADCALL |vv| (QREFELT $ 462))
                                             (QREFELT $ 357))
                                   |l| (QREFELT $ 464))
                                  NIL)))
                      (LETT #2# (PROG1 (CDR #2#) (LETT #3# (CDR #3#) NIL)) NIL)
                      (GO G190) G191 (EXIT NIL))
                 (LETT |vv| (LIST |lastv|) NIL) (LETT |vn| |lastv| NIL)
                 (LETT |r|
                       (SPADCALL
                        (SPADCALL |o|
                                  (SPADCALL |maxMD| (|spadConstant| $ 355)
                                            (QREFELT $ 257))
                                  (QREFELT $ 465))
                        (|spadConstant| $ 355) (QREFELT $ 217))
                       NIL)
                 (COND
                  ((SPADCALL |r|
                             (SPADCALL (|spadConstant| $ 452) (QREFELT $ 466))
                             (QREFELT $ 274))
                   (LETT |r| |maxMD| NIL)))
                 (SEQ (LETT |i| (|spadConstant| $ 355) NIL) G190
                      (COND ((> |i| |r|) (GO G191)))
                      (SEQ (LETT |vn| (SPADCALL |vn| (QREFELT $ 459)) NIL)
                           (SEQ (LETT |e| (|spadConstant| $ 355) NIL) G190
                                (COND ((> |e| |d|) (GO G191)))
                                (SEQ
                                 (EXIT
                                  (SPADCALL |vn| |e|
                                            (QSMULMOD32
                                             (SPADCALL |vn| |e|
                                                       (QREFELT $ 460))
                                             (SPADCALL |qv| |e|
                                                       (QREFELT $ 460))
                                             |prime|)
                                            (QREFELT $ 455))))
                                (LETT |e| (+ |e| 1) NIL) (GO G190) G191
                                (EXIT NIL))
                           (EXIT
                            (LETT |vv| (SPADCALL |vn| |vv| (QREFELT $ 461))
                                  NIL)))
                      (LETT |i| (+ |i| 1) NIL) (GO G190) G191 (EXIT NIL))
                 (LETT |l|
                       (SPADCALL
                        (SPADCALL (SPADCALL |vv| (QREFELT $ 462))
                                  (QREFELT $ 357))
                        |l| (QREFELT $ 464))
                       NIL)
                 (EXIT
                  (SPADCALL (SPADCALL |l| (QREFELT $ 467))
                            (QREFELT $ 469))))))))))))) 

(DEFUN |GUESS;ADEdegreeStreamMixShift| (|partitions| |maxMD| $)
  (PROG (|s|)
    (RETURN
     (SEQ
      (LETT |s| (|GUESS;ADEdegreeStream| |partitions| $)
            |GUESS;ADEdegreeStreamMixShift|)
      (EXIT
       (SPADCALL |s|
                 (CONS #'|GUESS;ADEdegreeStreamMixShift!0| (VECTOR |maxMD| $))
                 (QREFELT $ 473))))))) 

(DEFUN |GUESS;ADEdegreeStreamMixShift!0| (|z1| $$)
  (PROG ($ |maxMD|)
    (LETT $ (QREFELT $$ 1) . #1=(|GUESS;ADEdegreeStreamMixShift|))
    (LETT |maxMD| (QREFELT $$ 0) . #1#)
    (RETURN
     (PROGN
      (PROG (|i| #2=#:G4170)
        (RETURN
         (SEQ
          (PROGN
           (LETT #2# NIL NIL)
           (SEQ (LETT |i| (|spadConstant| $ 273) NIL) G190
                (COND ((> |i| |maxMD|) (GO G191)))
                (SEQ (EXIT (LETT #2# (CONS |z1| #2#) NIL)))
                (LETT |i| (+ |i| 1) NIL) (GO G190) G191
                (EXIT (NREVERSE0 #2#))))))))))) 

(DEFUN |GUESS;ADEtestMixShiftGen| (|q| |partitions| |maxMD| |l| $)
  (PROG ()
    (RETURN
     (SEQ
      (CONS #'|GUESS;ADEtestMixShiftGen!0|
            (VECTOR |q| |partitions| |maxMD| $ |l|)))))) 

(DEFUN |GUESS;ADEtestMixShiftGen!0| (|f| $$)
  (PROG (|l| $ |maxMD| |partitions| |q|)
    (LETT |l| (QREFELT $$ 4) . #1=(|GUESS;ADEtestMixShiftGen|))
    (LETT $ (QREFELT $$ 3) . #1#)
    (LETT |maxMD| (QREFELT $$ 2) . #1#)
    (LETT |partitions| (QREFELT $$ 1) . #1#)
    (LETT |q| (QREFELT $$ 0) . #1#)
    (RETURN
     (PROGN
      (PROG (|res| #2=#:G4194 |i| #3=#:G4193 |f0| |exponents| #4=#:G4181
             |oldPartition| #5=#:G4192 #6=#:G4191 |newPartition| #7=#:G4175
             #8=#:G4190 |p| #9=#:G4174)
        (RETURN
         (SEQ (LETT |res| NIL NIL) (LETT |exponents| NIL NIL)
              (LETT |oldPartition|
                    (PROG1
                        (LETT #9#
                              (SPADCALL
                               (SPADCALL (SPADCALL |l| (QREFELT $ 475))
                                         (SPADCALL |maxMD|
                                                   (|spadConstant| $ 107)
                                                   (QREFELT $ 257))
                                         (QREFELT $ 456))
                               (QREFELT $ 457))
                              NIL)
                      (|check-subtype| (> #9# 0) '(|PositiveInteger|) #9#))
                    NIL)
              (SEQ (LETT |p| NIL NIL) (LETT #8# |l| NIL) G190
                   (COND
                    ((OR (ATOM #8#) (PROGN (LETT |p| (CAR #8#) NIL) NIL))
                     (GO G191)))
                   (SEQ
                    (LETT |newPartition|
                          (PROG1
                              (LETT #7#
                                    (SPADCALL
                                     (SPADCALL |p|
                                               (SPADCALL |maxMD|
                                                         (|spadConstant| $ 107)
                                                         (QREFELT $ 257))
                                               (QREFELT $ 456))
                                     (QREFELT $ 457))
                                    NIL)
                            (|check-subtype| (> #7# 0) '(|PositiveInteger|)
                                             #7#))
                          NIL)
                    (COND
                     ((SPADCALL |oldPartition| |newPartition| (QREFELT $ 476))
                      (SEQ
                       (LETT |f0|
                             (|GUESS;termAsUFPSSUPF2| |f|
                              (SPADCALL |partitions| |oldPartition|
                                        (QREFELT $ 382))
                              (CONS (|function| |GUESS;ShiftSF|) $)
                              (SPADCALL
                               (SPADCALL (|spadConstant| $ 325)
                                         (SPADCALL (|spadConstant| $ 332)
                                                   (|spadConstant| $ 107)
                                                   (QREFELT $ 435))
                                         (QREFELT $ 436))
                               (SPADCALL (|spadConstant| $ 331)
                                         (QREFELT $ 432))
                               (QREFELT $ 437))
                              $)
                             NIL)
                       (LETT |res|
                             (SPADCALL
                              (PROGN
                               (LETT #6# NIL NIL)
                               (SEQ (LETT |i| NIL NIL)
                                    (LETT #5# |exponents| NIL) G190
                                    (COND
                                     ((OR (ATOM #5#)
                                          (PROGN (LETT |i| (CAR #5#) NIL) NIL))
                                      (GO G191)))
                                    (SEQ
                                     (EXIT
                                      (LETT #6#
                                            (CONS
                                             (SPADCALL |f0|
                                                       (SPADCALL
                                                        (SPADCALL
                                                         (SPADCALL
                                                          (SPADCALL |q|
                                                                    (QREFELT $
                                                                             240))
                                                          |i| (QREFELT $ 297))
                                                         (QREFELT $ 410))
                                                        (SPADCALL
                                                         (|spadConstant| $ 332)
                                                         (|spadConstant| $ 107)
                                                         (QREFELT $ 435))
                                                        (QREFELT $ 477))
                                                       (QREFELT $ 478))
                                             #6#)
                                            NIL)))
                                    (LETT #5# (CDR #5#) NIL) (GO G190) G191
                                    (EXIT (NREVERSE0 #6#))))
                              |res| (QREFELT $ 479))
                             NIL)
                       (LETT |exponents| NIL NIL)
                       (EXIT (LETT |oldPartition| |newPartition| NIL)))))
                    (EXIT
                     (LETT |exponents|
                           (SPADCALL
                            (PROG1
                                (LETT #4#
                                      (SPADCALL
                                       (SPADCALL |p| (|spadConstant| $ 107)
                                                 (QREFELT $ 217))
                                       (SPADCALL |maxMD| (|spadConstant| $ 107)
                                                 (QREFELT $ 257))
                                       (QREFELT $ 454))
                                      NIL)
                              (|check-subtype| (>= #4# 0)
                                               '(|NonNegativeInteger|) #4#))
                            |exponents| (QREFELT $ 481))
                           NIL)))
                   (LETT #8# (CDR #8#) NIL) (GO G190) G191 (EXIT NIL))
              (LETT |f0|
                    (|GUESS;termAsUFPSSUPF2| |f|
                     (SPADCALL |partitions| |oldPartition| (QREFELT $ 382))
                     (CONS (|function| |GUESS;ShiftSF|) $)
                     (SPADCALL
                      (SPADCALL (|spadConstant| $ 325)
                                (SPADCALL (|spadConstant| $ 332)
                                          (|spadConstant| $ 107)
                                          (QREFELT $ 435))
                                (QREFELT $ 436))
                      (SPADCALL (|spadConstant| $ 331) (QREFELT $ 432))
                      (QREFELT $ 437))
                     $)
                    NIL)
              (LETT |res|
                    (SPADCALL
                     (PROGN
                      (LETT #3# NIL NIL)
                      (SEQ (LETT |i| NIL NIL) (LETT #2# |exponents| NIL) G190
                           (COND
                            ((OR (ATOM #2#)
                                 (PROGN (LETT |i| (CAR #2#) NIL) NIL))
                             (GO G191)))
                           (SEQ
                            (EXIT
                             (LETT #3#
                                   (CONS
                                    (SPADCALL |f0|
                                              (SPADCALL
                                               (SPADCALL
                                                (SPADCALL
                                                 (SPADCALL |q| (QREFELT $ 240))
                                                 |i| (QREFELT $ 297))
                                                (QREFELT $ 410))
                                               (SPADCALL (|spadConstant| $ 332)
                                                         (|spadConstant| $ 107)
                                                         (QREFELT $ 435))
                                               (QREFELT $ 477))
                                              (QREFELT $ 478))
                                    #3#)
                                   NIL)))
                           (LETT #2# (CDR #2#) NIL) (GO G190) G191
                           (EXIT (NREVERSE0 #3#))))
                     |res| (QREFELT $ 479))
                    NIL)
              (EXIT
               (SPADCALL (SPADCALL |res| (QREFELT $ 482))
                         (QREFELT $ 358)))))))))) 

(DEFUN |GUESS;ADEEXPRRStreamMixShift| (|q| |f| |xx| |partitions| |maxMD| $)
  (PROG (|s|)
    (RETURN
     (SEQ
      (LETT |s|
            (|GUESS;ADEEXPRRStream| |f| |xx| |partitions|
             (CONS (|function| |GUESS;ShiftSX|) $)
             (CONS (|function| |GUESS;diff1X|) $) $)
            |GUESS;ADEEXPRRStreamMixShift|)
      (EXIT
       (SPADCALL |s|
                 (CONS #'|GUESS;ADEEXPRRStreamMixShift!0|
                       (VECTOR $ |maxMD| |xx| |q|))
                 (QREFELT $ 485))))))) 

(DEFUN |GUESS;ADEEXPRRStreamMixShift!0| (|z1| $$)
  (PROG (|q| |xx| |maxMD| $)
    (LETT |q| (QREFELT $$ 3) . #1=(|GUESS;ADEEXPRRStreamMixShift|))
    (LETT |xx| (QREFELT $$ 2) . #1#)
    (LETT |maxMD| (QREFELT $$ 1) . #1#)
    (LETT $ (QREFELT $$ 0) . #1#)
    (RETURN (PROGN (|GUESS;qSubstEXPRR| |q| |xx| |z1| |maxMD| $))))) 

(DEFUN |GUESS;shiftHP;SM;111| (|q| $)
  (PROG () (RETURN (SEQ (CONS #'|GUESS;shiftHP;SM;111!12| (VECTOR |q| $)))))) 

(DEFUN |GUESS;shiftHP;SM;111!12| (|l1| $$)
  (PROG ($ |q|)
    (LETT $ (QREFELT $$ 1) . #1=(|GUESS;shiftHP;SM;111|))
    (LETT |q| (QREFELT $$ 0) . #1#)
    (RETURN
     (PROGN
      (PROG (|degrees| |maxMD| |partitions|)
        (RETURN
         (SEQ
          (COND
           ((SPADCALL (SPADCALL |l1| (QREFELT $ 378)) '|displayAsRec|
                      (QREFELT $ 414))
            (SEQ
             (LETT |partitions| (|GUESS;FilteredPartitionStream| |l1| $) NIL)
             (EXIT
              (COND
               ((SPADCALL (LETT |maxMD| (SPADCALL |l1| (QREFELT $ 377)) NIL)
                          (QREFELT $ 413))
                (SEQ
                 (LETT |degrees| (|GUESS;ADEdegreeStream| |partitions| $) NIL)
                 (EXIT
                  (VECTOR |degrees|
                          (CONS #'|GUESS;shiftHP;SM;111!0|
                                (VECTOR $ |partitions|))
                          (CONS #'|GUESS;shiftHP;SM;111!1|
                                (VECTOR |degrees| $ |partitions|))
                          (CONS #'|GUESS;shiftHP;SM;111!2|
                                (VECTOR $ |partitions|))
                          (CONS #'|GUESS;shiftHP;SM;111!3|
                                (VECTOR $ |partitions|))
                          '|qshiftHP| |q|
                          (CONS #'|GUESS;shiftHP;SM;111!4| (VECTOR $ |q|))
                          (CONS #'|GUESS;shiftHP;SM;111!5| (VECTOR $ |q|))
                          (CONS #'|GUESS;shiftHP;SM;111!6| (VECTOR $ |q|))
                          (CONS #'|GUESS;shiftHP;SM;111!7| (VECTOR $ |q|))))))
               ('T
                (SEQ
                 (LETT |degrees|
                       (|GUESS;ADEdegreeStreamMixShift| |partitions| |maxMD| $)
                       NIL)
                 (EXIT
                  (VECTOR |degrees|
                          (CONS #'|GUESS;shiftHP;SM;111!8|
                                (VECTOR $ |maxMD| |partitions| |q|))
                          (CONS #'|GUESS;shiftHP;SM;111!9|
                                (VECTOR |maxMD| $ |degrees| |partitions|))
                          (CONS #'|GUESS;shiftHP;SM;111!10|
                                (VECTOR $ |maxMD| |partitions| |q|))
                          (CONS #'|GUESS;shiftHP;SM;111!11|
                                (VECTOR $ |maxMD| |partitions| |q|))
                          '|qmixed| |q| (CONS (|function| |GUESS;ShiftA|) $)
                          (CONS (|function| |GUESS;ShiftAF|) $)
                          (CONS (|function| |GUESS;ShiftAX|) $)
                          (CONS (|function| |GUESS;ShiftC|) $)))))))))
           ('T
            (|error|
             "Guess: no support for the qShift operator with displayAsGF")))))))))) 

(DEFUN |GUESS;shiftHP;SM;111!11| (|z1| |z2| $$)
  (PROG (|q| |partitions| |maxMD| $)
    (LETT |q| (QREFELT $$ 3) NIL)
    (LETT |partitions| (QREFELT $$ 2) NIL)
    (LETT |maxMD| (QREFELT $$ 1) NIL)
    (LETT $ (QREFELT $$ 0) NIL)
    (RETURN
     (PROGN
      (|GUESS;ADEEXPRRStreamMixShift| |q| |z1| |z2| |partitions| |maxMD| $))))) 

(DEFUN |GUESS;shiftHP;SM;111!10| (|l| $$)
  (PROG (|q| |partitions| |maxMD| $)
    (LETT |q| (QREFELT $$ 3) NIL)
    (LETT |partitions| (QREFELT $$ 2) NIL)
    (LETT |maxMD| (QREFELT $$ 1) NIL)
    (LETT $ (QREFELT $$ 0) NIL)
    (RETURN
     (PROGN (|GUESS;ADEtestMixShiftGen| |q| |partitions| |maxMD| |l| $))))) 

(DEFUN |GUESS;shiftHP;SM;111!9| (|o| $$)
  (PROG (|partitions| |degrees| $ |maxMD|)
    (LETT |partitions| (QREFELT $$ 3) NIL)
    (LETT |degrees| (QREFELT $$ 2) NIL)
    (LETT $ (QREFELT $$ 1) NIL)
    (LETT |maxMD| (QREFELT $$ 0) NIL)
    (RETURN
     (PROGN
      (|GUESS;ADEguessModGen2Mixed| |partitions|
       (SPADCALL |degrees| |o| (QREFELT $ 434)) |maxMD| |o| $))))) 

(DEFUN |GUESS;shiftHP;SM;111!8| (|z1| $$)
  (PROG (|q| |partitions| |maxMD| $)
    (LETT |q| (QREFELT $$ 3) NIL)
    (LETT |partitions| (QREFELT $$ 2) NIL)
    (LETT |maxMD| (QREFELT $$ 1) NIL)
    (LETT $ (QREFELT $$ 0) NIL)
    (RETURN
     (PROGN (|GUESS;ADEguessStreamMixShift| |q| |z1| |partitions| |maxMD| $))))) 

(DEFUN |GUESS;shiftHP;SM;111!7| (|z1| $$)
  (PROG (|q| $)
    (LETT |q| (QREFELT $$ 1) NIL)
    (LETT $ (QREFELT $$ 0) NIL)
    (RETURN (PROGN (|GUESS;qShiftC| |q| |z1| $))))) 

(DEFUN |GUESS;shiftHP;SM;111!6| (|z1| |z2| |z3| $$)
  (PROG (|q| $)
    (LETT |q| (QREFELT $$ 1) NIL)
    (LETT $ (QREFELT $$ 0) NIL)
    (RETURN (PROGN (|GUESS;qShiftAX| |q| |z1| |z2| |z3| $))))) 

(DEFUN |GUESS;shiftHP;SM;111!5| (|z1| |z2| |z3| $$)
  (PROG (|q| $)
    (LETT |q| (QREFELT $$ 1) NIL)
    (LETT $ (QREFELT $$ 0) NIL)
    (RETURN (PROGN (|GUESS;qShiftAF| |q| |z1| |z2| |z3| $))))) 

(DEFUN |GUESS;shiftHP;SM;111!4| (|z1| |z2| |z3| $$)
  (PROG (|q| $)
    (LETT |q| (QREFELT $$ 1) NIL)
    (LETT $ (QREFELT $$ 0) NIL)
    (RETURN (PROGN (|GUESS;qShiftA| |q| |z1| |z2| |z3| $))))) 

(DEFUN |GUESS;shiftHP;SM;111!3| (|z1| |z2| $$)
  (PROG (|partitions| $)
    (LETT |partitions| (QREFELT $$ 1) NIL)
    (LETT $ (QREFELT $$ 0) NIL)
    (RETURN
     (PROGN
      (|GUESS;ADEEXPRRStream| |z1| |z2| |partitions|
       (CONS (|function| |GUESS;ShiftSX|) $)
       (CONS (|function| |GUESS;diff1X|) $) $))))) 

(DEFUN |GUESS;shiftHP;SM;111!2| (|l| $$)
  (PROG (|partitions| $)
    (LETT |partitions| (QREFELT $$ 1) NIL)
    (LETT $ (QREFELT $$ 0) NIL)
    (RETURN
     (PROGN
      (PROG (#1=#:G4218 |i| #2=#:G4217)
        (RETURN
         (SEQ
          (|GUESS;ADEtestGen2|
           (PROGN
            (LETT #2# NIL NIL)
            (SEQ (LETT |i| NIL NIL) (LETT #1# |l| NIL) G190
                 (COND
                  ((OR (ATOM #1#) (PROGN (LETT |i| (CAR #1#) NIL) NIL))
                   (GO G191)))
                 (SEQ
                  (EXIT
                   (LETT #2#
                         (CONS (SPADCALL |partitions| |i| (QREFELT $ 382)) #2#)
                         NIL)))
                 (LETT #1# (CDR #1#) NIL) (GO G190) G191
                 (EXIT (NREVERSE0 #2#))))
           (CONS (|function| |GUESS;ShiftSF|) $)
           (SPADCALL
            (SPADCALL (|spadConstant| $ 325)
                      (SPADCALL (|spadConstant| $ 332) (|spadConstant| $ 107)
                                (QREFELT $ 435))
                      (QREFELT $ 436))
            (SPADCALL (|spadConstant| $ 331) (QREFELT $ 432)) (QREFELT $ 437))
           $)))))))) 

(DEFUN |GUESS;shiftHP;SM;111!1| (|o| $$)
  (PROG (|partitions| $ |degrees|)
    (LETT |partitions| (QREFELT $$ 2) NIL)
    (LETT $ (QREFELT $$ 1) NIL)
    (LETT |degrees| (QREFELT $$ 0) NIL)
    (RETURN
     (PROGN
      (|GUESS;ADEguessModGen2|
       (SPADCALL
        (SPADCALL (SPADCALL |partitions| |o| (QREFELT $ 379)) (QREFELT $ 380))
        (QREFELT $ 381))
       (SPADCALL |degrees| |o| (QREFELT $ 434)) $))))) 

(DEFUN |GUESS;shiftHP;SM;111!0| (|z1| $$)
  (PROG (|partitions| $)
    (LETT |partitions| (QREFELT $$ 1) NIL)
    (LETT $ (QREFELT $$ 0) NIL)
    (RETURN
     (PROGN
      (|GUESS;ADEguessStream2| |z1| |partitions|
       (CONS (|function| |GUESS;ShiftSS|) $)
       (SPADCALL
        (SPADCALL (|spadConstant| $ 324)
                  (SPADCALL (|spadConstant| $ 11) (|spadConstant| $ 355)
                            (QREFELT $ 430))
                  (QREFELT $ 431))
        (SPADCALL (|spadConstant| $ 331) (QREFELT $ 432)) (QREFELT $ 433))
       $))))) 

(DEFUN |GUESS;makeEXPRR| (DAX |x| |p| |expr| $)
  (COND ((SPADCALL |p| (QREFELT $ 122)) (|spadConstant| $ 49))
        ('T
         (SPADCALL
          (SPADCALL (SPADCALL (SPADCALL |p| (QREFELT $ 123)) (QREFELT $ 10))
                    (SPADCALL (SPADCALL |p| (QREFELT $ 125)) |x| |expr| DAX)
                    (QREFELT $ 104))
          (|GUESS;makeEXPRR| DAX |x| (SPADCALL |p| (QREFELT $ 127)) |expr| $)
          (QREFELT $ 109))))) 

(DEFUN |GUESS;list2UFPSF| (|list| $)
  (SPADCALL (SPADCALL |list| (QREFELT $ 488)) (QREFELT $ 489))) 

(DEFUN |GUESS;list2UFPSSUPF| (|list| $)
  (PROG (|l2| |s1| |l1| #1=#:G4265 |e| #2=#:G4264)
    (RETURN
     (SEQ
      (LETT |l1|
            (SPADCALL
             (PROGN
              (LETT #2# NIL . #3=(|GUESS;list2UFPSSUPF|))
              (SEQ (LETT |e| NIL . #3#) (LETT #1# |list| . #3#) G190
                   (COND
                    ((OR (ATOM #1#) (PROGN (LETT |e| (CAR #1#) . #3#) NIL))
                     (GO G191)))
                   (SEQ
                    (EXIT
                     (LETT #2# (CONS (SPADCALL |e| (QREFELT $ 410)) #2#)
                           . #3#)))
                   (LETT #1# (CDR #1#) . #3#) (GO G190) G191
                   (EXIT (NREVERSE0 #2#))))
             (QREFELT $ 492))
            . #3#)
      (LETT |s1| (SPADCALL (ELT $ 253) 0 (QREFELT $ 256)) . #3#)
      (LETT |l2|
            (SPADCALL (CONS #'|GUESS;list2UFPSSUPF!0| $) |s1| (QREFELT $ 497))
            . #3#)
      (EXIT (SPADCALL (SPADCALL |l1| |l2| (QREFELT $ 498)) (QREFELT $ 499))))))) 

(DEFUN |GUESS;list2UFPSSUPF!0| (|i| $)
  (PROG (#1=#:G4260)
    (RETURN
     (SPADCALL (|spadConstant| $ 11)
               (SPADCALL (|spadConstant| $ 355)
                         (PROG1 (LETT #1# |i| NIL)
                           (|check-subtype| (>= #1# 0) '(|NonNegativeInteger|)
                                            #1#))
                         (QREFELT $ 494))
               (QREFELT $ 495))))) 

(DEFUN |GUESS;SUPF2SUPSUPF| (|p| $) (SPADCALL (ELT $ 410) |p| (QREFELT $ 503))) 

(DEFUN |GUESS;UFPSF2SUPF| (|f| |deg| $)
  (SPADCALL (SPADCALL |f| |deg| (QREFELT $ 505)) (QREFELT $ 506))) 

(DEFUN |GUESS;getListSUPF| (|s| |deg| $)
  (PROG ()
    (RETURN
     (SPADCALL (CONS #'|GUESS;getListSUPF!0| (VECTOR $ |deg|)) |s|
               (QREFELT $ 510))))) 

(DEFUN |GUESS;getListSUPF!0| (|z1| $$)
  (PROG (|deg| $)
    (LETT |deg| (QREFELT $$ 1) . #1=(|GUESS;getListSUPF|))
    (LETT $ (QREFELT $$ 0) . #1#)
    (RETURN (PROGN (|GUESS;UFPSF2SUPF| |z1| |deg| $))))) 

(DEFUN |GUESS;precCheck| (|list| |resi| |options| |sigma| |bad| $)
  (PROG (#1=#:G4311 |res2| |p2val| |p2| #2=#:G4313 |j| |si| |i| |res1| |gl|
         #3=#:G4312 |cden| |c2| #4=#:G4282 |c1| |pp| |vd| |vi| |order| |j0|
         |svar| |max_ind| |degree_loss| |gl0| |m| |resv| |homo| |homp|)
    (RETURN
     (SEQ
      (EXIT
       (SEQ
        (LETT |homp| (SPADCALL |options| (QREFELT $ 247))
              . #5=(|GUESS;precCheck|))
        (LETT |homo| (COND ((QEQCAR |homp| 1) (QCDR |homp|)) (#6='T 'T)) . #5#)
        (LETT |resv| (SPADCALL |resi| (QREFELT $ 513)) . #5#)
        (LETT |m| (QVSIZE |resv|) . #5#)
        (LETT |gl0| (SPADCALL |list| (QREFELT $ 515)) . #5#)
        (LETT |degree_loss| (COND (|homo| (- |m| 1)) (#6# (- |m| 2))) . #5#)
        (COND
         ((SPADCALL |options| (QREFELT $ 516))
          (LETT |max_ind| (- (- (QVSIZE |gl0|) |degree_loss|) 1) . #5#))
         (#6# (LETT |max_ind| (- |sigma| 1) . #5#)))
        (LETT |svar| (SPADCALL (QREFELT $ 518)) . #5#)
        (LETT |j0| (COND (|homo| 1) (#6# 2)) . #5#) (LETT |order| 0 . #5#)
        (EXIT
         (COND
          ((|domainEqual| (QREFELT $ 6) (|Fraction| (QREFELT $ 7)))
           (SEQ (LETT |gl| |gl0| . #5#)
                (SEQ (LETT |i| 0 . #5#) G190
                     (COND ((QSGREATERP |i| |max_ind|) #7=(GO G191)))
                     (SEQ (LETT |res1| (|spadConstant| $ 48) . #5#)
                          (LETT |cden| (|spadConstant| $ 12) . #5#)
                          (LETT |si| (SPADCALL |i| (QREFELT $ 158)) . #5#)
                          (COND
                           ((NULL |homo|)
                            (LETT |res1|
                                  (SPADCALL
                                   (SPADCALL
                                    (SPADCALL |resv| 1 (QREFELT $ 519)) |svar|
                                    |si| (QREFELT $ 520))
                                   (QREFELT $ 521))
                                  . #5#)))
                          (SEQ (LETT |j| |j0| . #5#) G190
                               (COND ((> |j| |m|) #7#))
                               (SEQ
                                (LETT |p2|
                                      (SPADCALL |resv| |j| (QREFELT $ 519))
                                      . #5#)
                                (LETT |p2val|
                                      (SPADCALL
                                       (SPADCALL |p2| |svar| |si|
                                                 (QREFELT $ 520))
                                       (QREFELT $ 521))
                                      . #5#)
                                (LETT |vi|
                                      (SPADCALL |gl| (+ (- (+ |i| |j|) |j0|) 1)
                                                (QREFELT $ 522))
                                      . #5#)
                                (LETT |vd| (SPADCALL |vi| (QREFELT $ 30))
                                      . #5#)
                                (LETT |pp|
                                      (SPADCALL |cden| |vd| (QREFELT $ 523))
                                      . #5#)
                                (LETT |c1|
                                      (PROG2
                                          (LETT #4#
                                                (SPADCALL |cden| |pp|
                                                          (QREFELT $ 169))
                                                . #5#)
                                          (QCDR #4#)
                                        (|check-union| (QEQCAR #4# 0)
                                                       (QREFELT $ 7) #4#))
                                      . #5#)
                                (LETT |c2|
                                      (PROG2
                                          (LETT #4#
                                                (SPADCALL |vd| |pp|
                                                          (QREFELT $ 169))
                                                . #5#)
                                          (QCDR #4#)
                                        (|check-union| (QEQCAR #4# 0)
                                                       (QREFELT $ 7) #4#))
                                      . #5#)
                                (LETT |res1|
                                      (SPADCALL
                                       (SPADCALL |c2| |res1| (QREFELT $ 165))
                                       (SPADCALL
                                        (SPADCALL |p2val| |c1| (QREFELT $ 165))
                                        (SPADCALL |vi| (QREFELT $ 29))
                                        (QREFELT $ 165))
                                       (QREFELT $ 272))
                                      . #5#)
                                (EXIT
                                 (LETT |cden|
                                       (SPADCALL |cden| |c2| (QREFELT $ 165))
                                       . #5#)))
                               (LETT |j| (+ |j| 1) . #5#) #8=(GO G190) G191
                               (EXIT NIL))
                          (EXIT
                           (COND
                            ((NULL
                              (SPADCALL |res1| (|spadConstant| $ 48)
                                        (QREFELT $ 524)))
                             (COND
                              ((< |i| |sigma|)
                               (PROGN
                                (LETT #1# (CONS 2 "no_solution") . #5#)
                                (GO #1#)))
                              ('T
                               (PROGN
                                (LETT #1# (CONS 1 "reject") . #5#)
                                (GO #1#))))))))
                     (LETT |i| (QSADD1 |i|) . #5#) #8# G191 (EXIT NIL))
                (COND
                 ((NULL (SPADCALL |options| (QREFELT $ 516)))
                  (PROGN (LETT #1# (CONS 0 "good") . #5#) (GO #1#))))
                (EXIT
                 (COND
                  (|bad| (PROGN (LETT #1# (CONS 1 "reject") . #5#) (GO #1#)))
                  (#6#
                   (SEQ
                    (SEQ (LETT |i| 1 . #5#) G190
                         (COND ((QSGREATERP |i| |degree_loss|) #7#))
                         (SEQ
                          (LETT |si|
                                (SPADCALL (+ |i| |max_ind|) (QREFELT $ 158))
                                . #5#)
                          (SEQ (LETT |j| (- |m| |i|) . #5#) G190
                               (COND ((> |j| |m|) #7#))
                               (SEQ
                                (LETT |p2|
                                      (SPADCALL |resv| |j| (QREFELT $ 519))
                                      . #5#)
                                (LETT |p2val|
                                      (SPADCALL
                                       (SPADCALL |p2| |svar| |si|
                                                 (QREFELT $ 520))
                                       (QREFELT $ 521))
                                      . #5#)
                                (EXIT
                                 (COND
                                  ((NULL
                                    (SPADCALL |p2val| (|spadConstant| $ 48)
                                              (QREFELT $ 524)))
                                   (PROGN
                                    (LETT #1# (CONS 0 "good") . #5#)
                                    (GO #1#))))))
                               (LETT |j| (+ |j| 1) . #5#) #8# G191 (EXIT NIL))
                          (LETT |res2| (|spadConstant| $ 47) . #5#)
                          (COND
                           (|homo|
                            (LETT |res2|
                                  (SPADCALL
                                   (SPADCALL
                                    (SPADCALL
                                     (SPADCALL |resv| 1 (QREFELT $ 519)) |svar|
                                     |si| (QREFELT $ 520))
                                    (QREFELT $ 521))
                                   (QREFELT $ 56))
                                  . #5#)))
                          (SEQ (LETT |j| |j0| . #5#)
                               (LETT #3# (- |m| |i|) . #5#) G190
                               (COND ((> |j| #3#) #7#))
                               (SEQ
                                (LETT |p2|
                                      (SPADCALL |resv| |j| (QREFELT $ 519))
                                      . #5#)
                                (LETT |p2val|
                                      (SPADCALL
                                       (SPADCALL |p2| |svar| |si|
                                                 (QREFELT $ 520))
                                       (QREFELT $ 521))
                                      . #5#)
                                (EXIT
                                 (LETT |res2|
                                       (SPADCALL |res2|
                                                 (SPADCALL |p2val|
                                                           (SPADCALL |gl|
                                                                     (+
                                                                      (-
                                                                       (+
                                                                        (+ |i|
                                                                           |max_ind|)
                                                                        |j|)
                                                                       |j0|)
                                                                      1)
                                                                     (QREFELT $
                                                                              522))
                                                           (QREFELT $ 525))
                                                 (QREFELT $ 526))
                                       . #5#)))
                               (LETT |j| (+ |j| 1) . #5#) #8# G191 (EXIT NIL))
                          (EXIT
                           (COND
                            ((NULL
                              (SPADCALL |res2| (|spadConstant| $ 47)
                                        (QREFELT $ 527)))
                             (PROGN
                              (LETT #1# (CONS 1 "reject") . #5#)
                              (GO #1#))))))
                         (LETT |i| (QSADD1 |i|) . #5#) #8# G191 (EXIT NIL))
                    (EXIT
                     (PROGN (LETT #1# (CONS 0 "good") . #5#) (GO #1#)))))))))
          ((|domainEqual| (QREFELT $ 6) (QREFELT $ 7))
           (SEQ (LETT |gl| |gl0| . #5#)
                (SEQ (LETT |i| 0 . #5#) G190
                     (COND ((QSGREATERP |i| |max_ind|) #7#))
                     (SEQ (LETT |res1| (|spadConstant| $ 48) . #5#)
                          (LETT |si| (SPADCALL |i| (QREFELT $ 158)) . #5#)
                          (COND
                           ((NULL |homo|)
                            (LETT |res1|
                                  (SPADCALL
                                   (SPADCALL
                                    (SPADCALL |resv| 1 (QREFELT $ 519)) |svar|
                                    |si| (QREFELT $ 520))
                                   (QREFELT $ 521))
                                  . #5#)))
                          (SEQ (LETT |j| |j0| . #5#) G190
                               (COND ((> |j| |m|) #7#))
                               (SEQ
                                (LETT |p2|
                                      (SPADCALL |resv| |j| (QREFELT $ 519))
                                      . #5#)
                                (LETT |p2val|
                                      (SPADCALL
                                       (SPADCALL |p2| |svar| |si|
                                                 (QREFELT $ 520))
                                       (QREFELT $ 521))
                                      . #5#)
                                (EXIT
                                 (LETT |res1|
                                       (SPADCALL |res1|
                                                 (SPADCALL |p2val|
                                                           (SPADCALL |gl|
                                                                     (+
                                                                      (-
                                                                       (+ |i|
                                                                          |j|)
                                                                       |j0|)
                                                                      1)
                                                                     (QREFELT $
                                                                              529))
                                                           (QREFELT $ 165))
                                                 (QREFELT $ 272))
                                       . #5#)))
                               (LETT |j| (+ |j| 1) . #5#) #8# G191 (EXIT NIL))
                          (EXIT
                           (COND
                            ((NULL
                              (SPADCALL |res1| (|spadConstant| $ 48)
                                        (QREFELT $ 524)))
                             (COND
                              ((< |i| |sigma|)
                               (PROGN
                                (LETT #1# (CONS 2 "no_solution") . #5#)
                                (GO #1#)))
                              ('T
                               (PROGN
                                (LETT #1# (CONS 1 "reject") . #5#)
                                (GO #1#))))))))
                     (LETT |i| (QSADD1 |i|) . #5#) #8# G191 (EXIT NIL))
                (COND
                 ((NULL (SPADCALL |options| (QREFELT $ 516)))
                  (PROGN (LETT #1# (CONS 0 "good") . #5#) (GO #1#))))
                (EXIT
                 (COND
                  (|bad| (PROGN (LETT #1# (CONS 1 "reject") . #5#) (GO #1#)))
                  (#6#
                   (SEQ
                    (SEQ (LETT |i| 1 . #5#) G190
                         (COND ((QSGREATERP |i| |degree_loss|) #7#))
                         (SEQ
                          (LETT |si|
                                (SPADCALL (+ |i| |max_ind|) (QREFELT $ 158))
                                . #5#)
                          (SEQ (LETT |j| (- |m| |i|) . #5#) G190
                               (COND ((> |j| |m|) #7#))
                               (SEQ
                                (LETT |p2|
                                      (SPADCALL |resv| |j| (QREFELT $ 519))
                                      . #5#)
                                (LETT |p2val|
                                      (SPADCALL
                                       (SPADCALL |p2| |svar| |si|
                                                 (QREFELT $ 520))
                                       (QREFELT $ 521))
                                      . #5#)
                                (EXIT
                                 (COND
                                  ((NULL
                                    (SPADCALL |p2val| (|spadConstant| $ 48)
                                              (QREFELT $ 524)))
                                   (PROGN
                                    (LETT #1# (CONS 0 "good") . #5#)
                                    (GO #1#))))))
                               (LETT |j| (+ |j| 1) . #5#) #8# G191 (EXIT NIL))
                          (LETT |res2| (|spadConstant| $ 48) . #5#)
                          (COND
                           (|homo|
                            (LETT |res2|
                                  (SPADCALL
                                   (SPADCALL
                                    (SPADCALL |resv| 1 (QREFELT $ 519)) |svar|
                                    |si| (QREFELT $ 520))
                                   (QREFELT $ 521))
                                  . #5#)))
                          (SEQ (LETT |j| |j0| . #5#)
                               (LETT #2# (- |m| |i|) . #5#) G190
                               (COND ((> |j| #2#) #7#))
                               (SEQ
                                (LETT |p2|
                                      (SPADCALL |resv| |j| (QREFELT $ 519))
                                      . #5#)
                                (LETT |p2val|
                                      (SPADCALL
                                       (SPADCALL |p2| |svar| |si|
                                                 (QREFELT $ 520))
                                       (QREFELT $ 521))
                                      . #5#)
                                (EXIT
                                 (LETT |res2|
                                       (SPADCALL |res2|
                                                 (SPADCALL |p2val|
                                                           (SPADCALL |gl|
                                                                     (+
                                                                      (-
                                                                       (+
                                                                        (+ |i|
                                                                           |max_ind|)
                                                                        |j|)
                                                                       |j0|)
                                                                      1)
                                                                     (QREFELT $
                                                                              529))
                                                           (QREFELT $ 165))
                                                 (QREFELT $ 272))
                                       . #5#)))
                               (LETT |j| (+ |j| 1) . #5#) #8# G191 (EXIT NIL))
                          (EXIT
                           (COND
                            ((NULL
                              (SPADCALL |res2| (|spadConstant| $ 48)
                                        (QREFELT $ 524)))
                             (PROGN
                              (LETT #1# (CONS 1 "reject") . #5#)
                              (GO #1#))))))
                         (LETT |i| (QSADD1 |i|) . #5#) #8# G191 (EXIT NIL))
                    (EXIT
                     (PROGN (LETT #1# (CONS 0 "good") . #5#) (GO #1#)))))))))
          (#6# (|error| "F must be S or Fraction(S)"))))))
      #1# (EXIT #1#))))) 

(DEFUN |GUESS;checkInterpolant| (|list| |o| |resi| D |options| |sigma| $)
  (PROG (#1=#:G4361 #2=#:G4354 |order| |c| |d| |dmax| |resiSUPF| #3=#:G4365 |i|
         #4=#:G4364 |testList| |flist| #5=#:G4343 #6=#:G4363 |maxPow| |maxP|
         |len| |reject_one_term| #7=#:G4322 |nonZeroCoefficients| #8=#:G4362)
    (RETURN
     (SEQ
      (EXIT
       (SEQ
        (COND
         ((SPADCALL |options| (QREFELT $ 67))
          (SPADCALL "Guess: checking solution" (QREFELT $ 78))))
        (LETT |nonZeroCoefficients| (CONS 2 "none")
              . #9=(|GUESS;checkInterpolant|))
        (LETT |reject_one_term| 'NIL . #9#)
        (SEQ
         (EXIT
          (SEQ (LETT |i| 1 . #9#) (LETT #8# (LENGTH |resi|) . #9#) G190
               (COND ((QSGREATERP |i| #8#) #10=(GO G191)))
               (SEQ
                (EXIT
                 (COND
                  ((NULL
                    (SPADCALL (SPADCALL |resi| |i| (QREFELT $ 530))
                              (QREFELT $ 531)))
                   (COND
                    ((QEQCAR |nonZeroCoefficients| 2)
                     (LETT |nonZeroCoefficients| (CONS 0 "one") . #9#))
                    ('T
                     (SEQ (LETT |nonZeroCoefficients| (CONS 1 "several") . #9#)
                          (EXIT
                           (PROGN (LETT #7# |$NoValue| . #9#) (GO #7#))))))))))
               (LETT |i| (QSADD1 |i|) . #9#) #11=(GO G190) G191 (EXIT NIL)))
         #7# (EXIT #7#))
        (COND
         ((NULL (QEQCAR |nonZeroCoefficients| 1))
          (COND
           ((NULL (SPADCALL (ELT $ 536) |list| (QREFELT $ 83)))
            (SEQ (LETT |reject_one_term| 'T . #9#)
                 (EXIT
                  (COND
                   ((SPADCALL |options| (QREFELT $ 67))
                    (SPADCALL "Guess: encountered single-term solution"
                              (QREFELT $ 78))))))))))
        (LETT |len| (LENGTH |list|) . #9#)
        (LETT |maxP| (SPADCALL |options| (QREFELT $ 245)) . #9#)
        (COND ((QEQCAR |maxP| 0) (LETT |maxPow| (QCDR |maxP|) . #9#))
              (#12='T (LETT |maxPow| (+ |len| 2) . #9#)))
        (COND
         ((EQL |maxPow| 1)
          (COND
           ((EQUAL (QVELT D 5) '|shiftHP|)
            (EXIT
             (|GUESS;precCheck| |list| |resi| |options| |sigma|
              |reject_one_term| $))))))
        (LETT |flist|
              (PROGN
               (LETT #6# NIL . #9#)
               (SEQ (LETT |i| 1 . #9#) G190 (COND ((QSGREATERP |i| |o|) #10#))
                    (SEQ
                     (EXIT
                      (COND
                       ((COND
                         ((SPADCALL (SPADCALL |resi| |i| (QREFELT $ 530))
                                    (QREFELT $ 531))
                          'NIL)
                         (#12# 'T))
                        (LETT #6#
                              (CONS
                               (PROG1 (LETT #5# |i| . #9#)
                                 (|check-subtype| (> #5# 0)
                                                  '(|PositiveInteger|) #5#))
                               #6#)
                              . #9#)))))
                    (LETT |i| (QSADD1 |i|) . #9#) #11# G191
                    (EXIT (NREVERSE0 #6#))))
              . #9#)
        (LETT |testList|
              (SPADCALL (|GUESS;list2UFPSSUPF| |list| $)
                        (SPADCALL |flist| (QVELT D 3)))
              . #9#)
        (LETT |resiSUPF|
              (PROGN
               (LETT #4# NIL . #9#)
               (SEQ (LETT |i| NIL . #9#) (LETT #3# |flist| . #9#) G190
                    (COND
                     ((OR (ATOM #3#) (PROGN (LETT |i| (CAR #3#) . #9#) NIL))
                      #10#))
                    (SEQ
                     (EXIT
                      (LETT #4#
                            (CONS
                             (|GUESS;SUPF2SUPSUPF|
                              (|GUESS;SUPS2SUPF|
                               (SPADCALL |resi| |i| (QREFELT $ 530)) $)
                              $)
                             #4#)
                            . #9#)))
                    (LETT #3# (CDR #3#) . #9#) #11# G191
                    (EXIT (NREVERSE0 #4#))))
              . #9#)
        (LETT |order| 0 . #9#)
        (LETT |dmax| (SPADCALL 10 (LENGTH |list|) (QREFELT $ 537)) . #9#)
        (SEQ
         (EXIT
          (SEQ (LETT |d| 0 . #9#) G190 NIL
               (SEQ
                (COND
                 ((NULL (SPADCALL |options| (QREFELT $ 516)))
                  (COND
                   ((EQL |d| |sigma|)
                    (PROGN (LETT #1# (CONS 0 "good") . #9#) (GO #1#))))))
                (COND
                 (|reject_one_term|
                  (COND
                   ((EQL |d| |sigma|)
                    (PROGN (LETT #1# (CONS 1 "reject") . #9#) (GO #1#))))))
                (LETT |c|
                      (SPADCALL (QVELT D 8) |testList| |d|
                                (SPADCALL |resiSUPF| (QREFELT $ 540))
                                (QREFELT $ 541))
                      . #9#)
                (COND
                 ((NULL (SPADCALL |c| (QREFELT $ 542)))
                  (SEQ (LETT |order| |d| . #9#)
                       (EXIT (PROGN (LETT #2# |$NoValue| . #9#) (GO #2#))))))
                (EXIT
                 (COND
                  ((< |dmax| |d|)
                   (SEQ
                    (SPADCALL "bailing out from checkInterpolant"
                              (QREFELT $ 543))
                    (SPADCALL
                     "please report the input to fricas-devel@googlegroups.com"
                     (QREFELT $ 543))
                    (LETT |order| |d| . #9#)
                    (EXIT (PROGN (LETT #2# |$NoValue| . #9#) (GO #2#))))))))
               (LETT |d| (QSADD1 |d|) . #9#) #11# G191 (EXIT NIL)))
         #2# (EXIT #2#))
        (EXIT
         (COND
          ((< |order| |sigma|)
           (SEQ
            (SPADCALL
             (SPADCALL "Order too low: " (SPADCALL |order| (QREFELT $ 544))
                       (QREFELT $ 70))
             (QREFELT $ 543))
            (SPADCALL
             (SPADCALL "sigma: " (SPADCALL |sigma| (QREFELT $ 544))
                       (QREFELT $ 70))
             (QREFELT $ 543))
            (EXIT (PROGN (LETT #1# (CONS 2 "no_solution") . #9#) (GO #1#)))))
          ((SPADCALL |c| (QREFELT $ 545))
           (SEQ
            (COND
             ((SPADCALL |options| (QREFELT $ 67))
              (SEQ
               (SPADCALL
                (SPADCALL "Proposed solution does not fit coefficient "
                          (SPADCALL |order| (QREFELT $ 544)) (QREFELT $ 70))
                (QREFELT $ 543))
               (EXIT
                (SPADCALL
                 (SPADCALL "sigma: " (SPADCALL |sigma| (QREFELT $ 544))
                           (QREFELT $ 70))
                 (QREFELT $ 543))))))
            (EXIT (PROGN (LETT #1# (CONS 1 "reject") . #9#) (GO #1#)))))
          (#12# (CONS 0 "good"))))))
      #1# (EXIT #1#))))) 

(DEFUN |GUESS;wrapInterpolant|
       (|resi| |exprList| |initials| D |op| |options| $)
  (PROG (|ex| #1=#:G4397 |p| #2=#:G4398 |e| #3=#:G4396 |eq| #4=#:G4394
         #5=#:G4395 #6=#:G4393 |dk|)
    (RETURN
     (SEQ
      (LETT |dk| (SPADCALL |options| (QREFELT $ 378))
            . #7=(|GUESS;wrapInterpolant|))
      (COND
       ((OR (EQUAL |dk| '|displayAsGF|) (EQUAL |dk| '|displayAsEQ|))
        (EXIT
         (SEQ
          (LETT |ex|
                (PROGN
                 (LETT #6# NIL . #7#)
                 (SEQ (LETT |e| NIL . #7#) (LETT #5# |exprList| . #7#)
                      (LETT |p| NIL . #7#) (LETT #4# |resi| . #7#) G190
                      (COND
                       ((OR (ATOM #4#) (PROGN (LETT |p| (CAR #4#) . #7#) NIL)
                            (ATOM #5#) (PROGN (LETT |e| (CAR #5#) . #7#) NIL))
                        #8=(GO G191)))
                      (SEQ
                       (EXIT
                        (LETT #6#
                              (CONS
                               (|GUESS;makeEXPRR| (QVELT D 9)
                                (SPADCALL |options| (QREFELT $ 546))
                                (|GUESS;SUPS2SUPF| |p| $) |e| $)
                               #6#)
                              . #7#)))
                      (LETT #4# (PROG1 (CDR #4#) (LETT #5# (CDR #5#) . #7#))
                            . #7#)
                      #9=(GO G190) G191 (EXIT (NREVERSE0 #6#))))
                . #7#)
          (LETT |eq|
                (SPADCALL (SPADCALL (ELT $ 109) |ex| (QREFELT $ 280))
                          (QREFELT $ 52))
                . #7#)
          (EXIT
           (COND ((EQUAL |dk| '|displayAsEQ|) |eq|)
                 (#10='T
                  (SPADCALL |op| (SPADCALL |options| (QREFELT $ 546))
                            (SPADCALL |options| (QREFELT $ 66)) |eq|
                            (|GUESS;getVariables| |initials| $)
                            (SPADCALL (QREFELT $ 10)
                                      (SPADCALL |initials| (QREFELT $ 488))
                                      (QREFELT $ 549))
                            (QREFELT $ 552)))))))))
      (EXIT
       (COND
        ((EQUAL |dk| '|displayAsRec|)
         (SEQ
          (LETT |ex|
                (PROGN
                 (LETT #3# NIL . #7#)
                 (SEQ (LETT |e| NIL . #7#) (LETT #2# |exprList| . #7#)
                      (LETT |p| NIL . #7#) (LETT #1# |resi| . #7#) G190
                      (COND
                       ((OR (ATOM #1#) (PROGN (LETT |p| (CAR #1#) . #7#) NIL)
                            (ATOM #2#) (PROGN (LETT |e| (CAR #2#) . #7#) NIL))
                        #8#))
                      (SEQ
                       (EXIT
                        (LETT #3#
                              (CONS
                               (|GUESS;makeEXPRR| (QVELT D 9)
                                (SPADCALL |options| (QREFELT $ 66))
                                (|GUESS;SUPS2SUPF| |p| $) |e| $)
                               #3#)
                              . #7#)))
                      (LETT #1# (PROG1 (CDR #1#) (LETT #2# (CDR #2#) . #7#))
                            . #7#)
                      #9# G191 (EXIT (NREVERSE0 #3#))))
                . #7#)
          (EXIT
           (SPADCALL |op| (SPADCALL |options| (QREFELT $ 66))
                     (SPADCALL (SPADCALL (ELT $ 109) |ex| (QREFELT $ 280))
                               (QREFELT $ 52))
                     (|GUESS;getVariables| |initials| $)
                     (SPADCALL (QREFELT $ 10)
                               (SPADCALL |initials| (QREFELT $ 488))
                               (QREFELT $ 549))
                     (QREFELT $ 553)))))
        (#10# (|error| "wrapInterpolant: unsupported display kind")))))))) 

(DEFUN |GUESS;guessInterpolateModular|
       (|lists| |degs| |o| |degreeLoss| |guessDegree| D |options| $)
  (PROG (|check| |i| #1=#:G4465 |deg| #2=#:G4464 #3=#:G4463 |maxD| #4=#:G4411
         #5=#:G4461 |del| |leadingZeros| #6=#:G4462 |el| |sigma| #7=#:G4409
         |list|)
    (RETURN
     (SEQ
      (EXIT
       (SEQ
        (LETT |list| (|SPADfirst| |lists|)
              . #8=(|GUESS;guessInterpolateModular|))
        (LETT |sigma|
              (PROG1 (LETT #7# (- (LENGTH |list|) |degreeLoss|) . #8#)
                (|check-subtype| (>= #7# 0) '(|NonNegativeInteger|) #7#))
              . #8#)
        (LETT |leadingZeros| 0 . #8#)
        (SEQ (LETT |el| NIL . #8#) (LETT #6# |list| . #8#) G190
             (COND
              ((OR (ATOM #6#) (PROGN (LETT |el| (CAR #6#) . #8#) NIL)
                   (NULL (SPADCALL |el| (QREFELT $ 536))))
               #9=(GO G191)))
             (SEQ (EXIT (LETT |leadingZeros| (+ |leadingZeros| 1) . #8#)))
             (LETT #6# (CDR #6#) . #8#) #10=(GO G190) G191 (EXIT NIL))
        (COND
         ((< |degreeLoss| |leadingZeros|)
          (SEQ (LETT |del| (- |leadingZeros| |degreeLoss|) . #8#)
               (EXIT
                (COND
                 ((< |guessDegree| |del|)
                  (PROGN (LETT #5# (CONS 1 'NIL) . #8#) (GO #5#)))
                 (#11='T
                  (LETT |guessDegree|
                        (PROG1 (LETT #4# (- |guessDegree| |del|) . #8#)
                          (|check-subtype| (>= #4# 0) '(|NonNegativeInteger|)
                                           #4#))
                        . #8#)))))))
        (COND
         ((NULL (SPADCALL |options| (QREFELT $ 554)))
          (SEQ (LETT |maxD| (SPADCALL |options| (QREFELT $ 177)) . #8#)
               (EXIT
                (COND
                 ((QEQCAR |maxD| 0)
                  (COND
                   ((< (* (QCDR |maxD|) |o|) |guessDegree|)
                    (LETT |degs|
                          (PROGN
                           (LETT #3# NIL . #8#)
                           (SEQ (LETT |i| 1 . #8#) G190
                                (COND ((QSGREATERP |i| |o|) #9#))
                                (SEQ
                                 (EXIT
                                  (LETT #3# (CONS (QCDR |maxD|) #3#) . #8#)))
                                (LETT |i| (QSADD1 |i|) . #8#) #10# G191
                                (EXIT (NREVERSE0 #3#))))
                          . #8#))
                   (#11#
                    (SEQ (LETT |deg| (DIVIDE2 |guessDegree| |o|) . #8#)
                         (EXIT
                          (LETT |degs|
                                (PROGN
                                 (LETT #2# NIL . #8#)
                                 (SEQ (LETT |i| 1 . #8#) G190
                                      (COND ((QSGREATERP |i| |o|) #9#))
                                      (SEQ
                                       (EXIT
                                        (LETT #2#
                                              (CONS
                                               (COND
                                                ((< (QCDR |deg|) |i|)
                                                 (QCAR |deg|))
                                                ('T (+ (QCAR |deg|) 1)))
                                               #2#)
                                              . #8#)))
                                      (LETT |i| (QSADD1 |i|) . #8#) #10# G191
                                      (EXIT (NREVERSE0 #2#))))
                                . #8#))))))
                 (#11#
                  (SEQ (LETT |deg| (DIVIDE2 |guessDegree| |o|) . #8#)
                       (EXIT
                        (LETT |degs|
                              (PROGN
                               (LETT #1# NIL . #8#)
                               (SEQ (LETT |i| 1 . #8#) G190
                                    (COND ((QSGREATERP |i| |o|) #9#))
                                    (SEQ
                                     (EXIT
                                      (LETT #1#
                                            (CONS
                                             (COND
                                              ((< (QCDR |deg|) |i|)
                                               (QCAR |deg|))
                                              ('T (+ (QCAR |deg|) 1)))
                                             #1#)
                                            . #8#)))
                                    (LETT |i| (QSADD1 |i|) . #8#) #10# G191
                                    (EXIT (NREVERSE0 #1#))))
                              . #8#)))))))))
        (COND
         ((QEQCAR (SPADCALL |options| (QREFELT $ 556)) 1)
          (SEQ
           (LETT |check|
                 (CONS #'|GUESS;guessInterpolateModular!0|
                       (VECTOR $ |sigma| |options| D |o| |list|))
                 . #8#)
           (EXIT
            (LETT |check|
                  (SPADCALL |check| |lists| (QVELT D 5) (QVELT D 6) |sigma|
                            (SPADCALL |o| (QVELT D 2)) (QREFELT $ 560))
                  . #8#))))
         ((QEQCAR (SPADCALL |options| (QREFELT $ 556)) 0)
          (SEQ
           (COND
            ((SPADCALL |options| (QREFELT $ 67))
             (SPADCALL "Guess: skipping checks" (QREFELT $ 78))))
           (EXIT
            (LETT |check| (LIST #'|GUESS;guessInterpolateModular!1|) . #8#))))
         (#11#
          (LETT |check|
                (CONS #'|GUESS;guessInterpolateModular!2|
                      (VECTOR $ |sigma| |options| D |o| |list|))
                . #8#)))
        (EXIT
         (SPADCALL |lists| |degs| (QVELT D 5) (QVELT D 6) |sigma|
                   (SPADCALL |o| (QVELT D 2)) |check| (QREFELT $ 562)))))
      #5# (EXIT #5#))))) 

(DEFUN |GUESS;guessInterpolateModular!2| (|x| $$)
  (PROG (|list| |o| D |options| |sigma| $)
    (LETT |list| (QREFELT $$ 5) . #1=(|GUESS;guessInterpolateModular|))
    (LETT |o| (QREFELT $$ 4) . #1#)
    (LETT D (QREFELT $$ 3) . #1#)
    (LETT |options| (QREFELT $$ 2) . #1#)
    (LETT |sigma| (QREFELT $$ 1) . #1#)
    (LETT $ (QREFELT $$ 0) . #1#)
    (RETURN
     (PROGN (|GUESS;checkInterpolant| |list| |o| |x| D |options| |sigma| $))))) 

(DEFUN |GUESS;guessInterpolateModular!1| (|x| $$) (CONS 0 "good")) 

(DEFUN |GUESS;guessInterpolateModular!0| (|x| $$)
  (PROG (|list| |o| D |options| |sigma| $)
    (LETT |list| (QREFELT $$ 5) . #1=(|GUESS;guessInterpolateModular|))
    (LETT |o| (QREFELT $$ 4) . #1#)
    (LETT D (QREFELT $$ 3) . #1#)
    (LETT |options| (QREFELT $$ 2) . #1#)
    (LETT |sigma| (QREFELT $$ 1) . #1#)
    (LETT $ (QREFELT $$ 0) . #1#)
    (RETURN
     (PROGN (|GUESS;checkInterpolant| |list| |o| |x| D |options| |sigma| $))))) 

(DEFUN |GUESS;guessInterpolateFFFG|
       (|lists| |degs| |o| |guessDegree| D |options| $)
  (PROG (#1=#:G4544 |j| |c| |cl| #2=#:G4560 #3=#:G4558 |i1| #4=#:G4559 |i2|
         |Mr| |m| |rl| |ce| #5=#:G4557 |i| M |vguessListF| |vguessList|
         |guessPolys| #6=#:G4528 |guessList| |guessS| |sumEta| |eta| #7=#:G4556
         |deg| #8=#:G4489 #9=#:G4555 #10=#:G4479 #11=#:G4554 |maxD| #12=#:G4468
         #13=#:G4553 |d| #14=#:G4552 |list|)
    (RETURN
     (SEQ
      (LETT |list| (|SPADfirst| |lists|) . #15=(|GUESS;guessInterpolateFFFG|))
      (COND
       ((SPADCALL |options| (QREFELT $ 67))
        (SPADCALL "Guess: using FFFG" (QREFELT $ 78))))
      (COND
       ((SPADCALL |options| (QREFELT $ 554))
        (SEQ
         (LETT |eta|
               (PROGN
                (LETT #14# NIL . #15#)
                (SEQ (LETT |d| NIL . #15#) (LETT #13# |degs| . #15#) G190
                     (COND
                      ((OR (ATOM #13#)
                           (PROGN (LETT |d| (CAR #13#) . #15#) NIL))
                       #16=(GO G191)))
                     (SEQ
                      (EXIT
                       (LETT #14#
                             (CONS
                              (PROG1 (LETT #12# |d| . #15#)
                                (|check-subtype| (>= #12# 0)
                                                 '(|NonNegativeInteger|) #12#))
                              #14#)
                             . #15#)))
                     (LETT #13# (CDR #13#) . #15#) #17=(GO G190) G191
                     (EXIT (NREVERSE0 #14#))))
               . #15#)
         (EXIT
          (SPADCALL |eta| 1 (+ (SPADCALL |eta| 1 (QREFELT $ 563)) 1)
                    (QREFELT $ 564)))))
       (#18='T
        (SEQ (LETT |maxD| (SPADCALL |options| (QREFELT $ 177)) . #15#)
             (EXIT
              (COND
               ((QEQCAR |maxD| 0)
                (COND
                 ((< (* (QCDR |maxD|) |o|) |guessDegree|)
                  (LETT |eta|
                        (PROGN
                         (LETT #11# NIL . #15#)
                         (SEQ (LETT |i| 1 . #15#) G190
                              (COND ((QSGREATERP |i| |o|) #16#))
                              (SEQ
                               (EXIT
                                (LETT #11#
                                      (CONS
                                       (COND ((< |i| |o|) (+ (QCDR |maxD|) 1))
                                             ('T (QCDR |maxD|)))
                                       #11#)
                                      . #15#)))
                              (LETT |i| (QSADD1 |i|) . #15#) #17# G191
                              (EXIT (NREVERSE0 #11#))))
                        . #15#))
                 (#18#
                  (SEQ
                   (LETT |deg|
                         (DIVIDE2
                          (PROG1 (LETT #10# (- (+ |guessDegree| |o|) 1) . #15#)
                            (|check-subtype| (>= #10# 0)
                                             '(|NonNegativeInteger|) #10#))
                          |o|)
                         . #15#)
                   (EXIT
                    (LETT |eta|
                          (PROGN
                           (LETT #9# NIL . #15#)
                           (SEQ (LETT |i| 1 . #15#) G190
                                (COND ((QSGREATERP |i| |o|) #16#))
                                (SEQ
                                 (EXIT
                                  (LETT #9#
                                        (CONS
                                         (COND
                                          ((< (QCDR |deg|) |i|) (QCAR |deg|))
                                          ('T (+ (QCAR |deg|) 1)))
                                         #9#)
                                        . #15#)))
                                (LETT |i| (QSADD1 |i|) . #15#) #17# G191
                                (EXIT (NREVERSE0 #9#))))
                          . #15#))))))
               (#18#
                (SEQ
                 (LETT |deg|
                       (DIVIDE2
                        (PROG1 (LETT #8# (- (+ |guessDegree| |o|) 1) . #15#)
                          (|check-subtype| (>= #8# 0) '(|NonNegativeInteger|)
                                           #8#))
                        |o|)
                       . #15#)
                 (EXIT
                  (LETT |eta|
                        (PROGN
                         (LETT #7# NIL . #15#)
                         (SEQ (LETT |i| 1 . #15#) G190
                              (COND ((QSGREATERP |i| |o|) #16#))
                              (SEQ
                               (EXIT
                                (LETT #7#
                                      (CONS
                                       (COND
                                        ((< (QCDR |deg|) |i|) (QCAR |deg|))
                                        ('T (+ (QCAR |deg|) 1)))
                                       #7#)
                                      . #15#)))
                              (LETT |i| (QSADD1 |i|) . #15#) #17# G191
                              (EXIT (NREVERSE0 #7#))))
                        . #15#)))))))))
      (LETT |sumEta| (SPADCALL (ELT $ 257) |eta| (QREFELT $ 569)) . #15#)
      (LETT |guessS| (SPADCALL (|GUESS;list2UFPSF| |list| $) (QVELT D 1))
            . #15#)
      (LETT |guessList|
            (SPADCALL
             (SPADCALL (SPADCALL |guessS| |o| (QREFELT $ 570)) (QREFELT $ 571))
             (QREFELT $ 572))
            . #15#)
      (LETT |guessPolys|
            (|GUESS;getListSUPF| |guessList|
             (PROG1 (LETT #6# (- |sumEta| 1) . #15#)
               (|check-subtype| (>= #6# 0) '(|NonNegativeInteger|) #6#))
             $)
            . #15#)
      (COND
       ((|domainEqual| (QREFELT $ 6) (QREFELT $ 7))
        (SEQ (LETT |vguessList| (SPADCALL |guessPolys| (QREFELT $ 513)) . #15#)
             (EXIT
              (LETT M
                    (SPADCALL (SPADCALL |sumEta| (QVELT D 10)) (QVELT D 7)
                              |vguessList| |eta| (QREFELT $ 574))
                    . #15#))))
       ((|domainEqual| (QREFELT $ 6) (|Fraction| (QREFELT $ 7)))
        (SEQ
         (LETT |vguessListF| (SPADCALL |guessPolys| (QREFELT $ 576)) . #15#)
         (EXIT
          (LETT M
                (SPADCALL (SPADCALL |sumEta| (QVELT D 10)) (QVELT D 7)
                          |vguessListF| |eta| (QREFELT $ 578))
                . #15#))))
       (#18#
        (|error|
         "Guess: type parameter F should be either equal to S or equal                         to Fraction S")))
      (LETT |rl| NIL . #15#)
      (SEQ (LETT |i| 1 . #15#) (LETT #5# (SPADCALL M (QREFELT $ 579)) . #15#)
           G190 (COND ((QSGREATERP |i| #5#) #16#))
           (SEQ
            (LETT |ce|
                  (SPADCALL (SPADCALL M |i| (QREFELT $ 580)) (QREFELT $ 581))
                  . #15#)
            (EXIT
             (COND
              ((QEQCAR
                (|GUESS;checkInterpolant| |list| |o|
                 (SPADCALL (SPADCALL M |i| (QREFELT $ 580)) (QREFELT $ 581)) D
                 |options| |guessDegree| $)
                0)
               (LETT |rl| (CONS |i| |rl|) . #15#)))))
           (LETT |i| (QSADD1 |i|) . #15#) #17# G191 (EXIT NIL))
      (EXIT
       (COND ((NULL |rl|) (MAKE-ARRAY 0))
             (#18#
              (SEQ (LETT |rl| (NREVERSE |rl|) . #15#)
                   (LETT |m| (QVSIZE M) . #15#)
                   (LETT |Mr|
                         (SPADCALL |m| (LENGTH |rl|) (|spadConstant| $ 582)
                                   (QREFELT $ 583))
                         . #15#)
                   (SEQ (LETT |i2| NIL . #15#) (LETT #4# |rl| . #15#)
                        (LETT |i1| 1 . #15#) (LETT #3# (LENGTH |rl|) . #15#)
                        G190
                        (COND
                         ((OR (QSGREATERP |i1| #3#) (ATOM #4#)
                              (PROGN (LETT |i2| (CAR #4#) . #15#) NIL))
                          #16#))
                        (SEQ
                         (COND
                          ((|HasCategory| (QREFELT $ 7) '(|Field|))
                           (SEQ (LETT |c| (|spadConstant| $ 48) . #15#)
                                (EXIT
                                 (SEQ (LETT |j| 1 . #15#) G190
                                      (COND
                                       ((OR (QSGREATERP |j| |m|)
                                            (NULL
                                             (SPADCALL |c| (QREFELT $ 166))))
                                        #16#))
                                      (SEQ
                                       (EXIT
                                        (LETT |c|
                                              (SPADCALL
                                               (SPADCALL M |j| |i2|
                                                         (QREFELT $ 584))
                                               (QREFELT $ 162))
                                              . #15#)))
                                      (LETT |j| (QSADD1 |j|) . #15#) #17# G191
                                      (EXIT NIL)))))
                          ('T
                           (SEQ
                            (LETT |cl|
                                  (PROGN
                                   (LETT #2# NIL . #15#)
                                   (SEQ (LETT |j| 1 . #15#) G190
                                        (COND ((QSGREATERP |j| |m|) #16#))
                                        (SEQ
                                         (EXIT
                                          (LETT #2#
                                                (CONS
                                                 (SPADCALL
                                                  (SPADCALL M |j| |i2|
                                                            (QREFELT $ 584))
                                                  (QREFELT $ 585))
                                                 #2#)
                                                . #15#)))
                                        (LETT |j| (QSADD1 |j|) . #15#) #17#
                                        G191 (EXIT (NREVERSE0 #2#))))
                                  . #15#)
                            (EXIT
                             (LETT |c| (SPADCALL |cl| (QREFELT $ 586))
                                   . #15#)))))
                         (EXIT
                          (SEQ (LETT |j| 1 . #15#) G190
                               (COND ((QSGREATERP |j| |m|) #16#))
                               (SEQ
                                (EXIT
                                 (SPADCALL |Mr| |j| |i1|
                                           (PROG2
                                               (LETT #1#
                                                     (SPADCALL
                                                      (SPADCALL M |j| |i2|
                                                                (QREFELT $
                                                                         584))
                                                      |c| (QREFELT $ 587))
                                                     . #15#)
                                               (QCDR #1#)
                                             (|check-union| (QEQCAR #1# 0)
                                                            (|SparseUnivariatePolynomial|
                                                             (QREFELT $ 7))
                                                            #1#))
                                           (QREFELT $ 588))))
                               (LETT |j| (QSADD1 |j|) . #15#) #17# G191
                               (EXIT NIL))))
                        (LETT |i1|
                              (PROG1 (QSADD1 |i1|) (LETT #4# (CDR #4#) . #15#))
                              . #15#)
                        #17# G191 (EXIT NIL))
                   (EXIT |Mr|))))))))) 

(DEFUN |GUESS;guessInterpolate3|
       (|lists| |o| |degreeLoss| |guessDegree| D |options| |vs| $)
  (PROG ()
    (RETURN
     (SEQ
      (SPADCALL
       (CONS #'|GUESS;guessInterpolate3!1|
             (VECTOR |options| D |guessDegree| |degreeLoss| |o| |lists| $
                     |vs|))
       (QREFELT $ 603)))))) 

(DEFUN |GUESS;guessInterpolate3!1| ($$)
  (PROG (|vs| $ |lists| |o| |degreeLoss| |guessDegree| D |options|)
    (LETT |vs| (QREFELT $$ 7) . #1=(|GUESS;guessInterpolate3|))
    (LETT $ (QREFELT $$ 6) . #1#)
    (LETT |lists| (QREFELT $$ 5) . #1#)
    (LETT |o| (QREFELT $$ 4) . #1#)
    (LETT |degreeLoss| (QREFELT $$ 3) . #1#)
    (LETT |guessDegree| (QREFELT $$ 2) . #1#)
    (LETT D (QREFELT $$ 1) . #1#)
    (LETT |options| (QREFELT $$ 0) . #1#)
    (RETURN
     (PROGN
      (PROG (|degs| M0 #2=#:G4577 M)
        (RETURN
         (SEQ
          (EXIT
           (COND
            ((OR (SPADCALL |vs| (QREFELT $ 589))
                 (SPADCALL |vs| (QREFELT $ 592)))
             (SPADCALL (QREFELT $ 591)))
            ('T
             (SEQ (LETT |degs| (SPADCALL |vs| (QREFELT $ 593)) NIL)
                  (LETT M0
                        (|GUESS;guessInterpolateModular| |lists| |degs| |o|
                         |degreeLoss| |guessDegree| D |options| $)
                        NIL)
                  (LETT M
                        (COND
                         ((QEQCAR M0 1)
                          (SEQ
                           (COND
                            ((QCDR M0)
                             (COND
                              ((SPADCALL (CONS #'|GUESS;guessInterpolate3!0| $)
                                         |degs| (QREFELT $ 599))
                               (EXIT
                                (|GUESS;guessInterpolateFFFG| |lists| |degs|
                                 |o| |guessDegree| D |options| $))))))
                           (EXIT
                            (PROGN
                             (LETT #2#
                                   (|GUESS;guessInterpolate3| |lists| |o|
                                    |degreeLoss| |guessDegree| D |options|
                                    (SPADCALL |vs| (QREFELT $ 600)) $)
                                   NIL)
                             (GO #2#)))))
                         ('T (QCDR M0)))
                        NIL)
                  (EXIT
                   (SPADCALL M
                             (|GUESS;guessInterpolate3| |lists| |o|
                              |degreeLoss| |guessDegree| D |options|
                              (SPADCALL |vs| (QREFELT $ 600)) $)
                             (QREFELT $ 601)))))))
          #2# (EXIT #2#)))))))) 

(DEFUN |GUESS;guessInterpolate3!0| (|x| $)
  (COND
   ((SPADCALL |x| (|spadConstant| $ 273) (QREFELT $ 218))
    (|spadConstant| $ 596))
   ('T (|spadConstant| $ 597)))) 

(DEFUN |GUESS;listDecr| (|l| $)
  (SPADCALL (CONS #'|GUESS;listDecr!0| $) |l| (QREFELT $ 606))) 

(DEFUN |GUESS;listDecr!0| (|x| $)
  (SPADCALL |x| (|spadConstant| $ 355) (QREFELT $ 217))) 

(DEFUN |GUESS;guessInterpolate2|
       (|lists| |o| |degreeLoss| |guessDegree| D |options| $)
  (PROG (|vs| |vs0| |maxD| |maxD0|)
    (RETURN
     (SEQ
      (LETT |vs|
            (COND
             ((SPADCALL |options| (QREFELT $ 554))
              (SEQ
               (LETT |maxD0| (SPADCALL |options| (QREFELT $ 177))
                     . #1=(|GUESS;guessInterpolate2|))
               (LETT |maxD|
                     (COND ((QEQCAR |maxD0| 0) (QCDR |maxD0|))
                           (#2='T (- (+ |guessDegree| |o|) 2)))
                     . #1#)
               (LETT |vs0|
                     (SPADCALL (+ |guessDegree| |o|) (+ |maxD| 1) |o|
                               (QREFELT $ 608))
                     . #1#)
               (EXIT
                (SPADCALL (CONS (|function| |GUESS;listDecr|) $) |vs0|
                          (QREFELT $ 611)))))
             (#2# (SPADCALL NIL (SPADCALL (QREFELT $ 612)) (QREFELT $ 613))))
            . #1#)
      (EXIT
       (|GUESS;guessInterpolate3| |lists| |o| |degreeLoss| |guessDegree| D
        |options| |vs| $)))))) 

(DEFUN |GUESS;guessHPaux| (|lists| D |options| $)
  (PROG (#1=#:G4656 |reslist| |res| #2=#:G4658 |i| |exprList| MS M #3=#:G4650
         #4=#:G4643 #5=#:G4657 #6=#:G4613 #7=#:G4606 |maxD| |guessDegree|
         |degreeLoss| #8=#:G4654 #9=#:G4597 |o| |exprS| #10=#:G4596 |dk|
         |degreeS| |op| |listDegree| |list|)
    (RETURN
     (SEQ
      (EXIT
       (SEQ (LETT |reslist| NIL . #11=(|GUESS;guessHPaux|))
            (LETT |list| (|SPADfirst| |lists|) . #11#)
            (LETT |listDegree|
                  (- (- (LENGTH |list|) 1)
                     (SPADCALL |options| (QREFELT $ 215)))
                  . #11#)
            (COND
             ((< |listDegree| 0) (PROGN (LETT #1# |reslist| . #11#) (GO #1#))))
            (LETT |op|
                  (SPADCALL (SPADCALL |options| (QREFELT $ 614))
                            (QREFELT $ 615))
                  . #11#)
            (LETT |degreeS| (QVELT D 0) . #11#)
            (LETT |dk| (SPADCALL |options| (QREFELT $ 378)) . #11#)
            (LETT |exprS|
                  (SEQ
                   (EXIT
                    (COND
                     ((OR (EQUAL |dk| '|displayAsGF|)
                          (EQUAL |dk| '|displayAsEQ|))
                      (SPADCALL
                       (SPADCALL |op|
                                 (SPADCALL (SPADCALL |options| (QREFELT $ 546))
                                           (QREFELT $ 39))
                                 (QREFELT $ 616))
                       (SPADCALL |options| (QREFELT $ 546)) (QVELT D 4)))
                     ((EQUAL |dk| '|displayAsRec|)
                      (PROGN
                       (LETT #10#
                             (SPADCALL
                              (SPADCALL |op|
                                        (SPADCALL
                                         (SPADCALL |options| (QREFELT $ 66))
                                         (QREFELT $ 39))
                                        (QREFELT $ 616))
                              (SPADCALL |options| (QREFELT $ 66)) (QVELT D 4))
                             . #11#)
                       (GO #10#)))))
                   #10# (EXIT #10#))
                  . #11#)
            (SEQ
             (EXIT
              (SEQ (LETT |o| 2 . #11#) G190 NIL
                   (SEQ
                    (EXIT
                     (COND
                      ((SPADCALL
                        (SPADCALL |degreeS|
                                  (PROG1 (LETT #9# (- |o| 1) . #11#)
                                    (|check-subtype| (>= #9# 0)
                                                     '(|NonNegativeInteger|)
                                                     #9#))
                                  (QREFELT $ 617))
                        (QREFELT $ 618))
                       (PROGN (LETT #8# |$NoValue| . #11#) (GO #8#)))
                      ('T
                       (SEQ
                        (LETT |degreeLoss|
                              (SPADCALL |degreeS| |o| (QREFELT $ 434)) . #11#)
                        (LETT |guessDegree|
                              (- (- (+ |listDegree| 2) |degreeLoss|) |o|)
                              . #11#)
                        (COND
                         ((< |guessDegree| 0)
                          (SEQ
                           (COND
                            ((SPADCALL |options| (QREFELT $ 67))
                             (SPADCALL "Guess: not enough values for guessing"
                                       (QREFELT $ 78))))
                           (EXIT
                            (PROGN (LETT #1# |reslist| . #11#) (GO #1#))))))
                        (COND
                         ((SPADCALL |options| (QREFELT $ 67))
                          (SPADCALL
                           (SPADCALL
                            (LIST "Guess: trying order "
                                  (SPADCALL |o| (QREFELT $ 178))
                                  ", guessDegree is "
                                  (SPADCALL |guessDegree| (QREFELT $ 544)))
                            (QREFELT $ 619))
                           (QREFELT $ 73))))
                        (LETT |maxD| (SPADCALL |options| (QREFELT $ 177))
                              . #11#)
                        (EXIT
                         (COND
                          ((QEQCAR |maxD| 0)
                           (COND
                            ((OR
                              (OR
                               (SPADCALL
                                (SPADCALL |degreeS| |o| (QREFELT $ 617))
                                (QREFELT $ 618))
                               (NULL (< (* (QCDR |maxD|) |o|) |guessDegree|)))
                              (<
                               (-
                                (- (+ |listDegree| 2)
                                   (SPADCALL |degreeS| (+ |o| 1)
                                             (QREFELT $ 434)))
                                (+ |o| 1))
                               (* (QCDR |maxD|) (+ |o| 1))))
                             (SEQ (LETT |exprList| NIL . #11#)
                                  (COND
                                   ((SPADCALL |options| (QREFELT $ 67))
                                    (SEQ
                                     (LETT |exprList|
                                           (SPADCALL
                                            (SPADCALL
                                             (SPADCALL |exprS| |o|
                                                       (QREFELT $ 620))
                                             (QREFELT $ 621))
                                            (QREFELT $ 622))
                                           . #11#)
                                     (SPADCALL
                                      #12="Guess: The list of expressions is"
                                      (QREFELT $ 78))
                                     (EXIT
                                      (SPADCALL
                                       (SPADCALL |exprList| (QREFELT $ 623))
                                       (QREFELT $ 73))))))
                                  (LETT MS
                                        (|GUESS;guessInterpolate2| |lists| |o|
                                         |degreeLoss|
                                         (PROG1 (LETT #7# |guessDegree| . #11#)
                                           (|check-subtype| (>= #7# 0)
                                                            '(|NonNegativeInteger|)
                                                            #7#))
                                         D |options| $)
                                        . #11#)
                                  (EXIT
                                   (SEQ
                                    (EXIT
                                     (SEQ G190 NIL
                                          (SEQ
                                           (EXIT
                                            (COND
                                             ((SPADCALL MS (QREFELT $ 624))
                                              (PROGN
                                               (LETT #6# |$NoValue| . #11#)
                                               (GO #6#)))
                                             ('T
                                              (SEQ
                                               (LETT M
                                                     (SPADCALL MS
                                                               (QREFELT $ 625))
                                                     . #11#)
                                               (LETT MS
                                                     (SPADCALL MS
                                                               (QREFELT $ 626))
                                                     . #11#)
                                               (COND
                                                ((NULL |exprList|)
                                                 (LETT |exprList|
                                                       (SPADCALL
                                                        (SPADCALL
                                                         (SPADCALL |exprS| |o|
                                                                   (QREFELT $
                                                                            620))
                                                         (QREFELT $ 621))
                                                        (QREFELT $ 622))
                                                       . #11#)))
                                               (SEQ (LETT |i| 1 . #11#)
                                                    (LETT #5#
                                                          (SPADCALL M
                                                                    (QREFELT $
                                                                             579))
                                                          . #11#)
                                                    G190
                                                    (COND
                                                     ((QSGREATERP |i| #5#)
                                                      #13=(GO G191)))
                                                    (SEQ
                                                     (LETT |res|
                                                           (|GUESS;wrapInterpolant|
                                                            (SPADCALL
                                                             (SPADCALL M |i|
                                                                       (QREFELT
                                                                        $ 580))
                                                             (QREFELT $ 581))
                                                            |exprList| |list| D
                                                            |op| |options| $)
                                                           . #11#)
                                                     (EXIT
                                                      (COND
                                                       ((NULL
                                                         (SPADCALL |res|
                                                                   |reslist|
                                                                   (QREFELT $
                                                                            105)))
                                                        (LETT |reslist|
                                                              (CONS |res|
                                                                    |reslist|)
                                                              . #11#)))))
                                                    (LETT |i| (QSADD1 |i|)
                                                          . #11#)
                                                    #14=(GO G190) G191
                                                    (EXIT NIL))
                                               (EXIT
                                                (COND
                                                 ((NULL (NULL |reslist|))
                                                  (COND
                                                   ((SPADCALL |options|
                                                              (QREFELT $ 74))
                                                    (PROGN
                                                     (LETT #1# |reslist|
                                                           . #11#)
                                                     (GO #1#))))))))))))
                                          NIL #14# G191 (EXIT NIL)))
                                    #6# (EXIT #6#)))))
                            ('T
                             (SEQ (|spadConstant| $ 11)
                                  (EXIT
                                   (COND
                                    ((SPADCALL |options| (QREFELT $ 67))
                                     (SPADCALL "Guess: iterating"
                                               (QREFELT $ 78)))))))))
                          ('T
                           (SEQ (LETT |exprList| NIL . #11#)
                                (COND
                                 ((SPADCALL |options| (QREFELT $ 67))
                                  (SEQ
                                   (LETT |exprList|
                                         (SPADCALL
                                          (SPADCALL
                                           (SPADCALL |exprS| |o|
                                                     (QREFELT $ 620))
                                           (QREFELT $ 621))
                                          (QREFELT $ 622))
                                         . #11#)
                                   (SPADCALL #12# (QREFELT $ 78))
                                   (EXIT
                                    (SPADCALL
                                     (SPADCALL |exprList| (QREFELT $ 623))
                                     (QREFELT $ 73))))))
                                (LETT MS
                                      (|GUESS;guessInterpolate2| |lists| |o|
                                       |degreeLoss|
                                       (PROG1 (LETT #4# |guessDegree| . #11#)
                                         (|check-subtype| (>= #4# 0)
                                                          '(|NonNegativeInteger|)
                                                          #4#))
                                       D |options| $)
                                      . #11#)
                                (EXIT
                                 (SEQ
                                  (EXIT
                                   (SEQ G190 NIL
                                        (SEQ
                                         (EXIT
                                          (COND
                                           ((SPADCALL MS (QREFELT $ 624))
                                            (PROGN
                                             (LETT #3# |$NoValue| . #11#)
                                             (GO #3#)))
                                           ('T
                                            (SEQ
                                             (LETT M
                                                   (SPADCALL MS
                                                             (QREFELT $ 625))
                                                   . #11#)
                                             (LETT MS
                                                   (SPADCALL MS
                                                             (QREFELT $ 626))
                                                   . #11#)
                                             (COND
                                              ((NULL |exprList|)
                                               (LETT |exprList|
                                                     (SPADCALL
                                                      (SPADCALL
                                                       (SPADCALL |exprS| |o|
                                                                 (QREFELT $
                                                                          620))
                                                       (QREFELT $ 621))
                                                      (QREFELT $ 622))
                                                     . #11#)))
                                             (SEQ (LETT |i| 1 . #11#)
                                                  (LETT #2#
                                                        (SPADCALL M
                                                                  (QREFELT $
                                                                           579))
                                                        . #11#)
                                                  G190
                                                  (COND
                                                   ((QSGREATERP |i| #2#) #13#))
                                                  (SEQ
                                                   (LETT |res|
                                                         (|GUESS;wrapInterpolant|
                                                          (SPADCALL
                                                           (SPADCALL M |i|
                                                                     (QREFELT $
                                                                              580))
                                                           (QREFELT $ 581))
                                                          |exprList| |list| D
                                                          |op| |options| $)
                                                         . #11#)
                                                   (EXIT
                                                    (COND
                                                     ((NULL
                                                       (SPADCALL |res|
                                                                 |reslist|
                                                                 (QREFELT $
                                                                          105)))
                                                      (LETT |reslist|
                                                            (CONS |res|
                                                                  |reslist|)
                                                            . #11#)))))
                                                  (LETT |i| (QSADD1 |i|)
                                                        . #11#)
                                                  #14# G191 (EXIT NIL))
                                             (EXIT
                                              (COND
                                               ((NULL (NULL |reslist|))
                                                (COND
                                                 ((SPADCALL |options|
                                                            (QREFELT $ 74))
                                                  (PROGN
                                                   (LETT #1# |reslist| . #11#)
                                                   (GO #1#))))))))))))
                                        NIL #14# G191 (EXIT NIL)))
                                  #3# (EXIT #3#))))))))))))
                   (LETT |o| (QSADD1 |o|) . #11#) #14# G191 (EXIT NIL)))
             #8# (EXIT #8#))
            (EXIT |reslist|)))
      #1# (EXIT #1#))))) 

(DEFUN |GUESS;processOptions| (|options| $)
  (PROG (#1=#:G4707 #2=#:G4702 #3=#:G4700 #4=#:G4710 #5=#:G4666 |i| #6=#:G4709
         |minP| |hom?| #7=#:G4675 #8=#:G4708 |maxSomos| #9=#:G4660 #10=#:G4671
         #11=#:G4669 |maxD| #12=#:G4663 |Som?|)
    (RETURN
     (SEQ
      (EXIT
       (SEQ
        (SEQ
         (LETT |Som?| (SPADCALL |options| (QREFELT $ 249))
               . #13=(|GUESS;processOptions|))
         (EXIT
          (COND
           ((QEQCAR |Som?| 1)
            (COND
             ((QCDR |Som?|)
              (SEQ
               (LETT |maxD|
                     (PROG2
                         (LETT #12# (SPADCALL |options| (QREFELT $ 248))
                               . #13#)
                         (QCDR #12#)
                       (|check-union| (QEQCAR #12# 0) (|NonNegativeInteger|)
                                      #12#))
                     . #13#)
               (COND
                ((QEQCAR (SPADCALL |options| (QREFELT $ 245)) 0)
                 (LETT |maxSomos|
                       (*
                        (PROG1 (LETT #11# |maxD| . #13#)
                          (|check-subtype| (> #11# 0) '(|PositiveInteger|)
                                           #11#))
                        (PROG2
                            (LETT #5# (SPADCALL |options| (QREFELT $ 245))
                                  . #13#)
                            (QCDR #5#)
                          (|check-union| (QEQCAR #5# 0) (|PositiveInteger|)
                                         #5#)))
                       . #13#))
                ((QEQCAR (SPADCALL |options| (QREFELT $ 247)) 0)
                 (LETT |maxSomos|
                       (*
                        (PROG1 (LETT #10# |maxD| . #13#)
                          (|check-subtype| (> #10# 0) '(|PositiveInteger|)
                                           #10#))
                        (PROG2
                            (LETT #9# (SPADCALL |options| (QREFELT $ 247))
                                  . #13#)
                            (QCDR #9#)
                          (|check-union| (QEQCAR #9# 0) (|PositiveInteger|)
                                         #9#)))
                       . #13#))
                (#14='T
                 (|error| "Guess: internal error - inconsistent options")))
               (EXIT
                (PROGN
                 (LETT #1#
                       (SPADCALL
                        (PROGN
                         (LETT #8# NIL . #13#)
                         (SEQ (LETT |i| 2 . #13#) G190
                              (COND
                               ((QSGREATERP |i| |maxSomos|) #15=(GO G191)))
                              (SEQ
                               (EXIT
                                (LETT #8#
                                      (CONS
                                       (|GUESS;processOptions|
                                        (CONS
                                         (SPADCALL
                                          (CONS 0
                                                (PROG1 (LETT #7# |i| . #13#)
                                                  (|check-subtype| (> #7# 0)
                                                                   '(|PositiveInteger|)
                                                                   #7#)))
                                          (QREFELT $ 627))
                                         |options|)
                                        $)
                                       #8#)
                                      . #13#)))
                              (LETT |i| (QSADD1 |i|) . #13#) #16=(GO G190) G191
                              (EXIT (NREVERSE0 #8#))))
                        (QREFELT $ 629))
                       . #13#)
                 (GO #1#))))))))))
        (SEQ (LETT |hom?| (SPADCALL |options| (QREFELT $ 247)) . #13#)
             (EXIT
              (COND
               ((QEQCAR |hom?| 1)
                (COND
                 ((QCDR |hom?|)
                  (SEQ
                   (COND
                    ((QEQCAR (SPADCALL |options| (QREFELT $ 249)) 0)
                     (LETT |minP| 2 . #13#))
                    (#14# (LETT |minP| 1 . #13#)))
                   (EXIT
                    (PROGN
                     (LETT #1#
                           (PROGN
                            (LETT #6# NIL . #13#)
                            (SEQ (LETT |i| |minP| . #13#)
                                 (LETT #4#
                                       (PROG2
                                           (LETT #5#
                                                 (SPADCALL |options|
                                                           (QREFELT $ 245))
                                                 . #13#)
                                           (QCDR #5#)
                                         (|check-union| (QEQCAR #5# 0)
                                                        (|PositiveInteger|)
                                                        #5#))
                                       . #13#)
                                 G190 (COND ((> |i| #4#) #15#))
                                 (SEQ
                                  (EXIT
                                   (LETT #6#
                                         (CONS
                                          (SPADCALL
                                           (LIST
                                            (SPADCALL
                                             (CONS 0
                                                   (PROG1 (LETT #3# |i| . #13#)
                                                     (|check-subtype| (> #3# 0)
                                                                      '(|PositiveInteger|)
                                                                      #3#)))
                                             (QREFELT $ 630))
                                            (SPADCALL
                                             (CONS 0
                                                   (PROG1 (LETT #2# |i| . #13#)
                                                     (|check-subtype| (> #2# 0)
                                                                      '(|PositiveInteger|)
                                                                      #2#)))
                                             (QREFELT $ 631)))
                                           |options| (QREFELT $ 632))
                                          #6#)
                                         . #13#)))
                                 (LETT |i| (+ |i| 1) . #13#) #16# G191
                                 (EXIT (NREVERSE0 #6#))))
                           . #13#)
                     (GO #1#))))))))))
        (EXIT (LIST |options|))))
      #1# (EXIT #1#))))) 

(DEFUN |GUESS;guessAlgDep;LLL;128| (|lists| |options| $)
  (PROG (|lres| #1=#:G4724 |res| #2=#:G4726 |opts| |lopts| #3=#:G4716
         #4=#:G4712 #5=#:G4725 |li| |nn| |rl| |l|)
    (RETURN
     (SEQ
      (EXIT
       (SEQ (SPADCALL |options| (QREFELT $ 633))
            (EXIT
             (COND
              ((NULL |lists|) (|error| "guessAlgDep: need at least one list"))
              ('T
               (SEQ
                (LETT |l| (|SPADfirst| |lists|)
                      . #6=(|GUESS;guessAlgDep;LLL;128|))
                (LETT |rl| (CDR |lists|) . #6#) (LETT |nn| (LENGTH |l|) . #6#)
                (SEQ
                 (EXIT
                  (SEQ (LETT |li| NIL . #6#) (LETT #5# |rl| . #6#) G190
                       (COND
                        ((OR (ATOM #5#)
                             (PROGN (LETT |li| (CAR #5#) . #6#) NIL))
                         #7=(GO G191)))
                       (SEQ
                        (EXIT
                         (COND
                          ((NULL (EQL (LENGTH |li|) |nn|))
                           (PROGN
                            (LETT #4#
                                  (|error|
                                   "guessAlgDep: lists must have equal length")
                                  . #6#)
                            (GO #4#))))))
                       (LETT #5# (CDR #5#) . #6#) #8=(GO G190) G191
                       (EXIT NIL)))
                 #4# (EXIT #4#))
                (LETT |lopts|
                      (|GUESS;processOptions|
                       (APPEND
                        (LIST (SPADCALL '|displayAsEQ| (QREFELT $ 634))
                              (SPADCALL
                               (CONS 0
                                     (PROG1 (LETT #3# (LENGTH |lists|) . #6#)
                                       (|check-subtype| (> #3# 0)
                                                        '(|PositiveInteger|)
                                                        #3#)))
                               (QREFELT $ 635)))
                        |options|)
                       $)
                      . #6#)
                (LETT |lres| NIL . #6#) (LETT |res| NIL . #6#)
                (SEQ (LETT |opts| NIL . #6#) (LETT #2# |lopts| . #6#) G190
                     (COND
                      ((OR (ATOM #2#)
                           (PROGN (LETT |opts| (CAR #2#) . #6#) NIL))
                       #7#))
                     (SEQ
                      (LETT |res|
                            (|GUESS;guessHPaux| |lists|
                             (SPADCALL |lists| |opts| (QREFELT $ 402)) |opts|
                             $)
                            . #6#)
                      (COND
                       ((NULL (NULL |res|))
                        (COND
                         ((SPADCALL |options| (QREFELT $ 74))
                          (PROGN (LETT #1# |res| . #6#) (GO #1#))))))
                      (EXIT (LETT |lres| (APPEND |res| |lres|) . #6#)))
                     (LETT #2# (CDR #2#) . #6#) #8# G191 (EXIT NIL))
                (EXIT (NREVERSE |lres|))))))))
      #1# (EXIT #1#))))) 

(DEFUN |GUESS;guessAlgDep;LL;129| (|lists| $)
  (SPADCALL |lists| NIL (QREFELT $ 636))) 

(DEFUN |GUESS;guessADE;LLL;130| (|list| |options| $)
  (PROG (|lres| #1=#:G4734 |res| #2=#:G4735 |opts| |lopts|)
    (RETURN
     (SEQ
      (EXIT
       (SEQ (SPADCALL |options| (QREFELT $ 633))
            (LETT |lopts|
                  (|GUESS;processOptions|
                   (CONS (SPADCALL '|displayAsGF| (QREFELT $ 634)) |options|)
                   $)
                  . #3=(|GUESS;guessADE;LLL;130|))
            (LETT |lres| NIL . #3#) (LETT |res| NIL . #3#)
            (SEQ (LETT |opts| NIL . #3#) (LETT #2# |lopts| . #3#) G190
                 (COND
                  ((OR (ATOM #2#) (PROGN (LETT |opts| (CAR #2#) . #3#) NIL))
                   (GO G191)))
                 (SEQ
                  (LETT |res|
                        (|GUESS;guessHPaux| (LIST |list|)
                         (SPADCALL |opts| (QREFELT $ 394)) |opts| $)
                        . #3#)
                  (COND
                   ((NULL (NULL |res|))
                    (COND
                     ((SPADCALL |options| (QREFELT $ 74))
                      (PROGN (LETT #1# |res| . #3#) (GO #1#))))))
                  (EXIT (LETT |lres| (APPEND |res| |lres|) . #3#)))
                 (LETT #2# (CDR #2#) . #3#) (GO G190) G191 (EXIT NIL))
            (EXIT (NREVERSE |lres|))))
      #1# (EXIT #1#))))) 

(DEFUN |GUESS;guessADE;LL;131| (|list| $) (SPADCALL |list| NIL (QREFELT $ 638))) 

(DEFUN |GUESS;guessAlg;LLL;132| (|list| |options| $)
  (SPADCALL |list| (CONS (SPADCALL (CONS 0 0) (QREFELT $ 640)) |options|)
            (QREFELT $ 638))) 

(DEFUN |GUESS;guessAlg;LL;133| (|list| $) (SPADCALL |list| NIL (QREFELT $ 641))) 

(DEFUN |GUESS;guessHolo;LLL;134| (|list| |options| $)
  (SPADCALL |list| (CONS (SPADCALL (CONS 0 1) (QREFELT $ 631)) |options|)
            (QREFELT $ 638))) 

(DEFUN |GUESS;guessHolo;LL;135| (|list| $)
  (SPADCALL |list| NIL (QREFELT $ 643))) 

(DEFUN |GUESS;guessPade;LLL;136| (|list| |options| $)
  (PROG (|opts|)
    (RETURN
     (SEQ
      (LETT |opts|
            (SPADCALL
             (LIST
              (LIST (SPADCALL (CONS 0 0) (QREFELT $ 640))
                    (SPADCALL (CONS 0 1) (QREFELT $ 631)))
              |options| (LIST (SPADCALL 'T (QREFELT $ 645))))
             (QREFELT $ 646))
            |GUESS;guessPade;LLL;136|)
      (EXIT (SPADCALL |list| |opts| (QREFELT $ 638))))))) 

(DEFUN |GUESS;guessPade;LL;137| (|list| $)
  (SPADCALL |list| NIL (QREFELT $ 647))) 

(DEFUN |GUESS;guessFE;LLL;138| (|list| |options| $)
  (PROG (|lres| #1=#:G4762 |res| #2=#:G4763 |opts| |lopts|)
    (RETURN
     (SEQ
      (EXIT
       (SEQ (SPADCALL |options| (QREFELT $ 633))
            (LETT |lopts|
                  (|GUESS;processOptions|
                   (CONS (SPADCALL '|displayAsGF| (QREFELT $ 634)) |options|)
                   $)
                  . #3=(|GUESS;guessFE;LLL;138|))
            (LETT |lres| NIL . #3#) (LETT |res| NIL . #3#)
            (SEQ (LETT |opts| NIL . #3#) (LETT #2# |lopts| . #3#) G190
                 (COND
                  ((OR (ATOM #2#) (PROGN (LETT |opts| (CAR #2#) . #3#) NIL))
                   (GO G191)))
                 (SEQ
                  (LETT |res|
                        (|GUESS;guessHPaux| (LIST |list|)
                         (SPADCALL |opts| (QREFELT $ 405)) |opts| $)
                        . #3#)
                  (COND
                   ((NULL (NULL |res|))
                    (COND
                     ((SPADCALL |options| (QREFELT $ 74))
                      (PROGN (LETT #1# |res| . #3#) (GO #1#))))))
                  (EXIT (LETT |lres| (APPEND |res| |lres|) . #3#)))
                 (LETT #2# (CDR #2#) . #3#) (GO G190) G191 (EXIT NIL))
            (EXIT (NREVERSE |lres|))))
      #1# (EXIT #1#))))) 

(DEFUN |GUESS;guessFE;LL;139| (|list| $) (SPADCALL |list| NIL (QREFELT $ 649))) 

(DEFUN |GUESS;guessADE;SM;140| (|q| $)
  (PROG () (RETURN (SEQ (CONS #'|GUESS;guessADE;SM;140!0| (VECTOR |q| $)))))) 

(DEFUN |GUESS;guessADE;SM;140!0| (|list| |options| $$)
  (PROG ($ |q|)
    (LETT $ (QREFELT $$ 1) . #1=(|GUESS;guessADE;SM;140|))
    (LETT |q| (QREFELT $$ 0) . #1#)
    (RETURN
     (PROGN
      (PROG (|lres| #2=#:G4771 |res| #3=#:G4772 |opts| |lopts|)
        (RETURN
         (SEQ
          (EXIT
           (SEQ (SPADCALL |options| (QREFELT $ 633))
                (LETT |lopts|
                      (|GUESS;processOptions|
                       (SPADCALL (SPADCALL '|displayAsGF| (QREFELT $ 634))
                                 |options| (QREFELT $ 651))
                       $)
                      NIL)
                (LETT |lres| NIL NIL) (LETT |res| NIL NIL)
                (SEQ (LETT |opts| NIL NIL) (LETT #3# |lopts| NIL) G190
                     (COND
                      ((OR (ATOM #3#) (PROGN (LETT |opts| (CAR #3#) NIL) NIL))
                       (GO G191)))
                     (SEQ
                      (LETT |res|
                            (|GUESS;guessHPaux| (LIST |list|)
                             (SPADCALL |opts| (SPADCALL |q| (QREFELT $ 416)))
                             |opts| $)
                            NIL)
                      (COND
                       ((NULL (SPADCALL |res| (QREFELT $ 652)))
                        (COND
                         ((SPADCALL |options| (QREFELT $ 74))
                          (PROGN (LETT #2# |res| NIL) (GO #2#))))))
                      (EXIT
                       (LETT |lres| (SPADCALL |res| |lres| (QREFELT $ 653))
                             NIL)))
                     (LETT #3# (CDR #3#) NIL) (GO G190) G191 (EXIT NIL))
                (EXIT (SPADCALL |lres| (QREFELT $ 654)))))
          #2# (EXIT #2#)))))))) 

(DEFUN |GUESS;guessHolo;SM;141| (|q| $)
  (PROG () (RETURN (CONS #'|GUESS;guessHolo;SM;141!0| (VECTOR |q| $))))) 

(DEFUN |GUESS;guessHolo;SM;141!0| (|z1| |z2| $$)
  (PROG ($ |q|)
    (LETT $ (QREFELT $$ 1) . #1=(|GUESS;guessHolo;SM;141|))
    (LETT |q| (QREFELT $$ 0) . #1#)
    (RETURN
     (PROGN
      (SPADCALL |z1|
                (SPADCALL
                 (SPADCALL (CONS 0 (|spadConstant| $ 107)) (QREFELT $ 631))
                 |z2| (QREFELT $ 651))
                (SPADCALL |q| (QREFELT $ 655))))))) 

(DEFUN |GUESS;guessRec;LLL;142| (|list| |options| $)
  (PROG (|lres| #1=#:G4785 |res| #2=#:G4786 |opts| |lopts|)
    (RETURN
     (SEQ
      (EXIT
       (SEQ (SPADCALL |options| (QREFELT $ 633))
            (LETT |lopts|
                  (|GUESS;processOptions|
                   (CONS (SPADCALL '|displayAsRec| (QREFELT $ 634)) |options|)
                   $)
                  . #3=(|GUESS;guessRec;LLL;142|))
            (LETT |lres| NIL . #3#) (LETT |res| NIL . #3#)
            (SEQ (LETT |opts| NIL . #3#) (LETT #2# |lopts| . #3#) G190
                 (COND
                  ((OR (ATOM #2#) (PROGN (LETT |opts| (CAR #2#) . #3#) NIL))
                   (GO G191)))
                 (SEQ
                  (LETT |res|
                        (|GUESS;guessHPaux| (LIST |list|)
                         (SPADCALL |opts| (QREFELT $ 438)) |opts| $)
                        . #3#)
                  (COND
                   ((NULL (NULL |res|))
                    (COND
                     ((SPADCALL |options| (QREFELT $ 74))
                      (PROGN (LETT #1# |res| . #3#) (GO #1#))))))
                  (EXIT (LETT |lres| (APPEND |res| |lres|) . #3#)))
                 (LETT #2# (CDR #2#) . #3#) (GO G190) G191 (EXIT NIL))
            (EXIT (NREVERSE |lres|))))
      #1# (EXIT #1#))))) 

(DEFUN |GUESS;guessRec;LL;143| (|list| $) (SPADCALL |list| NIL (QREFELT $ 657))) 

(DEFUN |GUESS;guessPRec;LLL;144| (|list| |options| $)
  (SPADCALL |list| (CONS (SPADCALL (CONS 0 1) (QREFELT $ 631)) |options|)
            (QREFELT $ 657))) 

(DEFUN |GUESS;guessPRec;LL;145| (|list| $)
  (SPADCALL |list| NIL (QREFELT $ 659))) 

(DEFUN |GUESS;guessRat;LLL;146| (|list| |options| $)
  (PROG (|opts|)
    (RETURN
     (SEQ
      (LETT |opts|
            (SPADCALL
             (LIST
              (LIST (SPADCALL (CONS 0 0) (QREFELT $ 661))
                    (SPADCALL (CONS 0 1) (QREFELT $ 631)))
              |options| (LIST (SPADCALL 'T (QREFELT $ 645))))
             (QREFELT $ 646))
            |GUESS;guessRat;LLL;146|)
      (EXIT (SPADCALL |list| |opts| (QREFELT $ 657))))))) 

(DEFUN |GUESS;guessRat;LL;147| (|list| $) (SPADCALL |list| NIL (QREFELT $ 110))) 

(DEFUN |GUESS;guessRec;SM;148| (|q| $)
  (PROG () (RETURN (SEQ (CONS #'|GUESS;guessRec;SM;148!0| (VECTOR |q| $)))))) 

(DEFUN |GUESS;guessRec;SM;148!0| (|list| |options| $$)
  (PROG ($ |q|)
    (LETT $ (QREFELT $$ 1) . #1=(|GUESS;guessRec;SM;148|))
    (LETT |q| (QREFELT $$ 0) . #1#)
    (RETURN
     (PROGN
      (PROG (|lres| #2=#:G4808 |res| #3=#:G4809 |opts| |lopts|)
        (RETURN
         (SEQ
          (EXIT
           (SEQ (SPADCALL |options| (QREFELT $ 633))
                (LETT |lopts|
                      (|GUESS;processOptions|
                       (SPADCALL (SPADCALL '|displayAsRec| (QREFELT $ 634))
                                 |options| (QREFELT $ 651))
                       $)
                      NIL)
                (LETT |lres| NIL NIL) (LETT |res| NIL NIL)
                (SEQ (LETT |opts| NIL NIL) (LETT #3# |lopts| NIL) G190
                     (COND
                      ((OR (ATOM #3#) (PROGN (LETT |opts| (CAR #3#) NIL) NIL))
                       (GO G191)))
                     (SEQ
                      (LETT |res|
                            (|GUESS;guessHPaux| (LIST |list|)
                             (SPADCALL |opts| (SPADCALL |q| (QREFELT $ 486)))
                             |opts| $)
                            NIL)
                      (COND
                       ((NULL (SPADCALL |res| (QREFELT $ 652)))
                        (COND
                         ((SPADCALL |options| (QREFELT $ 74))
                          (PROGN (LETT #2# |res| NIL) (GO #2#))))))
                      (EXIT
                       (LETT |lres| (SPADCALL |res| |lres| (QREFELT $ 653))
                             NIL)))
                     (LETT #3# (CDR #3#) NIL) (GO G190) G191 (EXIT NIL))
                (EXIT (SPADCALL |lres| (QREFELT $ 654)))))
          #2# (EXIT #2#)))))))) 

(DEFUN |GUESS;guessPRec;SM;149| (|q| $)
  (PROG () (RETURN (CONS #'|GUESS;guessPRec;SM;149!0| (VECTOR |q| $))))) 

(DEFUN |GUESS;guessPRec;SM;149!0| (|z1| |z2| $$)
  (PROG ($ |q|)
    (LETT $ (QREFELT $$ 1) . #1=(|GUESS;guessPRec;SM;149|))
    (LETT |q| (QREFELT $$ 0) . #1#)
    (RETURN
     (PROGN
      (SPADCALL |z1|
                (SPADCALL
                 (SPADCALL (CONS 0 (|spadConstant| $ 107)) (QREFELT $ 631))
                 |z2| (QREFELT $ 651))
                (SPADCALL |q| (QREFELT $ 663))))))) 

(DEFUN |GUESS;guessRat;SM;150| (|q| $)
  (PROG () (RETURN (CONS #'|GUESS;guessRat;SM;150!0| (VECTOR |q| $))))) 

(DEFUN |GUESS;guessRat;SM;150!0| (|z1| |z2| $$)
  (PROG ($ |q|)
    (LETT $ (QREFELT $$ 1) . #1=(|GUESS;guessRat;SM;150|))
    (LETT |q| (QREFELT $$ 0) . #1#)
    (RETURN
     (PROGN
      (SPADCALL |z1|
                (SPADCALL
                 (LIST
                  (LIST
                   (SPADCALL (CONS 0 (|spadConstant| $ 273)) (QREFELT $ 661))
                   (SPADCALL (CONS 0 (|spadConstant| $ 107)) (QREFELT $ 631)))
                  |z2|
                  (LIST (SPADCALL (|spadConstant| $ 597) (QREFELT $ 645))))
                 (QREFELT $ 646))
                (SPADCALL |q| (QREFELT $ 663))))))) 

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

(DEFUN |Guess;| (|#1| |#2| |#3| |#4| |#5|)
  (PROG (|pv$| $ |dv$| DV$5 DV$4 DV$3 DV$2 DV$1)
    (RETURN
     (PROGN
      (LETT DV$1 (|devaluate| |#1|) . #1=(|Guess|))
      (LETT DV$2 (|devaluate| |#2|) . #1#)
      (LETT DV$3 (|devaluate| |#3|) . #1#)
      (LETT DV$4 (|devaluate| |#4|) . #1#)
      (LETT DV$5 (|devaluate| |#5|) . #1#)
      (LETT |dv$| (LIST '|Guess| DV$1 DV$2 DV$3 DV$4 DV$5) . #1#)
      (LETT $ (GETREFV 666) . #1#)
      (QSETREFV $ 0 |dv$|)
      (QSETREFV $ 3
                (LETT |pv$|
                      (|buildPredVector| 0 0
                                         (LIST
                                          (AND
                                           (|HasCategory| |#1|
                                                          '(|RetractableTo|
                                                            (|Symbol|)))
                                           (|HasCategory| |#2|
                                                          '(|RetractableTo|
                                                            (|Symbol|))))))
                      . #1#))
      (|haddProp| |$ConstructorCache| '|Guess| (LIST DV$1 DV$2 DV$3 DV$4 DV$5)
                  (CONS 1 $))
      (|stuffDomainSlots| $)
      (QSETREFV $ 6 |#1|)
      (QSETREFV $ 7 |#2|)
      (QSETREFV $ 8 |#3|)
      (QSETREFV $ 9 |#4|)
      (QSETREFV $ 10 |#5|)
      (SETF |pv$| (QREFELT $ 3))
      (COND
       ((|HasCategory| |#1| '(|RetractableTo| (|Symbol|)))
        (COND
         ((|HasCategory| |#2| '(|RetractableTo| (|Symbol|)))
          (QSETREFV $ 223
                    (CONS (|dispatchFunction| |GUESS;guessExpRat;SM;27|)
                          $))))))
      (COND
       ((|HasCategory| |#1| '(|RetractableTo| (|Symbol|)))
        (COND
         ((|HasCategory| |#2| '(|RetractableTo| (|Symbol|)))
          (PROGN
           (QSETREFV $ 243
                     (CONS (|dispatchFunction| |GUESS;guessBinRat;SM;39|)
                           $)))))))
      (COND
       ((|HasCategory| |#1| '(|RetractableTo| (|Symbol|)))
        (COND
         ((|HasCategory| |#2| '(|RetractableTo| (|Symbol|)))
          (PROGN
           (QSETREFV $ 416
                     (CONS (|dispatchFunction| |GUESS;diffHP;SM;89|) $)))))))
      (COND
       ((|HasCategory| |#1| '(|RetractableTo| (|Symbol|)))
        (COND
         ((|HasCategory| |#2| '(|RetractableTo| (|Symbol|)))
          (PROGN
           (QSETREFV $ 486
                     (CONS (|dispatchFunction| |GUESS;shiftHP;SM;111|) $)))))))
      (COND
       ((|HasCategory| |#1| '(|RetractableTo| (|Symbol|)))
        (COND
         ((|HasCategory| |#2| '(|RetractableTo| (|Symbol|)))
          (PROGN
           (QSETREFV $ 655
                     (CONS (|dispatchFunction| |GUESS;guessADE;SM;140|) $))
           (QSETREFV $ 656
                     (CONS (|dispatchFunction| |GUESS;guessHolo;SM;141|)
                           $)))))))
      (COND
       ((|HasCategory| |#1| '(|RetractableTo| (|Symbol|)))
        (COND
         ((|HasCategory| |#2| '(|RetractableTo| (|Symbol|)))
          (PROGN
           (QSETREFV $ 663
                     (CONS (|dispatchFunction| |GUESS;guessRec;SM;148|) $))
           (QSETREFV $ 664
                     (CONS (|dispatchFunction| |GUESS;guessPRec;SM;149|) $))
           (QSETREFV $ 665
                     (CONS (|dispatchFunction| |GUESS;guessRat;SM;150|)
                           $)))))))
      $)))) 

(MAKEPROP '|Guess| '|infovec|
          (LIST
           '#(NIL NIL NIL NIL NIL NIL (|local| |#1|) (|local| |#2|)
              (|local| |#3|) (|local| |#4|) (|local| |#5|) (0 . |One|)
              (4 . |One|) (|Integer|) (|List| 13) (8 . |elt|) (14 . +)
              (|Mapping| 13 13 13) (20 . |reduce|) (|PositiveInteger|) (27 . *)
              (|List| 38) (33 . |variables|) (|List| 21) (|Mapping| 21 7)
              (|List| 7) (|ListFunctions2| 7 21) (38 . |map|) (|Fraction| 7)
              (44 . |numer|) (49 . |denom|) (54 . |setUnion|) (|Mapping| 21 6)
              (|List| 6) (|ListFunctions2| 6 21) (60 . |map|)
              (|Mapping| 21 21 21) (66 . |reduce|) (|Symbol|) (72 . |coerce|)
              (|List| 8) (|Mapping| 8 38) (|ListFunctions2| 38 8) (77 . |map|)
              (83 . |denominator|) (88 . |coerce|) (93 . |eval|) (100 . |Zero|)
              (104 . |Zero|) (108 . |Zero|) (|Boolean|) (112 . =)
              (118 . |numerator|) (123 . |elt|) (129 . /) (135 . =)
              (141 . |coerce|) (|SparseUnivariatePolynomial| 6) (|Mapping| 6 7)
              (|SparseUnivariatePolynomial| 7)
              (|SparseUnivariatePolynomialFunctions2| 7 6) (146 . |map|)
              (|Union| 124 '"arbitrary") (|List| 87) (|GuessOptionFunctions0|)
              (152 . |maxLevel|) (157 . |indexName|) (162 . |debug|)
              (|OutputForm|) (167 . |coerce|) (172 . |hconcat|) (|Void|)
              (|OutputPackage|) (178 . |output|) (183 . |one|)
              (188 . |member?|) (194 . |member?|) (|String|) (200 . |output|)
              (205 . /) (211 . |one?|) (216 . |one?|) (|Mapping| 50 6)
              (221 . |every?|) (227 . |coerce|) (|List| 68) (232 . |subscript|)
              (|GuessOption|) (238 . |indexName|) (243 . |maxLevel|)
              (|Mapping| 40 33 63) (|List| 90) |GUESS;guess;LLLLL;8|
              (248 . |One|) (252 . -) (|Segment| 8) (258 . SEGMENT)
              (|SegmentBinding| 8) (264 . |equation|) (|SegmentBinding| $)
              (270 . |product|) (276 . |init|) (|Fraction| 57) (280 . |init|)
              (284 . *) (290 . |member?|) (296 . -) (302 . |One|)
              (306 . |summation|) (312 . +) |GUESS;guessRat;LLL;146|
              |GUESS;guess;LL;9| |GUESS;guess;LLL;10| |GUESS;guess;LLLL;11|
              (|SparseMultivariatePolynomial| 6 136) (318 . |coerce|)
              (|Fraction| 114) (323 . |coerce|)
              (|SparseMultivariatePolynomial| 7 136) (328 . |coerce|)
              (|Fraction| 118) (333 . /) (339 . |zero?|)
              (344 . |leadingCoefficient|) (|NonNegativeInteger|)
              (349 . |degree|) (354 . ^) (360 . |reductum|) (365 . |numer|)
              (370 . |denom|)
              (|MPolyCatFunctions2| 136 (|IndexedExponents| 136)
                                    (|IndexedExponents| 136) 7 6 118 114)
              (375 . |map|) (|SparseUnivariatePolynomial| 118) (381 . |zero?|)
              (386 . |Zero|) (390 . |leadingCoefficient|)
              (|OrderedVariableList| (NRTEVAL (LIST '|a1| 'A))) (395 . |index|)
              (|List| 136) (400 . |eval|) (407 . |retract|) (412 . |degree|)
              (417 . |monomial|) (423 . |reductum|) (428 . +)
              (|Record| (|:| |num| 146) (|:| |den| 118))
              (|SparseUnivariatePolynomial| 120)
              (|UnivariatePolynomialCommonDenominator| 118 120 146)
              (434 . |splitDenominator|) (439 . *) (445 . |retract|)
              (|Mapping| 118 120)
              (|SparseUnivariatePolynomialFunctions2| 120 118) (450 . |map|)
              (456 . |coerce|) (|Fraction| 132) (461 . /) (467 . |degree|)
              (473 . |coerce|) (478 . |eval|) (485 . |univariate|)
              (490 . |degree|) (495 . |leadingCoefficient|) (500 . ^) (506 . -)
              (511 . *) (517 . |zero?|) (522 . |resultant|)
              (|Union| $ '"failed") (528 . |exquo|) (534 . |coerce|)
              (539 . |coerce|) (544 . *) (550 . +) (556 . |last|) (561 . -)
              (566 . ^) (572 . |maxDegree|) (577 . |coerce|)
              (|MoreSystemCommands|) (582 . |systemCommand|) (|Fraction| 146)
              (|List| 120) (|FractionFreeFastGaussian| 120 146)
              (587 . |interpolate|) (|Fraction| $) (594 . |elt|) (600 . -)
              (606 . |numer|) (|NewtonInterpolation| 7) (611 . |newton|)
              (616 . |gcd|) (622 . |primitivePart|) (|Factored| 57)
              (|GeneralizedMultivariateFactorize| 517 124 6 6 57)
              (627 . |factor|) (|Record| (|:| |factor| 57) (|:| |exponent| 13))
              (|List| 196) (632 . |factors|) (637 . |coefficient|) (643 . -)
              (648 . |eval|) (655 . |zero?|) (660 . |univariate|)
              (665 . |numer|) (670 . |denom|) (675 . /) (681 . |numer|)
              (686 . |denom|) (691 . /) (|Kernel| 8) (697 . |kernel|)
              (|Kernel| $) (702 . |eval|) (709 . ^) (715 . |safety|)
              (720 . |first|) (726 . -) (732 . <) (|Mapping| 50 8)
              (738 . |select|) |GUESS;guessExpRat;LL;25|
              |GUESS;guessExpRat;LLL;26| (744 . |guessExpRat|) (749 . *)
              (755 . +) (761 . |coerce|) (766 . -) (772 . *) (778 . |One|)
              (|Mapping| 118 118 118) (|List| 118) (782 . |reduce|)
              (789 . |factorial|) (794 . |binomial|) (800 . /)
              (806 . |resultant|) |GUESS;guessBinRat;LL;32|
              |GUESS;guessBinRat;LLL;33| (813 . |One|) (817 . |coerce|)
              (|Mapping| 120 120 120) (822 . |reduce|) (829 . |guessBinRat|)
              (|Union| 19 '"arbitrary") (834 . |maxPower|) (|Union| 19 50)
              (839 . |homogeneous|) (844 . |maxDerivative|) (849 . |Somos|)
              (|Stream| 14) (|PartitionsAndPermutations|) (854 . |partitions|)
              (860 . |inc|) (|Mapping| 13 13) (|Stream| 13) (865 . |generate|)
              (871 . +) (877 . |partitions|) (|Stream| 250) (|Mapping| 250 13)
              (|StreamFunctions2| 13 250) (884 . |map|) (890 . |partitions|)
              (|StreamFunctions1| 14) (895 . |concat|) (900 . |cons|)
              (906 . |conjugates|) (911 . |#|) (916 . =) (|Mapping| 50 14)
              (922 . |select|) (928 . +) (934 . |Zero|) (938 . =) (|List| 14)
              (|Partition|) (944 . |powers|) (949 . |second|) (|Mapping| 8 8 8)
              (954 . |reduce|) (|U32Vector|) (960 . |construct|)
              (|U32VectorPolynomialOperations|) (965 . |differentiate|)
              (972 . |pow|) (980 . |truncated_multiplication|)
              (|Mapping| 281 281 281) (|List| 281) (988 . |reduce|)
              (994 . |copy_first|) (|UnivariateFormalPowerSeries| 6) (1001 . ^)
              (1007 . *) (|Mapping| 291 291 291) (|List| 291) (1013 . |reduce|)
              (1019 . ^) (|Mapping| 6 6) (1025 . |map|)
              (|UnivariateFormalPowerSeriesFunctions| 6) (1031 . |hadamard|)
              (|SparseMultivariatePolynomial| 6 124) (1037 . ^)
              (|Mapping| 302 302) (|UnivariateFormalPowerSeries| 302)
              (1043 . |map|) (|UnivariateFormalPowerSeriesFunctions| 302)
              (1049 . |hadamard|) (|Mapping| 305 305 305) (|List| 305)
              (1055 . |reduce|) (|Stream| 291) (|Mapping| 291 14)
              (|StreamFunctions2| 14 291) (1061 . |map|) (1067 . |Zero|)
              (1071 . |Zero|) (1075 . |Zero|) (1079 . |Zero|) (1083 . |Zero|)
              (1087 . |One|) (1091 . |One|) (1095 . |One|) (1099 . |One|)
              (1103 . |One|) (|Vector| 281) (1107 . |setelt|)
              (1114 . |differentiate|) (1120 . *) (|Fraction| 13)
              (1126 . |One|) (1130 . |One|) (|Vector| 305) (1134 . |setelt|)
              (1141 . |subtractIfCan|) (|List| 276) (1147 . |position|)
              (|Reference| 336) (1153 . |deref|) (1158 . |coerce|)
              (1163 . |partition|) (|Reference| 275) (1168 . |deref|)
              (1173 . |setref|) (1179 . |setref|) (1185 . |max|)
              (1191 . |first|) (|Mapping| 13 14) (|ListFunctions2| 14 13)
              (1196 . |map|) (1202 . |reduce|) (1208 . |ref|) (1213 . |ref|)
              (1218 . |#|) (1223 . |One|) (1227 . |first|) (1232 . |vector|)
              (1237 . |vector|) (|Stream| 8) (|Mapping| 8 14)
              (|StreamFunctions2| 14 8) (1242 . |map|) (1248 . |empty?|)
              (1253 . |max|) (|Stream| 124) (|Mapping| 124 14 124)
              (|StreamFunctions2| 14 124) (1259 . |scan|) (1266 . D) (1273 . D)
              (1279 . D) (|FractionFreeFastGaussian| 7 59)
              (1285 . |DiffAction|) (|FractionFreeFastGaussian| 302 305)
              (1292 . |DiffAction|) (1299 . |DiffC|) (1304 . |maxMixedDegree|)
              (1309 . |displayKind|) (1314 . |first|) (1320 . |complete|)
              (1325 . |entries|) (1330 . |elt|) (|Mapping| 312 291)
              (|Mapping| 326 288 13 13) (|Mapping| 384 124) (|Mapping| 333 305)
              (|Mapping| 386 474) (|Mapping| 359 8 38) (|Mapping| 7 124 124 59)
              (|Mapping| 302 124 124 305) (|Mapping| 8 124 38 8)
              (|Mapping| 25 124)
              (|Record| (|:| |degreeStream| 365) (|:| |guessStream| 383)
                        (|:| |guessModGen| 385) (|:| |testGen| 387)
                        (|:| |exprStream| 388) (|:| |kind| 38) (|:| |qvar| 38)
                        (|:| A 389) (|:| AF 390) (|:| AX 391) (|:| C 392))
              |GUESS;diffHP;LR;74| (1336 . |elt|) (1342 . |functionNames|)
              (1347 . |coerce|) (|List| 33) (1352 . |elt|) (|Mapping| 124 14)
              (1358 . |map|) |GUESS;algDepHP;LLR;78|
              (1364 . |multiplyExponents|) (1370 . |multiplyExponents|)
              |GUESS;substHP;LR;82| (1376 . *) (|Mapping| 6 13)
              (1382 . |multiplyCoefficients|) (1388 . |Zero|) (1392 . |coerce|)
              (|Mapping| 302 13) (1397 . |multiplyCoefficients|)
              (1403 . |zero?|) (1408 . =) (|Mapping| 393 63) (1414 . |diffHP|)
              (1419 . |quoByVar|) (|Mapping| 291 291) (|MappingPackage1| 291)
              (1424 . ^) (1430 . |quoByVar|) (|Mapping| 305 305)
              (|MappingPackage1| 305) (1435 . ^)
              (|IntegerCombinatoricFunctions| 13) (1441 . |stirling2|)
              (1447 . |ShiftAction|) (1454 . |ShiftAction|) (1461 . |ShiftC|)
              (1466 . |monomial|) (1472 . -) (1478 . -) (1483 . ^)
              (1489 . |elt|) (1495 . |monomial|) (1501 . -) (1507 . ^)
              |GUESS;shiftHP;LR;99| (1513 . *) (1519 . |coerce|)
              (1524 . |qShiftAction|) (1532 . |qShiftAction|)
              (1540 . |qShiftC|) (1546 . *) (1552 . |elt|) (|Mapping| 295 291)
              (|StreamTensor| 291) (1558 . |tensorMap|) (1564 . |#|)
              (1569 . |new|) (|SingleInteger|) (1575 . |One|) (1579 . ^)
              (1585 . |rem|) (1591 . |setelt|) (1598 . /) (1604 . |ceiling|)
              (1609 . |rest|) (1614 . |copy|) (1619 . |elt|) (1625 . |cons|)
              (1631 . |reverse!|) (|List| 326) (1636 . |cons|) (1642 . |rem|)
              (1648 . -) (1653 . |reverse!|) (|List| $) (1658 . |concat|)
              (1663 . |Zero|) (|Mapping| 480 124) (|StreamTensor| 124)
              (1667 . |tensorMap|) (|List| 19) (1673 . |first|) (1678 . <)
              (1684 . *) (1690 . |elt|) (1696 . |concat|) (|List| 124)
              (1702 . |cons|) (1708 . |reverse!|) (|Mapping| 40 8)
              (|StreamTensor| 8) (1713 . |tensorMap|) (1719 . |shiftHP|)
              (|Stream| 6) (1724 . |coerce|) (1729 . |series|) (|List| 302)
              (|Stream| 302) (1734 . |coerce|) (|IndexedExponents| 124)
              (1739 . |monomial|) (1745 . |monomial|)
              (|StreamFunctions2| 13 302) (1751 . |map|) (1757 . |concat|)
              (1763 . |series|) (|SparseUnivariatePolynomial| 302)
              (|Mapping| 302 6) (|SparseUnivariatePolynomialFunctions2| 6 302)
              (1768 . |map|) (|UnivariatePolynomial| (NRTEVAL '|x|) 6)
              (1774 . |univariatePolynomial|) (1780 . |makeSUP|) (|List| 57)
              (|Mapping| 57 291) (|ListFunctions2| 291 57) (1785 . |map|)
              (|List| 59) (|Vector| 59) (1791 . |vector|) (|Vector| 6)
              (1796 . |vector|) (1801 . |checkExtraValues|)
              (|SingletonAsOrderedSet|) (1806 . |create|) (1810 . |elt|)
              (1816 . |eval|) (1823 . |retract|) (1828 . |elt|) (1834 . |gcd|)
              (1840 . =) (1846 . *) (1852 . +) (1858 . =) (|Vector| 7)
              (1864 . |elt|) (1870 . |elt|) (1876 . |zero?|) (1881 . |zero?|)
              (1886 . |zero?|) (1891 . |zero?|) (1896 . |zero?|)
              (1901 . |zero?|) (1906 . *) (|List| 500) (|Vector| 500)
              (1912 . |vector|) (1917 . |generalCoefficient|) (1925 . |zero?|)
              (1930 . |print|) (1935 . |coerce|) (1940 . |ground?|)
              (1945 . |variableName|) (|Mapping| 8 6) (|StreamFunctions2| 6 8)
              (1950 . |map|) (|BasicOperator|) (|RecurrenceOperator| 13 8)
              (1956 . |makeFEq|) (1966 . |makeRec|) (1975 . |allDegrees|)
              (|Union| '"skip" '"MonteCarlo" '"deterministic") (1980 . |check|)
              (|Union| '"good" '"reject" '"no_solution") (|Mapping| 557 511)
              (|ModularHermitePadeSolver| 6 7) (1985 . |gen_Monte_Carlo_check|)
              (|Union| 573 50) (1995 . |HP_solve|) (2006 . |elt|)
              (2012 . |setelt|) (2019 . +) (2025 . +) (2031 . +)
              (|Mapping| 124 124 124) (2037 . |reduce|) (2043 . |first|)
              (2049 . |complete|) (2054 . |entries|) (|Matrix| 59)
              (2059 . |generalInterpolation|) (|Vector| 57) (2067 . |vector|)
              (|FractionFreeFastGaussianFractions| 7 59 57)
              (2072 . |generalInterpolation|) (2080 . |ncols|)
              (2085 . |column|) (2091 . |entries|) (2096 . |Zero|)
              (2100 . |new|) (2107 . |elt|) (2114 . |content|) (2119 . |gcd|)
              (2124 . |exquo|) (2130 . |setelt|) (2138 . |explicitlyEmpty?|)
              (|Stream| 573) (2143 . |empty|) (2147 . |empty?|) (2152 . |frst|)
              (2157 . |Zero|) (2161 . |Zero|) (2165 . |false|) (2169 . |true|)
              (|Mapping| 50 13) (2173 . |every?|) (2179 . |rst|)
              (2184 . |concat|) (|Mapping| $) (2190 . |delay|)
              (|Mapping| 13 124) (|ListFunctions2| 124 13) (2195 . |map|)
              (|Stream| 480) (2201 . |genVectorStream|) (|Mapping| 14 480)
              (|StreamFunctions2| 480 14) (2208 . |map|) (2214 . |empty|)
              (2218 . |concat|) (2224 . |functionName|) (2229 . |operator|)
              (2234 . |elt|) (2240 . |rest|) (2246 . |empty?|)
              (2251 . |hconcat|) (2256 . |first|) (2262 . |complete|)
              (2267 . |entries|) (2272 . |coerce|) (2277 . |empty?|)
              (2282 . |first|) (2287 . |rst|) (2292 . |Somos|) (|List| 63)
              (2297 . |concat|) (2302 . |homogeneous|) (2307 . |maxPower|)
              (2312 . |concat|) (2318 . |checkOptions|) (2323 . |displayKind|)
              (2328 . |maxSubst|) |GUESS;guessAlgDep;LLL;128|
              |GUESS;guessAlgDep;LL;129| |GUESS;guessADE;LLL;130|
              |GUESS;guessADE;LL;131| (2333 . |maxDerivative|)
              |GUESS;guessAlg;LLL;132| |GUESS;guessAlg;LL;133|
              |GUESS;guessHolo;LLL;134| |GUESS;guessHolo;LL;135|
              (2338 . |allDegrees|) (2343 . |concat|) |GUESS;guessPade;LLL;136|
              |GUESS;guessPade;LL;137| |GUESS;guessFE;LLL;138|
              |GUESS;guessFE;LL;139| (2348 . |cons|) (2354 . |empty?|)
              (2359 . |append|) (2365 . |reverse!|) (2370 . |guessADE|)
              (2375 . |guessHolo|) |GUESS;guessRec;LLL;142|
              |GUESS;guessRec;LL;143| |GUESS;guessPRec;LLL;144|
              |GUESS;guessPRec;LL;145| (2380 . |maxShift|)
              |GUESS;guessRat;LL;147| (2385 . |guessRec|) (2390 . |guessPRec|)
              (2395 . |guessRat|))
           '#(|substHP| 2400 |shiftHP| 2405 |guessRec| 2415 |guessRat| 2431
              |guessPade| 2447 |guessPRec| 2458 |guessHolo| 2474 |guessFE| 2490
              |guessExpRat| 2501 |guessBinRat| 2517 |guessAlgDep| 2533
              |guessAlg| 2544 |guessADE| 2555 |guess| 2571 |diffHP| 2597
              |algDepHP| 2607)
           'NIL
           (CONS (|makeByteWordVec2| 1 'NIL)
                 (CONS '#()
                       (CONS '#()
                             (|makeByteWordVec2| 665
                                                 '(0 6 0 11 0 7 0 12 2 14 13 0
                                                   13 15 2 13 0 0 0 16 3 14 13
                                                   17 0 13 18 2 13 0 19 0 20 1
                                                   7 21 0 22 2 26 23 24 25 27 1
                                                   28 7 0 29 1 28 7 0 30 2 21 0
                                                   0 0 31 2 34 23 32 33 35 2 23
                                                   21 36 0 37 1 8 0 38 39 2 42
                                                   40 41 21 43 1 8 0 0 44 1 8 0
                                                   13 45 3 8 0 0 0 0 46 0 6 0
                                                   47 0 7 0 48 0 8 0 49 2 8 50
                                                   0 0 51 1 8 0 0 52 2 33 6 0
                                                   13 53 2 8 0 0 0 54 2 6 50 0
                                                   0 55 1 28 0 7 56 2 60 57 58
                                                   59 61 1 64 62 63 65 1 64 38
                                                   63 66 1 64 50 63 67 1 62 68
                                                   0 69 2 68 0 0 0 70 1 72 71
                                                   68 73 1 64 50 63 74 2 21 50
                                                   38 0 75 2 33 50 6 0 76 1 72
                                                   71 77 78 2 6 0 0 0 79 1 8 50
                                                   0 80 1 6 50 0 81 2 33 50 82
                                                   0 83 1 19 68 0 84 2 38 0 0
                                                   85 86 1 87 0 38 88 1 87 0 62
                                                   89 0 8 0 93 2 8 0 0 0 94 2
                                                   95 0 8 8 96 2 97 0 38 95 98
                                                   2 8 0 0 99 100 0 57 0 101 0
                                                   102 0 103 2 8 0 0 0 104 2 40
                                                   50 8 0 105 2 6 0 0 0 106 0
                                                   19 0 107 2 8 0 0 99 108 2 8
                                                   0 0 0 109 1 114 0 6 115 1
                                                   116 0 114 117 1 118 0 7 119
                                                   2 120 0 118 118 121 1 57 50
                                                   0 122 1 57 6 0 123 1 57 124
                                                   0 125 2 8 0 0 124 126 1 57 0
                                                   0 127 1 102 57 0 128 1 102
                                                   57 0 129 2 130 114 58 118
                                                   131 1 132 50 0 133 0 57 0
                                                   134 1 132 118 0 135 1 136 0
                                                   19 137 3 114 0 0 138 33 139
                                                   1 114 6 0 140 1 132 124 0
                                                   141 2 57 0 6 124 142 1 132 0
                                                   0 143 2 57 0 0 0 144 1 147
                                                   145 146 148 2 120 0 0 118
                                                   149 1 120 118 0 150 2 152
                                                   132 151 146 153 1 132 0 118
                                                   154 2 155 0 132 132 156 2
                                                   118 124 0 136 157 1 7 0 13
                                                   158 3 118 0 0 136 7 159 1
                                                   118 59 0 160 1 59 124 0 161
                                                   1 59 7 0 162 2 7 0 0 124 163
                                                   1 7 0 0 164 2 7 0 0 0 165 1
                                                   7 50 0 166 2 59 7 0 0 167 2
                                                   7 168 0 0 169 1 118 0 136
                                                   170 1 120 0 118 171 2 120 0
                                                   0 0 172 2 120 0 0 0 173 1 14
                                                   13 0 174 1 13 0 0 175 2 120
                                                   0 0 13 176 1 64 62 63 177 1
                                                   124 68 0 178 1 179 71 77 180
                                                   3 183 181 182 182 124 184 2
                                                   146 120 185 120 186 2 120 0
                                                   0 0 187 1 120 118 0 188 1
                                                   189 59 25 190 2 59 0 0 0 191
                                                   1 59 0 0 192 1 194 193 57
                                                   195 1 193 197 0 198 2 57 6 0
                                                   124 199 1 6 0 0 200 3 114 0
                                                   0 136 6 201 1 114 50 0 202 1
                                                   114 57 0 203 1 181 146 0 204
                                                   1 181 146 0 205 2 155 0 0 0
                                                   206 1 155 132 0 207 1 155
                                                   132 0 208 2 102 0 57 57 209
                                                   1 210 0 38 211 3 8 0 0 212 0
                                                   213 2 8 0 0 0 214 1 64 124
                                                   63 215 2 33 0 0 124 216 2 13
                                                   0 0 0 217 2 13 50 0 0 218 2
                                                   40 0 219 0 220 1 0 90 38 223
                                                   2 118 0 13 0 224 2 118 0 0 0
                                                   225 1 118 0 13 226 2 118 0 0
                                                   0 227 2 118 0 0 0 228 0 118
                                                   0 229 3 231 118 230 0 118
                                                   232 1 13 0 0 233 2 8 0 0 0
                                                   234 2 120 0 0 0 235 3 118 0
                                                   0 0 136 236 0 120 0 239 1 6
                                                   0 38 240 3 182 120 241 0 120
                                                   242 1 0 90 38 243 1 64 244
                                                   63 245 1 64 246 63 247 1 64
                                                   62 63 248 1 64 246 63 249 2
                                                   251 250 13 13 252 1 13 0 0
                                                   253 2 255 0 254 13 256 2 124
                                                   0 0 0 257 3 251 250 13 13 13
                                                   258 2 261 259 260 255 262 1
                                                   251 250 13 263 1 264 250 259
                                                   265 2 250 0 14 0 266 1 251
                                                   250 250 267 1 14 124 0 268 2
                                                   124 50 0 0 269 2 250 0 270 0
                                                   271 2 7 0 0 0 272 0 124 0
                                                   273 2 13 50 0 0 274 1 276
                                                   275 14 277 1 14 13 0 278 2
                                                   40 8 279 0 280 1 281 0 14
                                                   282 3 283 281 281 124 13 284
                                                   4 283 281 281 19 124 13 285
                                                   4 283 281 281 281 13 13 286
                                                   2 288 281 287 0 289 3 283 71
                                                   281 281 13 290 2 291 0 0 124
                                                   292 2 291 0 0 0 293 2 295
                                                   291 294 0 296 2 6 0 0 124
                                                   297 2 291 0 298 0 299 2 300
                                                   291 291 291 301 2 302 0 0
                                                   124 303 2 305 0 304 0 306 2
                                                   307 305 305 305 308 2 310
                                                   305 309 0 311 2 314 312 313
                                                   250 315 0 120 0 316 0 114 0
                                                   317 0 155 0 318 0 291 0 319
                                                   0 305 0 320 0 57 0 321 0 114
                                                   0 322 0 155 0 323 0 291 0
                                                   324 0 305 0 325 3 326 281 0
                                                   13 281 327 2 283 281 281 13
                                                   328 2 305 0 0 0 329 0 330 0
                                                   331 0 302 0 332 3 333 305 0
                                                   13 305 334 2 276 168 0 0 335
                                                   2 336 13 276 0 337 1 338 336
                                                   0 339 1 276 14 0 340 1 276 0
                                                   14 341 1 342 275 0 343 2 342
                                                   275 0 275 344 2 338 336 0
                                                   336 345 2 13 0 0 0 346 1 14
                                                   13 0 347 2 349 14 348 275
                                                   350 2 14 13 17 0 351 1 342 0
                                                   275 352 1 338 0 336 353 1
                                                   288 124 0 354 0 124 0 355 1
                                                   288 281 0 356 1 326 0 288
                                                   357 1 333 0 310 358 2 361
                                                   359 360 250 362 1 14 50 0
                                                   363 2 124 0 0 0 364 3 367
                                                   365 124 366 250 368 3 8 0 0
                                                   38 124 369 2 291 0 0 124 370
                                                   2 305 0 0 124 371 3 372 7
                                                   124 124 59 373 3 374 302 124
                                                   124 305 375 1 372 25 124 376
                                                   1 64 124 63 377 1 64 38 63
                                                   378 2 250 0 0 124 379 1 250
                                                   0 0 380 1 250 275 0 381 2
                                                   250 14 0 13 382 2 40 8 0 13
                                                   395 1 64 21 63 396 1 38 0 77
                                                   397 2 398 33 0 13 399 2 367
                                                   365 400 250 401 2 291 0 0 19
                                                   403 2 305 0 0 19 404 2 13 0
                                                   124 0 406 2 291 0 407 0 408
                                                   0 302 0 409 1 302 0 6 410 2
                                                   305 0 411 0 412 1 124 50 0
                                                   413 2 38 50 0 0 414 1 0 415
                                                   38 416 1 291 0 0 417 2 419
                                                   418 418 124 420 1 305 0 0
                                                   421 2 423 422 422 124 424 2
                                                   425 13 13 13 426 3 372 7 124
                                                   124 59 427 3 374 302 124 124
                                                   305 428 1 372 25 124 429 2
                                                   291 0 6 124 430 2 291 0 0 0
                                                   431 1 330 0 0 432 2 291 0 0
                                                   330 433 2 365 124 0 13 434 2
                                                   305 0 302 124 435 2 305 0 0
                                                   0 436 2 305 0 0 330 437 2 8
                                                   0 124 0 439 1 7 0 38 440 4
                                                   372 7 7 124 124 59 441 4 374
                                                   302 302 124 124 305 442 2
                                                   372 25 7 124 443 2 291 0 6 0
                                                   444 2 291 0 0 0 445 2 447
                                                   312 312 446 448 1 281 124 0
                                                   449 2 281 0 124 13 450 0 451
                                                   0 452 2 13 0 0 124 453 2 13
                                                   0 0 0 454 3 281 13 0 13 13
                                                   455 2 330 0 13 13 456 1 330
                                                   13 0 457 1 288 0 0 458 1 281
                                                   0 0 459 2 281 13 0 13 460 2
                                                   288 0 281 0 461 1 288 0 0
                                                   462 2 463 0 326 0 464 2 124
                                                   0 0 0 465 1 451 0 0 466 1
                                                   463 0 0 467 1 326 0 468 469
                                                   0 451 0 470 2 472 365 365
                                                   471 473 1 474 19 0 475 2 19
                                                   50 0 0 476 2 305 0 302 0 477
                                                   2 305 0 0 0 478 2 310 0 0 0
                                                   479 2 480 0 124 0 481 1 310
                                                   0 0 482 2 484 359 359 483
                                                   485 1 0 415 38 486 1 487 0
                                                   33 488 1 291 0 487 489 1 491
                                                   0 490 492 2 493 0 124 124
                                                   494 2 302 0 6 493 495 2 496
                                                   491 411 255 497 2 491 0 0 0
                                                   498 1 305 0 491 499 2 502
                                                   500 501 57 503 2 291 504 0
                                                   124 505 1 504 57 0 506 2 509
                                                   507 508 295 510 1 512 0 511
                                                   513 1 514 0 33 515 1 64 50
                                                   63 516 0 517 0 518 2 512 59
                                                   0 13 519 3 59 0 0 517 7 520
                                                   1 59 7 0 521 2 514 6 0 13
                                                   522 2 7 0 0 0 523 2 7 50 0 0
                                                   524 2 28 0 7 0 525 2 28 0 0
                                                   0 526 2 28 50 0 0 527 2 528
                                                   7 0 13 529 2 511 59 0 13 530
                                                   1 59 50 0 531 1 8 50 0 532 1
                                                   291 50 0 533 1 13 50 0 534 1
                                                   305 50 0 535 1 6 50 0 536 2
                                                   124 0 19 0 537 1 539 0 538
                                                   540 4 374 302 390 333 124
                                                   539 541 1 302 50 0 542 1 68
                                                   71 0 543 1 13 68 0 544 1 302
                                                   50 0 545 1 64 38 63 546 2
                                                   548 359 547 487 549 6 551 8
                                                   550 38 38 8 40 359 552 5 551
                                                   8 550 38 8 40 359 553 1 64
                                                   50 63 554 1 64 555 63 556 6
                                                   559 558 558 398 38 38 124
                                                   384 560 7 559 561 398 14 38
                                                   38 124 384 558 562 2 480 124
                                                   0 13 563 3 480 124 0 13 124
                                                   564 2 291 0 0 0 565 2 305 0
                                                   0 0 566 2 6 0 0 0 567 2 480
                                                   124 568 0 569 2 312 0 0 124
                                                   570 1 312 0 0 571 1 312 295
                                                   0 572 4 372 573 25 389 512
                                                   480 574 1 575 0 507 576 4
                                                   577 573 25 389 575 480 578 1
                                                   573 124 0 579 2 573 512 0 13
                                                   580 1 512 511 0 581 0 59 0
                                                   582 3 573 0 124 124 59 583 3
                                                   573 59 0 13 13 584 1 59 7 0
                                                   585 1 7 0 468 586 2 59 168 0
                                                   7 587 4 573 59 0 13 13 59
                                                   588 1 250 50 0 589 0 590 0
                                                   591 1 250 50 0 592 1 250 14
                                                   0 593 0 13 0 594 0 500 0 595
                                                   0 50 0 596 0 50 0 597 2 14
                                                   50 598 0 599 1 250 0 0 600 2
                                                   590 0 573 0 601 1 590 0 602
                                                   603 2 605 14 604 480 606 3
                                                   372 607 124 124 124 608 2
                                                   610 250 609 607 611 0 250 0
                                                   612 2 250 0 14 0 613 1 64 38
                                                   63 614 1 550 0 38 615 2 8 0
                                                   550 0 616 2 365 0 0 124 617
                                                   1 365 50 0 618 1 68 0 468
                                                   619 2 359 0 0 124 620 1 359
                                                   0 0 621 1 359 40 0 622 1 40
                                                   68 0 623 1 590 50 0 624 1
                                                   590 573 0 625 1 590 0 0 626
                                                   1 87 0 246 627 1 628 0 468
                                                   629 1 87 0 246 630 1 87 0
                                                   244 631 2 63 0 0 0 632 1 64
                                                   71 63 633 1 87 0 38 634 1 87
                                                   0 244 635 1 87 0 62 640 1 87
                                                   0 50 645 1 63 0 468 646 2 63
                                                   0 87 0 651 1 40 50 0 652 2
                                                   40 0 0 0 653 1 40 0 0 654 1
                                                   0 90 38 655 1 0 90 38 656 1
                                                   87 0 62 661 1 0 90 38 663 1
                                                   0 90 38 664 1 0 90 38 665 1
                                                   0 393 63 405 1 1 415 38 486
                                                   1 0 393 63 438 1 1 90 38 663
                                                   2 0 40 33 63 657 1 0 40 33
                                                   658 1 1 90 38 665 2 0 40 33
                                                   63 110 1 0 40 33 662 2 0 40
                                                   33 63 647 1 0 40 33 648 1 1
                                                   90 38 664 1 0 40 33 660 2 0
                                                   40 33 63 659 1 1 90 38 656 1
                                                   0 40 33 644 2 0 40 33 63 643
                                                   2 0 40 33 63 649 1 0 40 33
                                                   650 1 1 90 38 223 2 0 40 33
                                                   63 222 1 0 40 33 221 1 1 90
                                                   38 243 1 0 40 33 237 2 0 40
                                                   33 63 238 1 0 40 398 637 2 0
                                                   40 398 63 636 1 0 40 33 642
                                                   2 0 40 33 63 641 1 1 90 38
                                                   655 2 0 40 33 63 638 1 0 40
                                                   33 639 2 0 40 33 63 112 1 0
                                                   40 33 111 4 0 40 33 91 21 63
                                                   92 3 0 40 33 91 21 113 1 1
                                                   415 38 416 1 0 393 63 394 2
                                                   0 393 398 63 402)))))
           '|lookupComplete|)) 
