
(/VERSIONCHECK 2) 

(DEFUN |GUESS;ord1| (|x| |i| $)
  (PROG (|n| #0=#:G55176 #1=#:G55177 |j| #2=#:G55178 |k| #3=#:G55179)
    (RETURN
      (SEQ (LETT |n| (- (- (LENGTH |x|) 3) |i|) . #4=(|GUESS;ord1|))
           (EXIT (+ (* (SPADCALL |x| (+ |n| 1) (QREFELT $ 16))
                       (SPADCALL (ELT $ 17)
                           (PROGN
                             (LETT #0# NIL . #4#)
                             (SEQ (LETT |j| 1 . #4#) G190
                                  (COND
                                    ((QSGREATERP |j| |n|) #5=(GO G191)))
                                  (SEQ (EXIT
                                        (LETT #0#
                                         (CONS
                                          (SPADCALL |x| |j|
                                           (QREFELT $ 16))
                                          #0#) . #4#)))
                                  (LETT |j| (QSADD1 |j|) . #4#)
                                  #6=(GO G190) G191
                                  (EXIT (NREVERSE0 #0#))))
                           0 (QREFELT $ 19)))
                    (SPADCALL 2
                        (SPADCALL (ELT $ 17)
                            (PROGN
                              (LETT #1# NIL . #4#)
                              (SEQ (LETT |j| 1 . #4#) G190
                                   (COND ((QSGREATERP |j| |n|) #5#))
                                   (SEQ
                                    (EXIT
                                     (LETT #1#
                                      (CONS
                                       (SPADCALL (ELT $ 17)
                                        (PROGN
                                          (LETT #2# NIL . #4#)
                                          (SEQ (LETT |k| 1 . #4#)
                                           (LETT #3# (- |j| 1) . #4#)
                                           G190
                                           (COND
                                             ((QSGREATERP |k| #3#) #5#))
                                           (SEQ
                                            (EXIT
                                             (LETT #2#
                                              (CONS
                                               (*
                                                (SPADCALL |x| |k|
                                                 (QREFELT $ 16))
                                                (SPADCALL |x| |j|
                                                 (QREFELT $ 16)))
                                               #2#) . #4#)))
                                           (LETT |k|
                                            (QSADD1 |k|) . #4#)
                                           #6# G191
                                           (EXIT (NREVERSE0 #2#))))
                                        0 (QREFELT $ 19))
                                       #1#) . #4#)))
                                   (LETT |j| (QSADD1 |j|) . #4#) #6#
                                   G191 (EXIT (NREVERSE0 #1#))))
                            0 (QREFELT $ 19))
                        (QREFELT $ 21)))))))) 

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

(DEFUN |GUESS;deg1| (|x| |i| $)
  (PROG (|m| #0=#:G55190 #1=#:G55191 |j| #2=#:G55192 |k| #3=#:G55193)
    (RETURN
      (SEQ (LETT |m| (- (LENGTH |x|) 3) . #4=(|GUESS;deg1|))
           (EXIT (+ (+ (* (+ (+ (SPADCALL |x| (+ |m| 3) (QREFELT $ 16))
                                (SPADCALL |x| (+ |m| 1) (QREFELT $ 16)))
                             (SPADCALL |x| (+ 1 |i|) (QREFELT $ 16)))
                          (SPADCALL (ELT $ 17)
                              (PROGN
                                (LETT #0# NIL . #4#)
                                (SEQ (LETT |j| (+ 2 |i|) . #4#) G190
                                     (COND ((> |j| |m|) #5=(GO G191)))
                                     (SEQ
                                      (EXIT
                                       (LETT #0#
                                        (CONS
                                         (SPADCALL |x| |j|
                                          (QREFELT $ 16))
                                         #0#) . #4#)))
                                     (LETT |j| (+ |j| 1) . #4#)
                                     #6=(GO G190) G191
                                     (EXIT (NREVERSE0 #0#))))
                              0 (QREFELT $ 19)))
                       (* (SPADCALL |x| (+ |m| 3) (QREFELT $ 16))
                          (SPADCALL |x| (+ |m| 1) (QREFELT $ 16))))
                    (SPADCALL 2
                        (SPADCALL (ELT $ 17)
                            (PROGN
                              (LETT #1# NIL . #4#)
                              (SEQ (LETT |j| (+ 2 |i|) . #4#) G190
                                   (COND ((> |j| |m|) #5#))
                                   (SEQ
                                    (EXIT
                                     (LETT #1#
                                      (CONS
                                       (SPADCALL (ELT $ 17)
                                        (PROGN
                                          (LETT #2# NIL . #4#)
                                          (SEQ
                                           (LETT |k| (+ 2 |i|) . #4#)
                                           (LETT #3# (- |j| 1) . #4#)
                                           G190
                                           (COND ((> |k| #3#) #5#))
                                           (SEQ
                                            (EXIT
                                             (LETT #2#
                                              (CONS
                                               (*
                                                (SPADCALL |x| |k|
                                                 (QREFELT $ 16))
                                                (SPADCALL |x| |j|
                                                 (QREFELT $ 16)))
                                               #2#) . #4#)))
                                           (LETT |k| (+ |k| 1) . #4#)
                                           #6# G191
                                           (EXIT (NREVERSE0 #2#))))
                                        0 (QREFELT $ 19))
                                       #1#) . #4#)))
                                   (LETT |j| (+ |j| 1) . #4#) #6# G191
                                   (EXIT (NREVERSE0 #1#))))
                            0 (QREFELT $ 19))
                        (QREFELT $ 21)))))))) 

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

(DEFUN |GUESS;checkResult| (|res| |n| |l| |list| |options| $)
  (PROG (|i| |den| #0=#:G55198 |num| #1=#:G55199 #2=#:G55203)
    (RETURN
      (SEQ (EXIT (SEQ (SEQ (LETT |i| |l| . #3=(|GUESS;checkResult|))
                           G190 (COND ((< |i| 1) (GO G191)))
                           (SEQ (LETT |den|
                                      (SPADCALL
                                       (SPADCALL |res| (QREFELT $ 22))
                                       (SPADCALL |n| (QREFELT $ 24))
                                       (SPADCALL (- |i| 1)
                                        (QREFELT $ 25))
                                       (QREFELT $ 26)) . #3#)
                                (COND
                                  ((SPADCALL |den|
                                    (|spadConstant| $ 29)
                                    (QREFELT $ 31))
                                   (PROGN
                                     (LETT #2#
                                      (PROG1 (LETT #0# |i| . #3#)
                                        (|check-subtype| (>= #0# 0)
                                         '(|NonNegativeInteger|) #0#)) . #3#)
                                     (GO #2#))))
                                (LETT |num|
                                      (SPADCALL
                                       (SPADCALL |res| (QREFELT $ 32))
                                       (SPADCALL |n| (QREFELT $ 24))
                                       (SPADCALL (- |i| 1)
                                        (QREFELT $ 25))
                                       (QREFELT $ 26)) . #3#)
                                (EXIT (COND
                                        ((SPADCALL
                                          (SPADCALL |list| |i|
                                           (QREFELT $ 34))
                                          (SPADCALL
                                           (SPADCALL
                                            (SPADCALL |num| |den|
                                             (QREFELT $ 35))
                                            (QREFELT $ 36))
                                           (QREFELT $ 10))
                                          (QREFELT $ 37))
                                         (PROGN
                                           (LETT #2#
                                            (PROG1 (LETT #1# |i| . #3#)
                                              (|check-subtype|
                                               (>= #1# 0)
                                               '(|NonNegativeInteger|)
                                               #1#)) . #3#)
                                           (GO #2#))))))
                           (LETT |i| (+ |i| -1) . #3#) (GO G190) G191
                           (EXIT NIL))
                      (EXIT 0)))
           #2# (EXIT #2#))))) 

(DEFUN |GUESS;SUPS2SUPF| (|p| $)
  (COND
    ((|domainEqual| (QREFELT $ 6) (QREFELT $ 7)) |p|)
    ((|domainEqual| (QREFELT $ 6) (|Fraction| (QREFELT $ 7)))
     (SPADCALL (CONS #'|GUESS;SUPS2SUPF!0| $) |p| (QREFELT $ 44)))
    ('T
     (|error| "Type parameter F should be either equal to S or equal                       to Fraction S")))) 

(DEFUN |GUESS;SUPS2SUPF!0| (|#1| $) (SPADCALL |#1| (QREFELT $ 39))) 

(DEFUN |GUESS;F2FPOLYS| (|p| $)
  (COND
    ((|domainEqual| (QREFELT $ 6) (QREFELT $ 7))
     (SPADCALL (SPADCALL |p| (QREFELT $ 46)) (QREFELT $ 48)))
    ((|domainEqual| (QREFELT $ 6) (|Fraction| (QREFELT $ 7)))
     (SPADCALL (SPADCALL (SPADCALL |p| (QREFELT $ 49)) (QREFELT $ 51))
         (SPADCALL (SPADCALL |p| (QREFELT $ 52)) (QREFELT $ 51))
         (QREFELT $ 54)))
    ('T
     (|error| "Type parameter F should be either equal to S or equal                        to Fraction S")))) 

(DEFUN |GUESS;SUPF2EXPRR| (|xx| |p| $)
  (COND
    ((SPADCALL |p| (QREFELT $ 55)) (|spadConstant| $ 29))
    ('T
     (SPADCALL
         (SPADCALL
             (SPADCALL (SPADCALL |p| (QREFELT $ 56)) (QREFELT $ 11))
             (SPADCALL (SPADCALL |xx| (QREFELT $ 24))
                 (SPADCALL |p| (QREFELT $ 58)) (QREFELT $ 59))
             (QREFELT $ 60))
         (|GUESS;SUPF2EXPRR| |xx| (SPADCALL |p| (QREFELT $ 61)) $)
         (QREFELT $ 62))))) 

(DEFUN |GUESS;FSUPF2EXPRR| (|xx| |p| $)
  (SPADCALL (|GUESS;SUPF2EXPRR| |xx| (SPADCALL |p| (QREFELT $ 64)) $)
            (|GUESS;SUPF2EXPRR| |xx| (SPADCALL |p| (QREFELT $ 65)) $)
            (QREFELT $ 35))) 

(DEFUN |GUESS;POLYS2POLYF| (|p| $)
  (COND
    ((|domainEqual| (QREFELT $ 6) (QREFELT $ 7)) |p|)
    ((|domainEqual| (QREFELT $ 6) (|Fraction| (QREFELT $ 7)))
     (SPADCALL (CONS #'|GUESS;POLYS2POLYF!0| $) |p| (QREFELT $ 67)))
    ('T
     (|error| "Type parameter F should be either equal to S or equal                       to Fraction S")))) 

(DEFUN |GUESS;POLYS2POLYF!0| (|#1| $) (SPADCALL |#1| (QREFELT $ 39))) 

(DEFUN |GUESS;SUPPOLYS2SUPF| (|p| |a1v| |Av| $)
  (PROG (|lc|)
    (RETURN
      (SEQ (COND
             ((SPADCALL |p| (QREFELT $ 69)) (|spadConstant| $ 70))
             ('T
              (SEQ (LETT |lc|
                         (|GUESS;POLYS2POLYF|
                             (SPADCALL |p| (QREFELT $ 71)) $)
                         |GUESS;SUPPOLYS2SUPF|)
                   (EXIT (SPADCALL
                             (SPADCALL
                                 (SPADCALL
                                     (SPADCALL |lc|
                                      (LIST (SPADCALL 1 (QREFELT $ 73))
                                       (SPADCALL 2 (QREFELT $ 73)))
                                      (LIST |a1v| |Av|) (QREFELT $ 75))
                                     (QREFELT $ 76))
                                 (SPADCALL |p| (QREFELT $ 77))
                                 (QREFELT $ 78))
                             (|GUESS;SUPPOLYS2SUPF|
                                 (SPADCALL |p| (QREFELT $ 79)) |a1v|
                                 |Av| $)
                             (QREFELT $ 80)))))))))) 

(DEFUN |GUESS;SUPFPOLYS2FSUPPOLYS| (|p| $)
  (PROG (|cden| |pnum| |pden|)
    (RETURN
      (SEQ (LETT |cden| (SPADCALL |p| (QREFELT $ 84))
                 . #0=(|GUESS;SUPFPOLYS2FSUPPOLYS|))
           (LETT |pnum|
                 (SPADCALL
                     (CONS #'|GUESS;SUPFPOLYS2FSUPPOLYS!0|
                           (VECTOR $ |cden|))
                     |p| (QREFELT $ 89)) . #0#)
           (LETT |pden| (SPADCALL (QCDR |cden|) (QREFELT $ 90)) . #0#)
           (EXIT (SPADCALL |pnum| |pden| (QREFELT $ 92))))))) 

(DEFUN |GUESS;SUPFPOLYS2FSUPPOLYS!0| (|#1| $$)
  (PROG ($)
    (LETT $ (QREFELT $$ 0) |GUESS;SUPFPOLYS2FSUPPOLYS|)
    (RETURN
      (PROGN
        (SPADCALL (SPADCALL |#1| (QCDR (QREFELT $$ 1)) (QREFELT $ 85))
            (QREFELT $ 86)))))) 

(DEFUN |GUESS;POLYF2EXPRR| (|p| $)
  (SPADCALL (CONS #'|GUESS;POLYF2EXPRR!0| $)
      (CONS #'|GUESS;POLYF2EXPRR!1| (QREFELT $ 11)) |p| (QREFELT $ 97))) 

(DEFUN |GUESS;POLYF2EXPRR!1| (|#1| |coerce|) (SPADCALL |#1| |coerce|)) 

(DEFUN |GUESS;POLYF2EXPRR!0| (|#1| $)
  (SPADCALL (SPADCALL |#1| (QREFELT $ 93)) (QREFELT $ 24))) 

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

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

(DEFUN |GUESS;DN2DL| (DN |i| $)
  (SPADCALL
      (SPADCALL (SPADCALL (SPADCALL |i| (QREFELT $ 25)) DN)
                (QREFELT $ 36))
      (QREFELT $ 10))) 

(DEFUN |GUESS;evalResultant| (|p1| |p2| |o| |d| |va1| |vA| $)
  (PROG (|d1| |d2| |k| #0=#:G55244 |p1atk| |p2atk| |d1atk| |d2atk|
              #1=#:G55225 #2=#:G55227 |lead| #3=#:G55233 #4=#:G55238
              |res|)
    (RETURN
      (SEQ (LETT |res| NIL . #5=(|GUESS;evalResultant|))
           (LETT |d1| (SPADCALL |p1| |va1| (QREFELT $ 98)) . #5#)
           (LETT |d2| (SPADCALL |p2| |va1| (QREFELT $ 98)) . #5#)
           (SEQ (LETT |k| 1 . #5#) (LETT #0# (+ (- |d| |o|) 1) . #5#)
                G190 (COND ((QSGREATERP |k| #0#) (GO G191)))
                (SEQ (LETT |p1atk|
                           (SPADCALL (SPADCALL |p1| |vA|
                                      (SPADCALL |k| (QREFELT $ 99))
                                      (QREFELT $ 100))
                                     (QREFELT $ 101)) . #5#)
                     (LETT |p2atk|
                           (SPADCALL
                               (SPADCALL |p2| |vA|
                                   (SPADCALL |k| (QREFELT $ 99))
                                   (QREFELT $ 100))
                               (QREFELT $ 101)) . #5#)
                     (LETT |d1atk|
                           (SPADCALL |p1atk| (QREFELT $ 102)) . #5#)
                     (LETT |d2atk|
                           (SPADCALL |p2atk| (QREFELT $ 102)) . #5#)
                     (COND
                       ((< |d2atk| |d2|)
                        (COND
                          ((< |d1atk| |d1|)
                           (LETT |lead| (|spadConstant| $ 28) . #5#))
                          ('T
                           (LETT |lead|
                                 (SPADCALL
                                     (SPADCALL |p1atk| (QREFELT $ 103))
                                     (PROG1
                                      (LETT #1# (- |d2| |d2atk|) . #5#)
                                       (|check-subtype| (>= #1# 0)
                                        '(|NonNegativeInteger|) #1#))
                                     (QREFELT $ 104)) . #5#))))
                       ((< |d1atk| |d1|)
                        (LETT |lead|
                              (SPADCALL
                                  (SPADCALL
                                      (SPADCALL (|spadConstant| $ 13)
                                       (QREFELT $ 105))
                                      |d2| (QREFELT $ 104))
                                  (SPADCALL
                                      (SPADCALL |p2atk|
                                       (QREFELT $ 103))
                                      (PROG1
                                       (LETT #2#
                                        (- |d1| |d1atk|) . #5#)
                                        (|check-subtype| (>= #2# 0)
                                         '(|NonNegativeInteger|) #2#))
                                      (QREFELT $ 104))
                                  (QREFELT $ 106)) . #5#))
                       ('T (LETT |lead| (|spadConstant| $ 13) . #5#)))
                     (EXIT (COND
                             ((SPADCALL |lead| (QREFELT $ 107))
                              (LETT |res|
                                    (CONS (|spadConstant| $ 28) |res|) . #5#))
                             ('T
                              (LETT |res|
                                    (CONS
                                     (SPADCALL |lead|
                                      (PROG2
                                       (LETT #4#
                                        (SPADCALL
                                         (SPADCALL |p1atk| |p2atk|
                                          (QREFELT $ 108))
                                         (SPADCALL
                                          (SPADCALL |k| (QREFELT $ 99))
                                          (PROG1 (LETT #3# |o| . #5#)
                                            (|check-subtype| (>= #3# 0)
                                             '(|NonNegativeInteger|)
                                             #3#))
                                          (QREFELT $ 104))
                                         (QREFELT $ 110)) . #5#)
                                       (QCDR #4#)
                                        (|check-union| (QEQCAR #4# 0)
                                         (QREFELT $ 7) #4#))
                                      (QREFELT $ 106))
                                     |res|) . #5#)))))
                (LETT |k| (QSADD1 |k|) . #5#) (GO G190) G191
                (EXIT NIL))
           (EXIT (REVERSE |res|)))))) 

(DEFUN |GUESS;p| (|xm| |i| |va1| |vA| |basis| $)
  (SPADCALL (SPADCALL (SPADCALL |vA| (QREFELT $ 111)) (QREFELT $ 112))
      (SPADCALL
          (SPADCALL (SPADCALL |va1| (QREFELT $ 111)) (QREFELT $ 112))
          (|GUESS;F2FPOLYS|
              (SPADCALL (|GUESS;DN2DL| |basis| |i| $)
                  (|GUESS;DN2DL| |basis| |xm| $) (QREFELT $ 113))
              $)
          (QREFELT $ 114))
      (QREFELT $ 115))) 

(DEFUN |GUESS;p2| (|xm| |i| |a1v| |Av| |basis| $)
  (SPADCALL (SPADCALL |Av| (QREFELT $ 11))
      (SPADCALL (SPADCALL |a1v| (QREFELT $ 11))
          (SPADCALL (SPADCALL (SPADCALL |i| (QREFELT $ 24)) |basis|)
              (SPADCALL (SPADCALL |xm| (QREFELT $ 25)) |basis|)
              (QREFELT $ 116))
          (QREFELT $ 60))
      (QREFELT $ 62))) 

(DEFUN |GUESS;guessExpRatAux|
       (|xx| |list| |basis| |xValues| |options| $)
  (PROG (|a1| A #0=#:G55247 |len| #1=#:G55285 |xlist| |x1| |x2| |x3|
              |y| #2=#:G55286 |ylist| |y1| |y2| |y3| |maxDeg| |i|
              #3=#:G55254 |ri| |poly1| |poly2| |poly3| |n| |o1| |d1|
              |o2| |d2| |res1| |res2| |res3| |f| #4=#:G55287 |Av|
              |evalPoly| |g| #5=#:G55288 |a1v| |t1| |t2| |ri1| |numr|
              |denr| |res4| |res| #6=#:G55284)
    (RETURN
      (SEQ (EXIT (SEQ (LETT |a1| (SPADCALL 1 (QREFELT $ 73))
                            . #7=(|GUESS;guessExpRatAux|))
                      (LETT A (SPADCALL 2 (QREFELT $ 73)) . #7#)
                      (LETT |len| (LENGTH |list|) . #7#)
                      (COND
                        ((< |len| 4)
                         (PROGN (LETT #6# NIL . #7#) (GO #6#)))
                        ('T
                         (LETT |len|
                               (PROG1 (LETT #0# (- |len| 3) . #7#)
                                 (|check-subtype| (>= #0# 0)
                                     '(|NonNegativeInteger|) #0#)) . #7#)))
                      (LETT |xlist|
                            (PROGN
                              (LETT #1# NIL . #7#)
                              (SEQ (LETT |i| 1 . #7#) G190
                                   (COND
                                     ((QSGREATERP |i| |len|)
                                      #8=(GO G191)))
                                   (SEQ
                                    (EXIT
                                     (LETT #1#
                                      (CONS
                                       (|GUESS;F2FPOLYS|
                                        (|GUESS;DN2DL| |basis|
                                         (SPADCALL |xValues| |i|
                                          (QREFELT $ 16))
                                         $)
                                        $)
                                       #1#) . #7#)))
                                   (LETT |i| (QSADD1 |i|) . #7#)
                                   #9=(GO G190) G191
                                   (EXIT (NREVERSE0 #1#)))) . #7#)
                      (LETT |x1|
                            (|GUESS;F2FPOLYS|
                                (|GUESS;DN2DL| |basis|
                                    (SPADCALL |xValues| (+ |len| 1)
                                     (QREFELT $ 16))
                                    $)
                                $) . #7#)
                      (LETT |x2|
                            (|GUESS;F2FPOLYS|
                                (|GUESS;DN2DL| |basis|
                                    (SPADCALL |xValues| (+ |len| 2)
                                     (QREFELT $ 16))
                                    $)
                                $) . #7#)
                      (LETT |x3|
                            (|GUESS;F2FPOLYS|
                                (|GUESS;DN2DL| |basis|
                                    (SPADCALL |xValues| (+ |len| 3)
                                     (QREFELT $ 16))
                                    $)
                                $) . #7#)
                      (LETT |y|
                            (CONS #'|GUESS;guessExpRatAux!0|
                                  (VECTOR |basis| A |a1| |xValues| $
                                          |list|)) . #7#)
                      (LETT |ylist|
                            (PROGN
                              (LETT #2# NIL . #7#)
                              (SEQ (LETT |i| 1 . #7#) G190
                                   (COND ((QSGREATERP |i| |len|) #8#))
                                   (SEQ
                                    (EXIT
                                     (LETT #2#
                                      (CONS (SPADCALL |i| |y|) #2#) . #7#)))
                                   (LETT |i| (QSADD1 |i|) . #7#) #9#
                                   G191 (EXIT (NREVERSE0 #2#)))) . #7#)
                      (LETT |y1| (SPADCALL (+ |len| 1) |y|) . #7#)
                      (LETT |y2| (SPADCALL (+ |len| 2) |y|) . #7#)
                      (LETT |y3| (SPADCALL (+ |len| 3) |y|) . #7#)
                      (LETT |res| NIL . #7#)
                      (COND
                        ((EQL (SPADCALL |options| (QREFELT $ 123)) -1)
                         (LETT |maxDeg| (- |len| 1) . #7#))
                        ('T
                         (LETT |maxDeg|
                               (MIN (SPADCALL |options|
                                     (QREFELT $ 123))
                                    (- |len| 1)) . #7#)))
                      (SEQ (LETT |i| 0 . #7#) G190
                           (COND ((QSGREATERP |i| |maxDeg|) #8#))
                           (SEQ (COND
                                  ((SPADCALL |options| (QREFELT $ 124))
                                   (SPADCALL
                                    (SPADCALL "degree ExpRat "
                                     (SPADCALL |i| (QREFELT $ 126))
                                     (QREFELT $ 127))
                                    (QREFELT $ 130))))
                                (COND
                                  ((SPADCALL |options| (QREFELT $ 124))
                                   (SEQ
                                    (SPADCALL "sys date +%s"
                                     (QREFELT $ 133))
                                    (EXIT
                                     (SPADCALL "interpolating..."
                                      (QREFELT $ 130))))))
                                (LETT |ri|
                                      (SPADCALL |xlist| |ylist|
                                       (PROG1
                                        (LETT #3#
                                         (- (- |len| 1) |i|) . #7#)
                                         (|check-subtype| (>= #3# 0)
                                          '(|NonNegativeInteger|) #3#))
                                       (QREFELT $ 137)) . #7#)
                                (COND
                                  ((SPADCALL |options| (QREFELT $ 124))
                                   (SEQ
                                    (SPADCALL "sys date +%s"
                                     (QREFELT $ 133))
                                    (EXIT
                                     (SPADCALL "polynomials..."
                                      (QREFELT $ 130))))))
                                (LETT |poly1|
                                      (SPADCALL
                                       (SPADCALL
                                        (SPADCALL |ri| |x1|
                                         (QREFELT $ 139))
                                        |y1| (QREFELT $ 140))
                                       (QREFELT $ 141)) . #7#)
                                (LETT |poly2|
                                      (SPADCALL
                                       (SPADCALL
                                        (SPADCALL |ri| |x2|
                                         (QREFELT $ 139))
                                        |y2| (QREFELT $ 140))
                                       (QREFELT $ 141)) . #7#)
                                (LETT |poly3|
                                      (SPADCALL
                                       (SPADCALL
                                        (SPADCALL |ri| |x3|
                                         (QREFELT $ 139))
                                        |y3| (QREFELT $ 140))
                                       (QREFELT $ 141)) . #7#)
                                (LETT |n| (- |len| |i|) . #7#)
                                (LETT |o1|
                                      (|GUESS;ord1| |xValues| |i| $) . #7#)
                                (LETT |d1|
                                      (|GUESS;deg1| |xValues| |i| $) . #7#)
                                (LETT |o2|
                                      (|GUESS;ord2| |xValues| |i| $) . #7#)
                                (LETT |d2|
                                      (|GUESS;deg2| |xValues| |i| $) . #7#)
                                (COND
                                  ((SPADCALL |options| (QREFELT $ 124))
                                   (SEQ
                                    (SPADCALL "sys date +%s"
                                     (QREFELT $ 133))
                                    (EXIT
                                     (SPADCALL
                                      "interpolating resultants..."
                                      (QREFELT $ 130))))))
                                (LETT |res1|
                                      (SPADCALL
                                       (|GUESS;evalResultant| |poly1|
                                        |poly3| |o1| |d1| |a1| A $)
                                       (QREFELT $ 144)) . #7#)
                                (LETT |res2|
                                      (SPADCALL
                                       (|GUESS;evalResultant| |poly2|
                                        |poly3| |o2| |d2| |a1| A $)
                                       (QREFELT $ 144)) . #7#)
                                (COND
                                  ((SPADCALL |options| (QREFELT $ 124))
                                   (SEQ
                                    (SPADCALL
                                     (SPADCALL "n/i: "
                                      (SPADCALL (STRINGIMAGE |n|)
                                       (SPADCALL " " (STRINGIMAGE |i|)
                                        (QREFELT $ 145))
                                       (QREFELT $ 145))
                                      (QREFELT $ 145))
                                     (QREFELT $ 146))
                                    (SPADCALL
                                     (SPADCALL "res1 ord: "
                                      (SPADCALL (STRINGIMAGE |o1|)
                                       (SPADCALL " "
                                        (STRINGIMAGE
                                         (SPADCALL |res1|
                                          (QREFELT $ 147)))
                                        (QREFELT $ 145))
                                       (QREFELT $ 145))
                                      (QREFELT $ 145))
                                     (QREFELT $ 146))
                                    (SPADCALL
                                     (SPADCALL "res1 deg: "
                                      (SPADCALL (STRINGIMAGE |d1|)
                                       (SPADCALL " "
                                        (STRINGIMAGE
                                         (SPADCALL |res1|
                                          (QREFELT $ 102)))
                                        (QREFELT $ 145))
                                       (QREFELT $ 145))
                                      (QREFELT $ 145))
                                     (QREFELT $ 146))
                                    (SPADCALL
                                     (SPADCALL "res2 ord: "
                                      (SPADCALL (STRINGIMAGE |o2|)
                                       (SPADCALL " "
                                        (STRINGIMAGE
                                         (SPADCALL |res2|
                                          (QREFELT $ 147)))
                                        (QREFELT $ 145))
                                       (QREFELT $ 145))
                                      (QREFELT $ 145))
                                     (QREFELT $ 146))
                                    (EXIT
                                     (SPADCALL
                                      (SPADCALL "res2 deg: "
                                       (SPADCALL (STRINGIMAGE |d2|)
                                        (SPADCALL " "
                                         (STRINGIMAGE
                                          (SPADCALL |res2|
                                           (QREFELT $ 102)))
                                         (QREFELT $ 145))
                                        (QREFELT $ 145))
                                       (QREFELT $ 145))
                                      (QREFELT $ 146))))))
                                (COND
                                  ((SPADCALL |options| (QREFELT $ 124))
                                   (SEQ
                                    (SPADCALL "sys date +%s"
                                     (QREFELT $ 133))
                                    (EXIT
                                     (SPADCALL "computing gcd..."
                                      (QREFELT $ 130))))))
                                (LETT |res3|
                                      (|GUESS;SUPS2SUPF|
                                       (SPADCALL
                                        (SPADCALL |res1| |res2|
                                         (QREFELT $ 148))
                                        (QREFELT $ 149))
                                       $) . #7#)
                                (COND
                                  ((SPADCALL |options| (QREFELT $ 124))
                                   (SEQ
                                    (SPADCALL "sys date +%s"
                                     (QREFELT $ 133))
                                    (EXIT
                                     (SPADCALL "solving..."
                                      (QREFELT $ 130))))))
                                (SEQ (LETT |f| NIL . #7#)
                                     (LETT #4#
                                      (SPADCALL
                                       (SPADCALL |res3|
                                        (QREFELT $ 152))
                                       (QREFELT $ 155)) . #7#)
                                     G190
                                     (COND
                                       ((OR (ATOM #4#)
                                         (PROGN
                                           (LETT |f| (CAR #4#) . #7#)
                                           NIL))
                                        #8#))
                                     (SEQ
                                      (EXIT
                                       (COND
                                         ((EQL
                                           (SPADCALL (QCAR |f|)
                                            (QREFELT $ 58))
                                           1)
                                          (SEQ
                                           (COND
                                             ((SPADCALL |options|
                                               (QREFELT $ 124))
                                              (SPADCALL
                                               (SPADCALL "f: "
                                                (|coerceRe2E| |f|
                                                 (ELT
                                                  (|Record|
                                                   (|:| |factor|
                                                    (|SparseUnivariatePolynomial|
                                                     (QREFELT $ 6)))
                                                   (|:| |exponent|
                                                    (|Integer|)))
                                                  0))
                                                (QREFELT $ 127))
                                               (QREFELT $ 130))))
                                           (LETT |Av|
                                            (SPADCALL
                                             (SPADCALL
                                              (SPADCALL (QCAR |f|) 0
                                               (QREFELT $ 156))
                                              (SPADCALL (QCAR |f|)
                                               (QREFELT $ 56))
                                              (QREFELT $ 157))
                                             (QREFELT $ 158)) . #7#)
                                           (LETT |evalPoly|
                                            (SPADCALL
                                             (|GUESS;POLYS2POLYF|
                                              |poly3| $)
                                             A |Av| (QREFELT $ 159)) . #7#)
                                           (COND
                                             ((SPADCALL |evalPoly|
                                               (QREFELT $ 160))
                                              (LETT |evalPoly|
                                               (SPADCALL
                                                (|GUESS;POLYS2POLYF|
                                                 |poly1| $)
                                                A |Av| (QREFELT $ 159)) . #7#)))
                                           (EXIT
                                            (SEQ (LETT |g| NIL . #7#)
                                             (LETT #5#
                                              (SPADCALL
                                               (SPADCALL
                                                (SPADCALL |evalPoly|
                                                 (QREFELT $ 161))
                                                (QREFELT $ 152))
                                               (QREFELT $ 155)) . #7#)
                                             G190
                                             (COND
                                               ((OR (ATOM #5#)
                                                 (PROGN
                                                   (LETT |g|
                                                    (CAR #5#) . #7#)
                                                   NIL))
                                                #8#))
                                             (SEQ
                                              (EXIT
                                               (COND
                                                 ((EQL
                                                   (SPADCALL (QCAR |g|)
                                                    (QREFELT $ 58))
                                                   1)
                                                  (SEQ
                                                   (COND
                                                     ((SPADCALL
                                                       |options|
                                                       (QREFELT $ 124))
                                                      (SPADCALL
                                                       (SPADCALL "g: "
                                                        (|coerceRe2E|
                                                         |g|
                                                         (ELT
                                                          (|Record|
                                                           (|:|
                                                            |factor|
                                                            (|SparseUnivariatePolynomial|
                                                             (QREFELT $
                                                              6)))
                                                           (|:|
                                                            |exponent|
                                                            (|Integer|)))
                                                          0))
                                                        (QREFELT $ 127))
                                                       (QREFELT $ 130))))
                                                   (LETT |a1v|
                                                    (SPADCALL
                                                     (SPADCALL
                                                      (SPADCALL
                                                       (QCAR |g|) 0
                                                       (QREFELT $ 156))
                                                      (SPADCALL
                                                       (QCAR |g|)
                                                       (QREFELT $ 56))
                                                      (QREFELT $ 157))
                                                     (QREFELT $ 158)) . #7#)
                                                   (LETT |t1|
                                                    (SPADCALL
                                                     (|GUESS;POLYS2POLYF|
                                                      |poly1| $)
                                                     (LIST |a1| A)
                                                     (LIST |a1v| |Av|)
                                                     (QREFELT $ 75)) . #7#)
                                                   (EXIT
                                                    (COND
                                                      ((SPADCALL |t1|
                                                        (QREFELT $ 160))
                                                       (SEQ
                                                        (LETT |t2|
                                                         (SPADCALL
                                                          (|GUESS;POLYS2POLYF|
                                                           |poly2| $)
                                                          (LIST |a1| A)
                                                          (LIST |a1v|
                                                           |Av|)
                                                          (QREFELT $
                                                           75)) . #7#)
                                                        (EXIT
                                                         (COND
                                                           ((SPADCALL
                                                             |t2|
                                                             (QREFELT $
                                                              160))
                                                            (SEQ
                                                             (LETT
                                                              |ri1|
                                                              (SPADCALL
                                                               (|GUESS;SUPFPOLYS2FSUPPOLYS|
                                                                (SPADCALL
                                                                 |ri|
                                                                 (QREFELT
                                                                  $
                                                                  162))
                                                                $)
                                                               (|GUESS;SUPFPOLYS2FSUPPOLYS|
                                                                (SPADCALL
                                                                 |ri|
                                                                 (QREFELT
                                                                  $
                                                                  163))
                                                                $)
                                                               (QREFELT
                                                                $ 164)) . #7#)
                                                             (LETT
                                                              |numr|
                                                              (|GUESS;SUPPOLYS2SUPF|
                                                               (SPADCALL
                                                                |ri1|
                                                                (QREFELT
                                                                 $ 165))
                                                               |a1v|
                                                               |Av| $) . #7#)
                                                             (LETT
                                                              |denr|
                                                              (|GUESS;SUPPOLYS2SUPF|
                                                               (SPADCALL
                                                                |ri1|
                                                                (QREFELT
                                                                 $ 166))
                                                               |a1v|
                                                               |Av| $) . #7#)
                                                             (EXIT
                                                              (COND
                                                                ((SPADCALL
                                                                  |denr|
                                                                  (QREFELT
                                                                   $
                                                                   55))
                                                                 (COND
                                                                   ((SPADCALL
                                                                     |numr|
                                                                     (QREFELT
                                                                      $
                                                                      55))
                                                                    (COND
                                                                      ((SPADCALL
                                                                        |options|
                                                                        (QREFELT
                                                                         $
                                                                         124))
                                                                       (SPADCALL
                                                                        "numerator and denominator vanish!"
                                                                        (QREFELT
                                                                         $
                                                                         146)))))))
                                                                ('T
                                                                 (SEQ
                                                                  (LETT
                                                                   |res4|
                                                                   (SPADCALL
                                                                    (SPADCALL
                                                                     (|GUESS;FSUPF2EXPRR|
                                                                      |xx|
                                                                      (SPADCALL
                                                                       |numr|
                                                                       |denr|
                                                                       (QREFELT
                                                                        $
                                                                        167))
                                                                      $)
                                                                     (SPADCALL
                                                                      |xx|
                                                                      (QREFELT
                                                                       $
                                                                       169))
                                                                     (SPADCALL
                                                                      (SPADCALL
                                                                       |xx|
                                                                       (QREFELT
                                                                        $
                                                                        24))
                                                                      |basis|)
                                                                     (QREFELT
                                                                      $
                                                                      171))
                                                                    (SPADCALL
                                                                     (|GUESS;p2|
                                                                      (SPADCALL
                                                                       |xValues|
                                                                       (QREFELT
                                                                        $
                                                                        117))
                                                                      |xx|
                                                                      |a1v|
                                                                      |Av|
                                                                      |basis|
                                                                      $)
                                                                     (SPADCALL
                                                                      |xx|
                                                                      (QREFELT
                                                                       $
                                                                       24))
                                                                     (QREFELT
                                                                      $
                                                                      172))
                                                                    (QREFELT
                                                                     $
                                                                     60)) . #7#)
                                                                  (EXIT
                                                                   (LETT
                                                                    |res|
                                                                    (CONS
                                                                     |res4|
                                                                     |res|) . #7#)))))))))))))))))))
                                             (LETT #5# (CDR #5#) . #7#)
                                             #9# G191 (EXIT NIL))))))))
                                     (LETT #4# (CDR #4#) . #7#) #9#
                                     G191 (EXIT NIL))
                                (EXIT (COND
                                        ((NULL (NULL |res|))
                                         (COND
                                           ((SPADCALL |options|
                                             (QREFELT $ 173))
                                            (PROGN
                                              (LETT #6# |res| . #7#)
                                              (GO #6#))))))))
                           (LETT |i| (QSADD1 |i|) . #7#) #9# G191
                           (EXIT NIL))
                      (EXIT |res|)))
           #6# (EXIT #6#))))) 

(DEFUN |GUESS;guessExpRatAux!0| (|#1| $$)
  (PROG ($ |xValues|)
    (LETT $ (QREFELT $$ 4) . #0=(|GUESS;guessExpRatAux|))
    (LETT |xValues| (QREFELT $$ 3) . #0#)
    (RETURN
      (PROGN
        (SPADCALL
            (|GUESS;F2FPOLYS|
                (SPADCALL (QREFELT $$ 5) |#1| (QREFELT $ 34)) $)
            (SPADCALL
                (|GUESS;p| (SPADCALL |xValues| (QREFELT $ 117))
                    (SPADCALL |xValues| |#1| (QREFELT $ 16))
                    (QREFELT $$ 2) (QREFELT $$ 1) (QREFELT $$ 0) $)
                (SPADCALL (SPADCALL |xValues| |#1| (QREFELT $ 16))
                    (QREFELT $ 118))
                (QREFELT $ 120))
            (QREFELT $ 114)))))) 

(DEFUN |GUESS;guessExpRatAux0| (|list| |basis| |options| $)
  (PROG (|xx| |len| #0=#:G55306 #1=#:G55292 |shortlist| #2=#:G55307
              |zeros| |x| #3=#:G55308 |i| |newlist| |xValues|
              #4=#:G55309 |f| #5=#:G55310 |res| |reslist|)
    (RETURN
      (SEQ (EXIT (SEQ (COND
                        ((ZEROP (SPADCALL |options| (QREFELT $ 174)))
                         (|error| "Guess: guessExpRat does not support zero safety")))
                      (LETT |xx| (SPADCALL |options| (QREFELT $ 175))
                            . #6=(|GUESS;guessExpRatAux0|))
                      (LETT |len| (LENGTH |list|) . #6#)
                      (COND
                        ((< (+ (- |len|
                                  (SPADCALL |options| (QREFELT $ 174)))
                               1)
                            0)
                         (PROGN (LETT #0# NIL . #6#) (GO #0#))))
                      (LETT |shortlist|
                            (SPADCALL |list|
                                (PROG1 (LETT #1#
                                        (+
                                         (- |len|
                                          (SPADCALL |options|
                                           (QREFELT $ 174)))
                                         1) . #6#)
                                  (|check-subtype| (>= #1# 0)
                                      '(|NonNegativeInteger|) #1#))
                                (QREFELT $ 176)) . #6#)
                      (LETT |zeros| (|spadConstant| $ 177) . #6#)
                      (LETT |i| -1 . #6#)
                      (SEQ (LETT |x| NIL . #6#)
                           (LETT #2# |shortlist| . #6#) G190
                           (COND
                             ((OR (ATOM #2#)
                                  (PROGN
                                    (LETT |x| (CAR #2#) . #6#)
                                    NIL))
                              #7=(GO G191)))
                           (SEQ (LETT |i| (+ |i| 1) . #6#)
                                (EXIT (COND
                                        ((SPADCALL |x|
                                          (|spadConstant| $ 27)
                                          (QREFELT $ 178))
                                         (LETT |zeros|
                                          (SPADCALL |zeros|
                                           (SPADCALL
                                            (SPADCALL
                                             (SPADCALL |xx|
                                              (QREFELT $ 24))
                                             |basis|)
                                            (SPADCALL
                                             (SPADCALL |i|
                                              (QREFELT $ 25))
                                             |basis|)
                                            (QREFELT $ 116))
                                           (QREFELT $ 60)) . #6#)))))
                           (LETT #2# (CDR #2#) . #6#) #8=(GO G190) G191
                           (EXIT NIL))
                      (LETT |i| -1 . #6#)
                      (SEQ (LETT |x| NIL . #6#)
                           (LETT #3# |shortlist| . #6#) G190
                           (COND
                             ((OR (ATOM #3#)
                                  (PROGN
                                    (LETT |x| (CAR #3#) . #6#)
                                    NIL))
                              #7#))
                           (SEQ (LETT |i| (+ |i| 1) . #6#)
                                (EXIT (COND
                                        ((SPADCALL |x|
                                          (|spadConstant| $ 27)
                                          (QREFELT $ 37))
                                         (SEQ
                                          (LETT |newlist|
                                           (CONS
                                            (SPADCALL |x|
                                             (SPADCALL
                                              (SPADCALL
                                               (SPADCALL |zeros|
                                                (SPADCALL |xx|
                                                 (QREFELT $ 24))
                                                (SPADCALL |i|
                                                 (QREFELT $ 25))
                                                (QREFELT $ 26))
                                               (QREFELT $ 36))
                                              (QREFELT $ 10))
                                             (QREFELT $ 157))
                                            |newlist|) . #6#)
                                          (EXIT
                                           (LETT |xValues|
                                            (CONS |i| |xValues|) . #6#)))))))
                           (LETT #3# (CDR #3#) . #6#) #8# G191
                           (EXIT NIL))
                      (LETT |newlist| (REVERSE |newlist|) . #6#)
                      (LETT |xValues| (REVERSE |xValues|) . #6#)
                      (LETT |res|
                            (PROGN
                              (LETT #4# NIL . #6#)
                              (SEQ (LETT |f| NIL . #6#)
                                   (LETT #5#
                                    (|GUESS;guessExpRatAux| |xx|
                                     |newlist| |basis| |xValues|
                                     |options| $) . #6#)
                                   G190
                                   (COND
                                     ((OR (ATOM #5#)
                                       (PROGN
                                         (LETT |f| (CAR #5#) . #6#)
                                         NIL))
                                      #7#))
                                   (SEQ
                                    (EXIT
                                     (LETT #4#
                                      (CONS
                                       (SPADCALL
                                        (SPADCALL |zeros| |f|
                                         (QREFELT $ 60))
                                        (SPADCALL |xx| (QREFELT $ 24))
                                        (SPADCALL |xx| (QREFELT $ 24))
                                        (QREFELT $ 26))
                                       #4#) . #6#)))
                                   (LETT #5# (CDR #5#) . #6#) #8# G191
                                   (EXIT (NREVERSE0 #4#)))) . #6#)
                      (LETT |reslist|
                            (SPADCALL
                                (CONS #'|GUESS;guessExpRatAux0!0|
                                      (VECTOR $ |options| |list| |len|
                                       |xx|))
                                |res| (QREFELT $ 184)) . #6#)
                      (EXIT (SPADCALL
                                (CONS #'|GUESS;guessExpRatAux0!1|
                                      (VECTOR $ |options| |len|))
                                |reslist| (QREFELT $ 188)))))
           #0# (EXIT #0#))))) 

(DEFUN |GUESS;guessExpRatAux0!1| (|#1| $$)
  (PROG ($)
    (LETT $ (QREFELT $$ 0) |GUESS;guessExpRatAux0|)
    (RETURN
      (PROGN
        (SPADCALL (QCDR |#1|)
            (SPADCALL (QREFELT $$ 2)
                (SPADCALL (QREFELT $$ 1) (QREFELT $ 174))
                (QREFELT $ 185))
            (QREFELT $ 186)))))) 

(DEFUN |GUESS;guessExpRatAux0!0| (|#1| $$)
  (CONS |#1|
        (|GUESS;checkResult| |#1| (QREFELT $$ 4) (QREFELT $$ 3)
            (QREFELT $$ 2) (QREFELT $$ 1) (QREFELT $$ 0)))) 

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

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

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

(DEFUN |GUESS;guessExpRat;SM;23!1| (|#1| |#2| $$)
  (PROG ($)
    (LETT $ (QREFELT $$ 1) |GUESS;guessExpRat;SM;23|)
    (RETURN
      (PROGN
        (PROG ()
          (RETURN
            (|GUESS;guessExpRatAux0| |#1|
                (CONS #'|GUESS;guessExpRat;SM;23!0|
                      (VECTOR $ (QREFELT $$ 0)))
                |#2| $))))))) 

(DEFUN |GUESS;guessExpRat;SM;23!0| (|#1| $$)
  (PROG ($)
    (LETT $ (QREFELT $$ 0) NIL)
    (RETURN
      (PROGN
        (SPADCALL (SPADCALL (QREFELT $$ 1) (QREFELT $ 24)) |#1|
            (QREFELT $ 172)))))) 

(DEFUN |GUESS;binExt| (|i| |va1| |vA| $)
  (PROG (#0=#:G55319 |l| #1=#:G55320 |numl| |num|)
    (RETURN
      (SEQ (LETT |numl|
                 (PROGN
                   (LETT #0# NIL . #2=(|GUESS;binExt|))
                   (SEQ (LETT |l| 0 . #2#) (LETT #1# (- |i| 1) . #2#)
                        G190 (COND ((QSGREATERP |l| #1#) (GO G191)))
                        (SEQ (EXIT (LETT #0#
                                    (CONS
                                     (SPADCALL
                                      (SPADCALL
                                       (SPADCALL |vA| (QREFELT $ 111))
                                       (SPADCALL |i|
                                        (SPADCALL |va1|
                                         (QREFELT $ 111))
                                        (QREFELT $ 193))
                                       (QREFELT $ 194))
                                      (SPADCALL |l| (QREFELT $ 195))
                                      (QREFELT $ 196))
                                     #0#) . #2#)))
                        (LETT |l| (QSADD1 |l|) . #2#) (GO G190) G191
                        (EXIT (NREVERSE0 #0#)))) . #2#)
           (LETT |num|
                 (SPADCALL (ELT $ 197) |numl| (|spadConstant| $ 198)
                     (QREFELT $ 201)) . #2#)
           (EXIT (SPADCALL |num|
                     (SPADCALL (SPADCALL |i| (QREFELT $ 202))
                         (QREFELT $ 195))
                     (QREFELT $ 54))))))) 

(DEFUN |GUESS;binExtEXPR| (|i| |a1v| |Av| $)
  (SPADCALL
      (SPADCALL (SPADCALL |Av| (QREFELT $ 11))
          (SPADCALL (SPADCALL |a1v| (QREFELT $ 11))
              (SPADCALL |i| (QREFELT $ 24)) (QREFELT $ 60))
          (QREFELT $ 62))
      (SPADCALL |i| (QREFELT $ 24)) (QREFELT $ 203))) 

(DEFUN |GUESS;guessBinRatAux|
       (|xx| |list| |basis| |ext| |extEXPR| |xValues| |options| $)
  (PROG (|a1| A #0=#:G55322 |len| #1=#:G55346 |xlist| |x1| |x2| |x3|
              |y| #2=#:G55347 |ylist| |y1| |y2| |y3| |maxDeg| |i|
              #3=#:G55326 |ri| |poly1| |poly2| |poly3| |n| |res1|
              |res2| |res3| |f| #4=#:G55348 |Av| |evalPoly| |g|
              #5=#:G55349 |a1v| |t1| |t2| |ri1| |numr| |denr| |res4|
              |res| #6=#:G55345)
    (RETURN
      (SEQ (EXIT (SEQ (LETT |a1| (SPADCALL 1 (QREFELT $ 73))
                            . #7=(|GUESS;guessBinRatAux|))
                      (LETT A (SPADCALL 2 (QREFELT $ 73)) . #7#)
                      (LETT |len| (LENGTH |list|) . #7#)
                      (COND
                        ((< |len| 4)
                         (PROGN (LETT #6# NIL . #7#) (GO #6#)))
                        ('T
                         (LETT |len|
                               (PROG1 (LETT #0# (- |len| 3) . #7#)
                                 (|check-subtype| (>= #0# 0)
                                     '(|NonNegativeInteger|) #0#)) . #7#)))
                      (LETT |xlist|
                            (PROGN
                              (LETT #1# NIL . #7#)
                              (SEQ (LETT |i| 1 . #7#) G190
                                   (COND
                                     ((QSGREATERP |i| |len|)
                                      #8=(GO G191)))
                                   (SEQ
                                    (EXIT
                                     (LETT #1#
                                      (CONS
                                       (|GUESS;F2FPOLYS|
                                        (|GUESS;DN2DL| |basis|
                                         (SPADCALL |xValues| |i|
                                          (QREFELT $ 16))
                                         $)
                                        $)
                                       #1#) . #7#)))
                                   (LETT |i| (QSADD1 |i|) . #7#)
                                   #9=(GO G190) G191
                                   (EXIT (NREVERSE0 #1#)))) . #7#)
                      (LETT |x1|
                            (|GUESS;F2FPOLYS|
                                (|GUESS;DN2DL| |basis|
                                    (SPADCALL |xValues| (+ |len| 1)
                                     (QREFELT $ 16))
                                    $)
                                $) . #7#)
                      (LETT |x2|
                            (|GUESS;F2FPOLYS|
                                (|GUESS;DN2DL| |basis|
                                    (SPADCALL |xValues| (+ |len| 2)
                                     (QREFELT $ 16))
                                    $)
                                $) . #7#)
                      (LETT |x3|
                            (|GUESS;F2FPOLYS|
                                (|GUESS;DN2DL| |basis|
                                    (SPADCALL |xValues| (+ |len| 3)
                                     (QREFELT $ 16))
                                    $)
                                $) . #7#)
                      (LETT |y|
                            (CONS #'|GUESS;guessBinRatAux!0|
                                  (VECTOR |ext| A |a1| |xValues| $
                                          |list|)) . #7#)
                      (LETT |ylist|
                            (PROGN
                              (LETT #2# NIL . #7#)
                              (SEQ (LETT |i| 1 . #7#) G190
                                   (COND ((QSGREATERP |i| |len|) #8#))
                                   (SEQ
                                    (EXIT
                                     (LETT #2#
                                      (CONS (SPADCALL |i| |y|) #2#) . #7#)))
                                   (LETT |i| (QSADD1 |i|) . #7#) #9#
                                   G191 (EXIT (NREVERSE0 #2#)))) . #7#)
                      (LETT |y1| (SPADCALL (+ |len| 1) |y|) . #7#)
                      (LETT |y2| (SPADCALL (+ |len| 2) |y|) . #7#)
                      (LETT |y3| (SPADCALL (+ |len| 3) |y|) . #7#)
                      (LETT |res| NIL . #7#)
                      (COND
                        ((EQL (SPADCALL |options| (QREFELT $ 123)) -1)
                         (LETT |maxDeg| (- |len| 1) . #7#))
                        ('T
                         (LETT |maxDeg|
                               (MIN (SPADCALL |options|
                                     (QREFELT $ 123))
                                    (- |len| 1)) . #7#)))
                      (SEQ (LETT |i| 0 . #7#) G190
                           (COND ((QSGREATERP |i| |maxDeg|) #8#))
                           (SEQ (LETT |ri|
                                      (SPADCALL |xlist| |ylist|
                                       (PROG1
                                        (LETT #3#
                                         (- (- |len| 1) |i|) . #7#)
                                         (|check-subtype| (>= #3# 0)
                                          '(|NonNegativeInteger|) #3#))
                                       (QREFELT $ 137)) . #7#)
                                (LETT |poly1|
                                      (SPADCALL
                                       (SPADCALL
                                        (SPADCALL |ri| |x1|
                                         (QREFELT $ 139))
                                        |y1| (QREFELT $ 140))
                                       (QREFELT $ 141)) . #7#)
                                (LETT |poly2|
                                      (SPADCALL
                                       (SPADCALL
                                        (SPADCALL |ri| |x2|
                                         (QREFELT $ 139))
                                        |y2| (QREFELT $ 140))
                                       (QREFELT $ 141)) . #7#)
                                (LETT |poly3|
                                      (SPADCALL
                                       (SPADCALL
                                        (SPADCALL |ri| |x3|
                                         (QREFELT $ 139))
                                        |y3| (QREFELT $ 140))
                                       (QREFELT $ 141)) . #7#)
                                (LETT |n| (- |len| |i|) . #7#)
                                (LETT |res1|
                                      (SPADCALL
                                       (SPADCALL |poly1| |poly3| |a1|
                                        (QREFELT $ 205))
                                       (QREFELT $ 101)) . #7#)
                                (LETT |res2|
                                      (SPADCALL
                                       (SPADCALL |poly2| |poly3| |a1|
                                        (QREFELT $ 205))
                                       (QREFELT $ 101)) . #7#)
                                (COND
                                  ((SPADCALL |options| (QREFELT $ 124))
                                   (SEQ
                                    (SPADCALL
                                     (SPADCALL "res1 ord: "
                                      (STRINGIMAGE
                                       (SPADCALL |res1|
                                        (QREFELT $ 147)))
                                      (QREFELT $ 145))
                                     (QREFELT $ 146))
                                    (SPADCALL
                                     (SPADCALL "res1 deg: "
                                      (STRINGIMAGE
                                       (SPADCALL |res1|
                                        (QREFELT $ 102)))
                                      (QREFELT $ 145))
                                     (QREFELT $ 146))
                                    (SPADCALL
                                     (SPADCALL "res2 ord: "
                                      (STRINGIMAGE
                                       (SPADCALL |res2|
                                        (QREFELT $ 147)))
                                      (QREFELT $ 145))
                                     (QREFELT $ 146))
                                    (EXIT
                                     (SPADCALL
                                      (SPADCALL "res2 deg: "
                                       (STRINGIMAGE
                                        (SPADCALL |res2|
                                         (QREFELT $ 102)))
                                       (QREFELT $ 145))
                                      (QREFELT $ 146))))))
                                (COND
                                  ((SPADCALL |options| (QREFELT $ 124))
                                   (SPADCALL "computing gcd..."
                                    (QREFELT $ 130))))
                                (LETT |res3|
                                      (|GUESS;SUPS2SUPF|
                                       (SPADCALL
                                        (SPADCALL |res1| |res2|
                                         (QREFELT $ 148))
                                        (QREFELT $ 149))
                                       $) . #7#)
                                (SEQ (LETT |f| NIL . #7#)
                                     (LETT #4#
                                      (SPADCALL
                                       (SPADCALL |res3|
                                        (QREFELT $ 152))
                                       (QREFELT $ 155)) . #7#)
                                     G190
                                     (COND
                                       ((OR (ATOM #4#)
                                         (PROGN
                                           (LETT |f| (CAR #4#) . #7#)
                                           NIL))
                                        #8#))
                                     (SEQ
                                      (EXIT
                                       (COND
                                         ((EQL
                                           (SPADCALL (QCAR |f|)
                                            (QREFELT $ 58))
                                           1)
                                          (SEQ
                                           (LETT |Av|
                                            (SPADCALL
                                             (SPADCALL
                                              (SPADCALL (QCAR |f|) 0
                                               (QREFELT $ 156))
                                              (SPADCALL (QCAR |f|)
                                               (QREFELT $ 56))
                                              (QREFELT $ 157))
                                             (QREFELT $ 158)) . #7#)
                                           (LETT |evalPoly|
                                            (SPADCALL
                                             (|GUESS;POLYS2POLYF|
                                              |poly3| $)
                                             A |Av| (QREFELT $ 159)) . #7#)
                                           (COND
                                             ((SPADCALL |evalPoly|
                                               (QREFELT $ 160))
                                              (LETT |evalPoly|
                                               (SPADCALL
                                                (|GUESS;POLYS2POLYF|
                                                 |poly1| $)
                                                A |Av| (QREFELT $ 159)) . #7#)))
                                           (EXIT
                                            (SEQ (LETT |g| NIL . #7#)
                                             (LETT #5#
                                              (SPADCALL
                                               (SPADCALL
                                                (SPADCALL |evalPoly|
                                                 (QREFELT $ 161))
                                                (QREFELT $ 152))
                                               (QREFELT $ 155)) . #7#)
                                             G190
                                             (COND
                                               ((OR (ATOM #5#)
                                                 (PROGN
                                                   (LETT |g|
                                                    (CAR #5#) . #7#)
                                                   NIL))
                                                #8#))
                                             (SEQ
                                              (EXIT
                                               (COND
                                                 ((EQL
                                                   (SPADCALL (QCAR |g|)
                                                    (QREFELT $ 58))
                                                   1)
                                                  (SEQ
                                                   (LETT |a1v|
                                                    (SPADCALL
                                                     (SPADCALL
                                                      (SPADCALL
                                                       (QCAR |g|) 0
                                                       (QREFELT $ 156))
                                                      (SPADCALL
                                                       (QCAR |g|)
                                                       (QREFELT $ 56))
                                                      (QREFELT $ 157))
                                                     (QREFELT $ 158)) . #7#)
                                                   (LETT |t1|
                                                    (SPADCALL
                                                     (|GUESS;POLYS2POLYF|
                                                      |poly1| $)
                                                     (LIST |a1| A)
                                                     (LIST |a1v| |Av|)
                                                     (QREFELT $ 75)) . #7#)
                                                   (EXIT
                                                    (COND
                                                      ((SPADCALL |t1|
                                                        (QREFELT $ 160))
                                                       (SEQ
                                                        (LETT |t2|
                                                         (SPADCALL
                                                          (|GUESS;POLYS2POLYF|
                                                           |poly2| $)
                                                          (LIST |a1| A)
                                                          (LIST |a1v|
                                                           |Av|)
                                                          (QREFELT $
                                                           75)) . #7#)
                                                        (EXIT
                                                         (COND
                                                           ((SPADCALL
                                                             |t2|
                                                             (QREFELT $
                                                              160))
                                                            (SEQ
                                                             (LETT
                                                              |ri1|
                                                              (SPADCALL
                                                               (|GUESS;SUPFPOLYS2FSUPPOLYS|
                                                                (SPADCALL
                                                                 |ri|
                                                                 (QREFELT
                                                                  $
                                                                  162))
                                                                $)
                                                               (|GUESS;SUPFPOLYS2FSUPPOLYS|
                                                                (SPADCALL
                                                                 |ri|
                                                                 (QREFELT
                                                                  $
                                                                  163))
                                                                $)
                                                               (QREFELT
                                                                $ 164)) . #7#)
                                                             (LETT
                                                              |numr|
                                                              (|GUESS;SUPPOLYS2SUPF|
                                                               (SPADCALL
                                                                |ri1|
                                                                (QREFELT
                                                                 $ 165))
                                                               |a1v|
                                                               |Av| $) . #7#)
                                                             (LETT
                                                              |denr|
                                                              (|GUESS;SUPPOLYS2SUPF|
                                                               (SPADCALL
                                                                |ri1|
                                                                (QREFELT
                                                                 $ 166))
                                                               |a1v|
                                                               |Av| $) . #7#)
                                                             (EXIT
                                                              (COND
                                                                ((SPADCALL
                                                                  |denr|
                                                                  (QREFELT
                                                                   $
                                                                   55))
                                                                 (COND
                                                                   ((SPADCALL
                                                                     |numr|
                                                                     (QREFELT
                                                                      $
                                                                      55))
                                                                    (COND
                                                                      ((SPADCALL
                                                                        |options|
                                                                        (QREFELT
                                                                         $
                                                                         124))
                                                                       (SPADCALL
                                                                        "numerator and denominator vanish!"
                                                                        (QREFELT
                                                                         $
                                                                         146)))))))
                                                                ('T
                                                                 (SEQ
                                                                  (LETT
                                                                   |res4|
                                                                   (SPADCALL
                                                                    (SPADCALL
                                                                     (|GUESS;FSUPF2EXPRR|
                                                                      |xx|
                                                                      (SPADCALL
                                                                       |numr|
                                                                       |denr|
                                                                       (QREFELT
                                                                        $
                                                                        167))
                                                                      $)
                                                                     (SPADCALL
                                                                      |xx|
                                                                      (QREFELT
                                                                       $
                                                                       169))
                                                                     (SPADCALL
                                                                      (SPADCALL
                                                                       |xx|
                                                                       (QREFELT
                                                                        $
                                                                        24))
                                                                      |basis|)
                                                                     (QREFELT
                                                                      $
                                                                      171))
                                                                    (SPADCALL
                                                                     |xx|
                                                                     |a1v|
                                                                     |Av|
                                                                     |extEXPR|)
                                                                    (QREFELT
                                                                     $
                                                                     60)) . #7#)
                                                                  (EXIT
                                                                   (LETT
                                                                    |res|
                                                                    (CONS
                                                                     |res4|
                                                                     |res|) . #7#)))))))))))))))))))
                                             (LETT #5# (CDR #5#) . #7#)
                                             #9# G191 (EXIT NIL))))))))
                                     (LETT #4# (CDR #4#) . #7#) #9#
                                     G191 (EXIT NIL))
                                (EXIT (COND
                                        ((NULL (NULL |res|))
                                         (COND
                                           ((SPADCALL |options|
                                             (QREFELT $ 173))
                                            (PROGN
                                              (LETT #6# |res| . #7#)
                                              (GO #6#))))))))
                           (LETT |i| (QSADD1 |i|) . #7#) #9# G191
                           (EXIT NIL))
                      (EXIT |res|)))
           #6# (EXIT #6#))))) 

(DEFUN |GUESS;guessBinRatAux!0| (|#1| $$)
  (PROG ($)
    (LETT $ (QREFELT $$ 4) |GUESS;guessBinRatAux|)
    (RETURN
      (PROGN
        (SPADCALL
            (|GUESS;F2FPOLYS|
                (SPADCALL (QREFELT $$ 5) |#1| (QREFELT $ 34)) $)
            (SPADCALL (SPADCALL (QREFELT $$ 3) |#1| (QREFELT $ 16))
                (QREFELT $$ 2) (QREFELT $$ 1) (QREFELT $$ 0))
            (QREFELT $ 204)))))) 

(DEFUN |GUESS;guessBinRatAux0|
       (|list| |basis| |ext| |extEXPR| |options| $)
  (PROG (|xx| |len| #0=#:G55361 #1=#:G55352 |shortlist| #2=#:G55362
              |zeros| |x| #3=#:G55363 |i| |newlist| |xValues|
              #4=#:G55364 |f| #5=#:G55365 |res| |reslist|)
    (RETURN
      (SEQ (EXIT (SEQ (COND
                        ((ZEROP (SPADCALL |options| (QREFELT $ 174)))
                         (|error| "Guess: guessBinRat does not support zero safety")))
                      (LETT |xx| (SPADCALL |options| (QREFELT $ 175))
                            . #6=(|GUESS;guessBinRatAux0|))
                      (LETT |len| (LENGTH |list|) . #6#)
                      (COND
                        ((< (+ (- |len|
                                  (SPADCALL |options| (QREFELT $ 174)))
                               1)
                            0)
                         (PROGN (LETT #0# NIL . #6#) (GO #0#))))
                      (LETT |shortlist|
                            (SPADCALL |list|
                                (PROG1 (LETT #1#
                                        (+
                                         (- |len|
                                          (SPADCALL |options|
                                           (QREFELT $ 174)))
                                         1) . #6#)
                                  (|check-subtype| (>= #1# 0)
                                      '(|NonNegativeInteger|) #1#))
                                (QREFELT $ 176)) . #6#)
                      (LETT |zeros| (|spadConstant| $ 177) . #6#)
                      (LETT |i| -1 . #6#)
                      (SEQ (LETT |x| NIL . #6#)
                           (LETT #2# |shortlist| . #6#) G190
                           (COND
                             ((OR (ATOM #2#)
                                  (PROGN
                                    (LETT |x| (CAR #2#) . #6#)
                                    NIL))
                              #7=(GO G191)))
                           (SEQ (LETT |i| (+ |i| 1) . #6#)
                                (EXIT (COND
                                        ((SPADCALL |x|
                                          (|spadConstant| $ 27)
                                          (QREFELT $ 178))
                                         (LETT |zeros|
                                          (SPADCALL |zeros|
                                           (SPADCALL
                                            (SPADCALL
                                             (SPADCALL |xx|
                                              (QREFELT $ 24))
                                             |basis|)
                                            (SPADCALL
                                             (SPADCALL |i|
                                              (QREFELT $ 25))
                                             |basis|)
                                            (QREFELT $ 116))
                                           (QREFELT $ 60)) . #6#)))))
                           (LETT #2# (CDR #2#) . #6#) #8=(GO G190) G191
                           (EXIT NIL))
                      (LETT |i| -1 . #6#)
                      (SEQ (LETT |x| NIL . #6#)
                           (LETT #3# |shortlist| . #6#) G190
                           (COND
                             ((OR (ATOM #3#)
                                  (PROGN
                                    (LETT |x| (CAR #3#) . #6#)
                                    NIL))
                              #7#))
                           (SEQ (LETT |i| (+ |i| 1) . #6#)
                                (EXIT (COND
                                        ((SPADCALL |x|
                                          (|spadConstant| $ 27)
                                          (QREFELT $ 37))
                                         (SEQ
                                          (LETT |newlist|
                                           (CONS
                                            (SPADCALL |x|
                                             (SPADCALL
                                              (SPADCALL
                                               (SPADCALL |zeros|
                                                (SPADCALL |xx|
                                                 (QREFELT $ 24))
                                                (SPADCALL |i|
                                                 (QREFELT $ 25))
                                                (QREFELT $ 26))
                                               (QREFELT $ 36))
                                              (QREFELT $ 10))
                                             (QREFELT $ 157))
                                            |newlist|) . #6#)
                                          (EXIT
                                           (LETT |xValues|
                                            (CONS |i| |xValues|) . #6#)))))))
                           (LETT #3# (CDR #3#) . #6#) #8# G191
                           (EXIT NIL))
                      (LETT |newlist| (REVERSE |newlist|) . #6#)
                      (LETT |xValues| (REVERSE |xValues|) . #6#)
                      (LETT |res|
                            (PROGN
                              (LETT #4# NIL . #6#)
                              (SEQ (LETT |f| NIL . #6#)
                                   (LETT #5#
                                    (|GUESS;guessBinRatAux| |xx|
                                     |newlist| |basis| |ext| |extEXPR|
                                     |xValues| |options| $) . #6#)
                                   G190
                                   (COND
                                     ((OR (ATOM #5#)
                                       (PROGN
                                         (LETT |f| (CAR #5#) . #6#)
                                         NIL))
                                      #7#))
                                   (SEQ
                                    (EXIT
                                     (LETT #4#
                                      (CONS
                                       (SPADCALL
                                        (SPADCALL |zeros| |f|
                                         (QREFELT $ 60))
                                        (SPADCALL |xx| (QREFELT $ 24))
                                        (SPADCALL |xx| (QREFELT $ 24))
                                        (QREFELT $ 26))
                                       #4#) . #6#)))
                                   (LETT #5# (CDR #5#) . #6#) #8# G191
                                   (EXIT (NREVERSE0 #4#)))) . #6#)
                      (LETT |reslist|
                            (SPADCALL
                                (CONS #'|GUESS;guessBinRatAux0!0|
                                      (VECTOR $ |options| |list| |len|
                                       |xx|))
                                |res| (QREFELT $ 184)) . #6#)
                      (EXIT (SPADCALL
                                (CONS #'|GUESS;guessBinRatAux0!1|
                                      (VECTOR $ |options| |len|))
                                |reslist| (QREFELT $ 188)))))
           #0# (EXIT #0#))))) 

(DEFUN |GUESS;guessBinRatAux0!1| (|#1| $$)
  (PROG ($)
    (LETT $ (QREFELT $$ 0) |GUESS;guessBinRatAux0|)
    (RETURN
      (PROGN
        (SPADCALL (QCDR |#1|)
            (SPADCALL (QREFELT $$ 2)
                (SPADCALL (QREFELT $$ 1) (QREFELT $ 174))
                (QREFELT $ 185))
            (QREFELT $ 186)))))) 

(DEFUN |GUESS;guessBinRatAux0!0| (|#1| $$)
  (CONS |#1|
        (|GUESS;checkResult| |#1| (QREFELT $$ 4) (QREFELT $$ 3)
            (QREFELT $$ 2) (QREFELT $$ 1) (QREFELT $$ 0)))) 

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

(DEFUN |GUESS;guessBinRat;LLL;29| (|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| (|#1| $$)
  (PROG ($)
    (LETT $ (QREFELT $$ 0) |GUESS;qD|)
    (RETURN
      (PROGN
        (SPADCALL (SPADCALL (QREFELT $$ 1) (QREFELT $ 24)) |#1|
            (QREFELT $ 172)))))) 

(DEFUN |GUESS;qBinExtAux| (|q| |i| |va1| |vA| $)
  (PROG (#0=#:G55373 |l| |fl|)
    (RETURN
      (SEQ (LETT |fl|
                 (PROGN
                   (LETT #0# NIL . #1=(|GUESS;qBinExtAux|))
                   (SEQ (LETT |l| 1 . #1#) G190
                        (COND ((QSGREATERP |l| |i|) (GO G191)))
                        (SEQ (EXIT (LETT #0#
                                    (CONS
                                     (SPADCALL
                                      (SPADCALL (|spadConstant| $ 208)
                                       (SPADCALL
                                        (SPADCALL
                                         (SPADCALL
                                          (SPADCALL |va1|
                                           (QREFELT $ 111))
                                          (QREFELT $ 112))
                                         (SPADCALL
                                          (SPADCALL
                                           (SPADCALL |vA|
                                            (QREFELT $ 111))
                                           (QREFELT $ 112))
                                          (- |i| 1) (QREFELT $ 120))
                                         (QREFELT $ 114))
                                        (SPADCALL
                                         (|GUESS;F2FPOLYS|
                                          (SPADCALL |q|
                                           (QREFELT $ 209))
                                          $)
                                         |l| (QREFELT $ 120))
                                        (QREFELT $ 114))
                                       (QREFELT $ 140))
                                      (SPADCALL (|spadConstant| $ 208)
                                       (SPADCALL
                                        (|GUESS;F2FPOLYS|
                                         (SPADCALL |q| (QREFELT $ 209))
                                         $)
                                        |l| (QREFELT $ 120))
                                       (QREFELT $ 140))
                                      (QREFELT $ 204))
                                     #0#) . #1#)))
                        (LETT |l| (QSADD1 |l|) . #1#) (GO G190) G191
                        (EXIT (NREVERSE0 #0#)))) . #1#)
           (EXIT (SPADCALL (ELT $ 114) |fl| (|spadConstant| $ 208)
                     (QREFELT $ 211))))))) 

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

(DEFUN |GUESS;qBinExt!0| (|#1| |#2| |#3| $$)
  (|GUESS;qBinExtAux| (QREFELT $$ 1) |#1| |#2| |#3| (QREFELT $$ 0))) 

(DEFUN |GUESS;qBinExtEXPRaux| (|q| |i| |a1v| |Av| $)
  (PROG (|l|)
    (RETURN
      (SEQ (LETT |l| '|l| |GUESS;qBinExtEXPRaux|)
           (EXIT (SPADCALL
                     (SPADCALL
                         (SPADCALL (|spadConstant| $ 177)
                             (SPADCALL
                                 (SPADCALL
                                     (SPADCALL |a1v| (QREFELT $ 11))
                                     (SPADCALL
                                      (SPADCALL |Av| (QREFELT $ 11))
                                      (SPADCALL
                                       (SPADCALL |i| (QREFELT $ 24))
                                       (|spadConstant| $ 177)
                                       (QREFELT $ 116))
                                      (QREFELT $ 172))
                                     (QREFELT $ 60))
                                 (SPADCALL
                                     (SPADCALL |q| (QREFELT $ 24))
                                     (SPADCALL |l| (QREFELT $ 24))
                                     (QREFELT $ 172))
                                 (QREFELT $ 60))
                             (QREFELT $ 116))
                         (SPADCALL (|spadConstant| $ 177)
                             (SPADCALL (SPADCALL |q| (QREFELT $ 24))
                                 (SPADCALL |l| (QREFELT $ 24))
                                 (QREFELT $ 172))
                             (QREFELT $ 116))
                         (QREFELT $ 35))
                     (SPADCALL |l|
                         (SPADCALL (|spadConstant| $ 177)
                             (SPADCALL |i| (QREFELT $ 24))
                             (QREFELT $ 213))
                         (QREFELT $ 215))
                     (QREFELT $ 217))))))) 

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

(DEFUN |GUESS;qBinExtEXPR!0| (|#1| |#2| |#3| $$)
  (|GUESS;qBinExtEXPRaux| (QREFELT $$ 1) |#1| |#2| |#3| (QREFELT $$ 0))) 

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

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

(DEFUN |GUESS;termAsEXPRR| (|f| |xx| |l| DX D1X $)
  (PROG (|ll| #0=#:G55391 |part| #1=#:G55392 #2=#:G55384 #3=#:G55385
              |fl|)
    (RETURN
      (SEQ (COND
             ((NULL |l|) (SPADCALL |xx| D1X))
             ('T
              (SEQ (LETT |ll| (SPADCALL |l| (QREFELT $ 221))
                         . #4=(|GUESS;termAsEXPRR|))
                   (LETT |fl|
                         (PROGN
                           (LETT #0# NIL . #4#)
                           (SEQ (LETT |part| NIL . #4#)
                                (LETT #1# |ll| . #4#) G190
                                (COND
                                  ((OR (ATOM #1#)
                                    (PROGN
                                      (LETT |part| (CAR #1#) . #4#)
                                      NIL))
                                   (GO G191)))
                                (SEQ (EXIT
                                      (LETT #0#
                                       (CONS
                                        (SPADCALL
                                         (SPADCALL |f| |xx|
                                          (PROG1
                                           (LETT #2#
                                            (- (|SPADfirst| |part|) 1) . #4#)
                                            (|check-subtype| (>= #2# 0)
                                             '(|NonNegativeInteger|)
                                             #2#))
                                          DX)
                                         (PROG1
                                          (LETT #3#
                                           (SPADCALL |part|
                                            (QREFELT $ 222)) . #4#)
                                           (|check-subtype| (>= #3# 0)
                                            '(|NonNegativeInteger|)
                                            #3#))
                                         (QREFELT $ 59))
                                        #0#) . #4#)))
                                (LETT #1# (CDR #1#) . #4#) (GO G190)
                                G191 (EXIT (NREVERSE0 #0#)))) . #4#)
                   (EXIT (SPADCALL (ELT $ 60) |fl| (QREFELT $ 224)))))))))) 

(DEFUN |GUESS;termAsUFPSF| (|f| |l| DS D1 $)
  (PROG (|ll| #0=#:G55407 |part| #1=#:G55408 #2=#:G55400 #3=#:G55401
              |fl|)
    (RETURN
      (SEQ (COND
             ((NULL |l|) D1)
             ('T
              (SEQ (LETT |ll| (SPADCALL |l| (QREFELT $ 221))
                         . #4=(|GUESS;termAsUFPSF|))
                   (LETT |fl|
                         (PROGN
                           (LETT #0# NIL . #4#)
                           (SEQ (LETT |part| NIL . #4#)
                                (LETT #1# |ll| . #4#) G190
                                (COND
                                  ((OR (ATOM #1#)
                                    (PROGN
                                      (LETT |part| (CAR #1#) . #4#)
                                      NIL))
                                   (GO G191)))
                                (SEQ (EXIT
                                      (LETT #0#
                                       (CONS
                                        (SPADCALL
                                         (SPADCALL |f|
                                          (PROG1
                                           (LETT #2#
                                            (- (|SPADfirst| |part|) 1) . #4#)
                                            (|check-subtype| (>= #2# 0)
                                             '(|NonNegativeInteger|)
                                             #2#))
                                          DS)
                                         (PROG1
                                          (LETT #3#
                                           (SPADCALL |part|
                                            (QREFELT $ 222)) . #4#)
                                           (|check-subtype| (>= #3# 0)
                                            '(|NonNegativeInteger|)
                                            #3#))
                                         (QREFELT $ 226))
                                        #0#) . #4#)))
                                (LETT #1# (CDR #1#) . #4#) (GO G190)
                                G191 (EXIT (NREVERSE0 #0#)))) . #4#)
                   (EXIT (SPADCALL (ELT $ 227) |fl| (QREFELT $ 230)))))))))) 

(DEFUN |GUESS;termAsUFPSF2| (|f| |l| DS D1 $)
  (PROG (|ll| #0=#:G55417 |part| #1=#:G55418 #2=#:G55411 |fl|)
    (RETURN
      (SEQ (COND
             ((NULL |l|) D1)
             ('T
              (SEQ (LETT |ll| (SPADCALL |l| (QREFELT $ 221))
                         . #3=(|GUESS;termAsUFPSF2|))
                   (LETT |fl|
                         (PROGN
                           (LETT #0# NIL . #3#)
                           (SEQ (LETT |part| NIL . #3#)
                                (LETT #1# |ll| . #3#) G190
                                (COND
                                  ((OR (ATOM #1#)
                                    (PROGN
                                      (LETT |part| (CAR #1#) . #3#)
                                      NIL))
                                   (GO G191)))
                                (SEQ (EXIT
                                      (LETT #0#
                                       (CONS
                                        (SPADCALL
                                         (CONS #'|GUESS;termAsUFPSF2!0|
                                          (VECTOR $ |part|))
                                         (SPADCALL |f|
                                          (PROG1
                                           (LETT #2#
                                            (- (|SPADfirst| |part|) 1) . #3#)
                                            (|check-subtype| (>= #2# 0)
                                             '(|NonNegativeInteger|)
                                             #2#))
                                          DS)
                                         (QREFELT $ 233))
                                        #0#) . #3#)))
                                (LETT #1# (CDR #1#) . #3#) (GO G190)
                                G191 (EXIT (NREVERSE0 #0#)))) . #3#)
                   (EXIT (SPADCALL (ELT $ 235) |fl| (QREFELT $ 230)))))))))) 

(DEFUN |GUESS;termAsUFPSF2!0| (|#1| $$)
  (PROG ($)
    (LETT $ (QREFELT $$ 0) |GUESS;termAsUFPSF2|)
    (RETURN
      (PROGN
        (PROG (#0=#:G55410)
          (RETURN
            (SPADCALL |#1|
                (PROG1 (LETT #0#
                             (SPADCALL (QREFELT $$ 1) (QREFELT $ 222))
                             NIL)
                  (|check-subtype| (>= #0# 0) '(|NonNegativeInteger|)
                      #0#))
                (QREFELT $ 231)))))))) 

(DEFUN |GUESS;termAsUFPSSUPF| (|f| |l| DSF D1F $)
  (PROG (|ll| #0=#:G55432 |part| #1=#:G55433 #2=#:G55425 #3=#:G55426
              |fl|)
    (RETURN
      (SEQ (COND
             ((NULL |l|) D1F)
             ('T
              (SEQ (LETT |ll| (SPADCALL |l| (QREFELT $ 221))
                         . #4=(|GUESS;termAsUFPSSUPF|))
                   (LETT |fl|
                         (PROGN
                           (LETT #0# NIL . #4#)
                           (SEQ (LETT |part| NIL . #4#)
                                (LETT #1# |ll| . #4#) G190
                                (COND
                                  ((OR (ATOM #1#)
                                    (PROGN
                                      (LETT |part| (CAR #1#) . #4#)
                                      NIL))
                                   (GO G191)))
                                (SEQ (EXIT
                                      (LETT #0#
                                       (CONS
                                        (SPADCALL
                                         (SPADCALL |f|
                                          (PROG1
                                           (LETT #2#
                                            (- (|SPADfirst| |part|) 1) . #4#)
                                            (|check-subtype| (>= #2# 0)
                                             '(|NonNegativeInteger|)
                                             #2#))
                                          DSF)
                                         (PROG1
                                          (LETT #3#
                                           (SPADCALL |part|
                                            (QREFELT $ 222)) . #4#)
                                           (|check-subtype| (>= #3# 0)
                                            '(|NonNegativeInteger|)
                                            #3#))
                                         (QREFELT $ 237))
                                        #0#) . #4#)))
                                (LETT #1# (CDR #1#) . #4#) (GO G190)
                                G191 (EXIT (NREVERSE0 #0#)))) . #4#)
                   (EXIT (SPADCALL (ELT $ 238) |fl| (QREFELT $ 241)))))))))) 

(DEFUN |GUESS;termAsUFPSSUPF2| (|f| |l| DSF D1F $)
  (PROG (|ll| #0=#:G55441 |part| #1=#:G55442 #2=#:G55435 |fl|)
    (RETURN
      (SEQ (COND
             ((NULL |l|) D1F)
             ('T
              (SEQ (LETT |ll| (SPADCALL |l| (QREFELT $ 221))
                         . #3=(|GUESS;termAsUFPSSUPF2|))
                   (LETT |fl|
                         (PROGN
                           (LETT #0# NIL . #3#)
                           (SEQ (LETT |part| NIL . #3#)
                                (LETT #1# |ll| . #3#) G190
                                (COND
                                  ((OR (ATOM #1#)
                                    (PROGN
                                      (LETT |part| (CAR #1#) . #3#)
                                      NIL))
                                   (GO G191)))
                                (SEQ (EXIT
                                      (LETT #0#
                                       (CONS
                                        (SPADCALL
                                         (CONS
                                          #'|GUESS;termAsUFPSSUPF2!0|
                                          (VECTOR $ |part|))
                                         (SPADCALL |f|
                                          (PROG1
                                           (LETT #2#
                                            (- (|SPADfirst| |part|) 1) . #3#)
                                            (|check-subtype| (>= #2# 0)
                                             '(|NonNegativeInteger|)
                                             #2#))
                                          DSF)
                                         (QREFELT $ 244))
                                        #0#) . #3#)))
                                (LETT #1# (CDR #1#) . #3#) (GO G190)
                                G191 (EXIT (NREVERSE0 #0#)))) . #3#)
                   (EXIT (SPADCALL (ELT $ 246) |fl| (QREFELT $ 241)))))))))) 

(DEFUN |GUESS;termAsUFPSSUPF2!0| (|#1| $$)
  (PROG ($)
    (LETT $ (QREFELT $$ 0) |GUESS;termAsUFPSSUPF2|)
    (RETURN
      (PROGN
        (PROG (#0=#:G55434)
          (RETURN
            (SPADCALL |#1|
                (PROG1 (LETT #0#
                             (SPADCALL (QREFELT $$ 1) (QREFELT $ 222))
                             NIL)
                  (|check-subtype| (>= #0# 0) '(|NonNegativeInteger|)
                      #0#))
                (QREFELT $ 242)))))))) 

(DEFUN |GUESS;FilteredPartitionStream| (|options| $)
  (PROG (|maxD| |maxP| |s1| |s2| |s3| |s|)
    (RETURN
      (SEQ (LETT |maxD| (+ 1 (SPADCALL |options| (QREFELT $ 248)))
                 . #0=(|GUESS;FilteredPartitionStream|))
           (LETT |maxP| (SPADCALL |options| (QREFELT $ 249)) . #0#)
           (COND
             ((< 0 |maxD|)
              (COND
                ((< -1 |maxP|)
                 (LETT |s|
                       (SPADCALL |maxD| |maxP| (QREFELT $ 255)) . #0#))
                ('T
                 (SEQ (LETT |s1|
                            (SPADCALL (ELT $ 256) 1 (QREFELT $ 259)) . #0#)
                      (LETT |s2|
                            (SPADCALL
                                (CONS #'|GUESS;FilteredPartitionStream!0|
                                      $)
                                |s1| (QREFELT $ 264)) . #0#)
                      (LETT |s3| (SPADCALL |s2| (QREFELT $ 266)) . #0#)
                      (EXIT (LETT |s|
                                  (SPADCALL NIL
                                      (SPADCALL
                                       (CONS
                                        #'|GUESS;FilteredPartitionStream!1|
                                        (VECTOR |maxP| $ |maxD|))
                                       |s3| (QREFELT $ 275))
                                      (QREFELT $ 276)) . #0#))))))
             ('T
              (SEQ (LETT |s1|
                         (SPADCALL (ELT $ 256) 1 (QREFELT $ 259)) . #0#)
                   (LETT |s2|
                         (SPADCALL
                             (CONS #'|GUESS;FilteredPartitionStream!2|
                                   $)
                             |s1| (QREFELT $ 264)) . #0#)
                   (LETT |s3| (SPADCALL |s2| (QREFELT $ 266)) . #0#)
                   (EXIT (LETT |s|
                               (SPADCALL NIL
                                   (SPADCALL
                                    (CONS
                                     #'|GUESS;FilteredPartitionStream!3|
                                     (VECTOR |maxP| $ |maxD|))
                                    |s3| (QREFELT $ 275))
                                   (QREFELT $ 276)) . #0#)))))
           (LETT |s| (SPADCALL |s| (QREFELT $ 277)) . #0#)
           (EXIT (COND
                   ((SPADCALL |options| (QREFELT $ 278))
                    (SPADCALL |s| (QREFELT $ 279)))
                   ('T |s|))))))) 

(DEFUN |GUESS;FilteredPartitionStream!3| (|#1| $$)
  (PROG (|maxD| $ |maxP|)
    (LETT |maxD| (QREFELT $$ 2) . #0=(|GUESS;FilteredPartitionStream|))
    (LETT $ (QREFELT $$ 1) . #0#)
    (LETT |maxP| (QREFELT $$ 0) . #0#)
    (RETURN
      (PROGN
        (COND
          ((SPADCALL |maxD| (|spadConstant| $ 267) (QREFELT $ 268))
           (COND
             ((OR (SPADCALL |maxP|
                      (SPADCALL (|spadConstant| $ 269) (QREFELT $ 118))
                      (QREFELT $ 268))
                  (NULL (SPADCALL |maxP|
                            (SPADCALL |#1| (QREFELT $ 271))
                            (QREFELT $ 186))))
              (|spadConstant| $ 270))
             ('T (|spadConstant| $ 272))))
          ((OR (SPADCALL |maxD| (SPADCALL |#1| (QREFELT $ 273))
                   (QREFELT $ 186))
               (NULL (OR (SPADCALL |maxP|
                             (SPADCALL (|spadConstant| $ 269)
                                 (QREFELT $ 118))
                             (QREFELT $ 268))
                         (NULL (SPADCALL |maxP|
                                   (SPADCALL |#1| (QREFELT $ 271))
                                   (QREFELT $ 186))))))
           (|spadConstant| $ 272))
          ('T (|spadConstant| $ 270))))))) 

(DEFUN |GUESS;FilteredPartitionStream!2| (|#1| $)
  (SPADCALL |#1| (QREFELT $ 260))) 

(DEFUN |GUESS;FilteredPartitionStream!1| (|#1| $$)
  (PROG (|maxD| $ |maxP|)
    (LETT |maxD| (QREFELT $$ 2) . #0=(|GUESS;FilteredPartitionStream|))
    (LETT $ (QREFELT $$ 1) . #0#)
    (LETT |maxP| (QREFELT $$ 0) . #0#)
    (RETURN
      (PROGN
        (COND
          ((SPADCALL |maxD| (|spadConstant| $ 267) (QREFELT $ 268))
           (COND
             ((OR (SPADCALL |maxP|
                      (SPADCALL (|spadConstant| $ 269) (QREFELT $ 118))
                      (QREFELT $ 268))
                  (NULL (SPADCALL |maxP|
                            (SPADCALL |#1| (QREFELT $ 271))
                            (QREFELT $ 186))))
              (|spadConstant| $ 270))
             ('T (|spadConstant| $ 272))))
          ((OR (SPADCALL |maxD| (SPADCALL |#1| (QREFELT $ 273))
                   (QREFELT $ 186))
               (NULL (OR (SPADCALL |maxP|
                             (SPADCALL (|spadConstant| $ 269)
                                 (QREFELT $ 118))
                             (QREFELT $ 268))
                         (NULL (SPADCALL |maxP|
                                   (SPADCALL |#1| (QREFELT $ 271))
                                   (QREFELT $ 186))))))
           (|spadConstant| $ 272))
          ('T (|spadConstant| $ 270))))))) 

(DEFUN |GUESS;FilteredPartitionStream!0| (|#1| $)
  (SPADCALL |#1| (QREFELT $ 260))) 

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

(DEFUN |GUESS;ADEguessStream!0| (|#1| $$)
  (|GUESS;termAsUFPSF| (QREFELT $$ 3) |#1| (QREFELT $$ 2)
      (QREFELT $$ 1) (QREFELT $$ 0))) 

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

(DEFUN |GUESS;ADEguessStream2!0| (|#1| $$)
  (|GUESS;termAsUFPSF2| (QREFELT $$ 3) |#1| (QREFELT $$ 2)
      (QREFELT $$ 1) (QREFELT $$ 0))) 

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

(DEFUN |GUESS;ADEdegreeStream!0| (|#1| |#2| $)
  (PROG (#0=#:G55464)
    (RETURN
      (SPADCALL
          (COND
            ((SPADCALL |#1| (QREFELT $ 284)) (|spadConstant| $ 267))
            ('T
             (PROG1 (LETT #0#
                          (SPADCALL (SPADCALL |#1| (QREFELT $ 271))
                              (|spadConstant| $ 269) (QREFELT $ 185))
                          NIL)
               (|check-subtype| (>= #0# 0) '(|NonNegativeInteger|) #0#))))
          |#2| (QREFELT $ 285))))) 

(DEFUN |GUESS;ADEtestStream| (|f| |partitions| DSF D1F $)
  (SPADCALL (CONS #'|GUESS;ADEtestStream!0| (VECTOR $ D1F DSF |f|))
      |partitions| (QREFELT $ 293))) 

(DEFUN |GUESS;ADEtestStream!0| (|#1| $$)
  (|GUESS;termAsUFPSSUPF| (QREFELT $$ 3) |#1| (QREFELT $$ 2)
      (QREFELT $$ 1) (QREFELT $$ 0))) 

(DEFUN |GUESS;ADEtestStream2| (|f| |partitions| DSF D1F $)
  (SPADCALL (CONS #'|GUESS;ADEtestStream2!0| (VECTOR $ D1F DSF |f|))
      |partitions| (QREFELT $ 293))) 

(DEFUN |GUESS;ADEtestStream2!0| (|#1| $$)
  (|GUESS;termAsUFPSSUPF2| (QREFELT $$ 3) |#1| (QREFELT $$ 2)
      (QREFELT $$ 1) (QREFELT $$ 0))) 

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

(DEFUN |GUESS;ADEEXPRRStream!0| (|#1| $$)
  (|GUESS;termAsEXPRR| (QREFELT $$ 4) (QREFELT $$ 3) |#1|
      (QREFELT $$ 2) (QREFELT $$ 1) (QREFELT $$ 0))) 

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

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

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

(DEFUN |GUESS;diffAX| (|l| |x| |f| $)
  (SPADCALL (SPADCALL (SPADCALL |x| (QREFELT $ 24)) |l| (QREFELT $ 59))
      |f| (QREFELT $ 60))) 

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

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

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

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

(DEFUN |GUESS;diffHP;LR;56| (|options| $)
  (PROG (|partitions|)
    (RETURN
      (SEQ (COND
             ((SPADCALL |options| (QREFELT $ 306))
              (SEQ (LETT |partitions|
                         (|GUESS;FilteredPartitionStream| |options| $)
                         |GUESS;diffHP;LR;56|)
                   (EXIT (VECTOR (CONS #'|GUESS;diffHP;LR;56!0|
                                       (VECTOR $ |partitions|))
                                 (|GUESS;ADEdegreeStream| |partitions|
                                     $)
                                 (CONS #'|GUESS;diffHP;LR;56!1|
                                       (VECTOR $ |partitions|))
                                 (CONS #'|GUESS;diffHP;LR;56!2|
                                       (VECTOR $ |partitions|))
                                 (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;56!2| (|#1| |#2| $$)
  (PROG ($)
    (LETT $ (QREFELT $$ 0) |GUESS;diffHP;LR;56|)
    (RETURN
      (PROGN
        (|GUESS;ADEEXPRRStream| |#1| |#2| (QREFELT $$ 1)
            (CONS (|function| |GUESS;diffDX|) $)
            (CONS (|function| |GUESS;diff1X|) $) $))))) 

(DEFUN |GUESS;diffHP;LR;56!1| (|#1| $$)
  (PROG ($)
    (LETT $ (QREFELT $$ 0) |GUESS;diffHP;LR;56|)
    (RETURN
      (PROGN
        (|GUESS;ADEtestStream| |#1| (QREFELT $$ 1)
            (CONS (|function| |GUESS;diffDSF|) $)
            (|spadConstant| $ 308) $))))) 

(DEFUN |GUESS;diffHP;LR;56!0| (|#1| $$)
  (PROG ($)
    (LETT $ (QREFELT $$ 0) |GUESS;diffHP;LR;56|)
    (RETURN
      (PROGN
        (|GUESS;ADEguessStream| |#1| (QREFELT $$ 1)
            (CONS (|function| |GUESS;diffDS|) $) (|spadConstant| $ 307)
            $))))) 

(DEFUN |GUESS;qDiffDX| (|q| |expr| |x| |n| $)
  (SPADCALL |expr| (SPADCALL |x| (QREFELT $ 24))
      (SPADCALL
          (SPADCALL (SPADCALL |q| (QREFELT $ 24)) |n| (QREFELT $ 59))
          (SPADCALL |x| (QREFELT $ 24)) (QREFELT $ 60))
      (QREFELT $ 26))) 

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

(DEFUN |GUESS;qDiffDS!0| (|#1| $$)
  (PROG ($)
    (LETT $ (QREFELT $$ 1) |GUESS;qDiffDS|)
    (RETURN
      (PROGN
        (PROG (#0=#:G55495)
          (RETURN
            (SPADCALL (SPADCALL (QREFELT $$ 2) (QREFELT $ 209))
                      (PROG1 (LETT #0#
                                   (SPADCALL (QREFELT $$ 0) |#1|
                                    (QREFELT $ 318))
                                   NIL)
                        (|check-subtype| (>= #0# 0)
                            '(|NonNegativeInteger|) #0#))
                      (QREFELT $ 231)))))))) 

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

(DEFUN |GUESS;qDiffDSF!0| (|#1| $$)
  (PROG ($)
    (LETT $ (QREFELT $$ 1) |GUESS;qDiffDSF|)
    (RETURN
      (PROGN
        (PROG (#0=#:G55498)
          (RETURN
            (SPADCALL
                (SPADCALL (SPADCALL (QREFELT $$ 2) (QREFELT $ 209))
                    (QREFELT $ 321))
                (PROG1 (LETT #0#
                             (SPADCALL (QREFELT $$ 0) |#1|
                                 (QREFELT $ 318))
                             NIL)
                  (|check-subtype| (>= #0# 0) '(|NonNegativeInteger|)
                      #0#))
                (QREFELT $ 242)))))))) 

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

(DEFUN |GUESS;diffHP;SM;60!6| (|#1| $$)
  (PROG ($ |q|)
    (LETT $ (QREFELT $$ 1) . #0=(|GUESS;diffHP;SM;60|))
    (LETT |q| (QREFELT $$ 0) . #0#)
    (RETURN
      (PROGN
        (PROG (|partitions|)
          (RETURN
            (SEQ (COND
                   ((SPADCALL |#1| (QREFELT $ 306))
                    (SEQ (LETT |partitions|
                               (|GUESS;FilteredPartitionStream| |#1| $)
                               NIL)
                         (EXIT (VECTOR (CONS #'|GUESS;diffHP;SM;60!1|
                                        (VECTOR |q| $ |partitions|))
                                       (SPADCALL
                                        (LIST (|spadConstant| $ 267))
                                        (QREFELT $ 325))
                                       (CONS #'|GUESS;diffHP;SM;60!3|
                                        (VECTOR |q| $ |partitions|))
                                       (CONS #'|GUESS;diffHP;SM;60!5|
                                        (VECTOR |q| $ |partitions|))
                                       (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;60!5| (|#1| |#2| $$)
  (PROG ($)
    (LETT $ (QREFELT $$ 1) NIL)
    (RETURN
      (PROGN
        (|GUESS;ADEEXPRRStream| |#1| |#2| (QREFELT $$ 2)
            (CONS #'|GUESS;diffHP;SM;60!4| (VECTOR $ (QREFELT $$ 0)))
            (CONS (|function| |GUESS;diff1X|) $) $))))) 

(DEFUN |GUESS;diffHP;SM;60!4| (|#1| |#2| |#3| $$)
  (|GUESS;qDiffDX| (QREFELT $$ 1) |#1| |#2| |#3| (QREFELT $$ 0))) 

(DEFUN |GUESS;diffHP;SM;60!3| (|#1| $$)
  (PROG ($)
    (LETT $ (QREFELT $$ 1) NIL)
    (RETURN
      (PROGN
        (|GUESS;ADEtestStream| |#1| (QREFELT $$ 2)
            (CONS #'|GUESS;diffHP;SM;60!2| (VECTOR $ (QREFELT $$ 0)))
            (|spadConstant| $ 308) $))))) 

(DEFUN |GUESS;diffHP;SM;60!2| (|#1| |#2| $$)
  (|GUESS;qDiffDSF| (QREFELT $$ 1) |#1| |#2| (QREFELT $$ 0))) 

(DEFUN |GUESS;diffHP;SM;60!1| (|#1| $$)
  (PROG ($)
    (LETT $ (QREFELT $$ 1) NIL)
    (RETURN
      (PROGN
        (|GUESS;ADEguessStream| |#1| (QREFELT $$ 2)
            (CONS #'|GUESS;diffHP;SM;60!0| (VECTOR $ (QREFELT $$ 0)))
            (|spadConstant| $ 307) $))))) 

(DEFUN |GUESS;diffHP;SM;60!0| (|#1| |#2| $$)
  (|GUESS;qDiffDS| (QREFELT $$ 1) |#1| |#2| (QREFELT $$ 0))) 

(DEFUN |GUESS;ShiftSX| (|expr| |x| |n| $)
  (SPADCALL |expr| (SPADCALL |x| (QREFELT $ 24))
      (SPADCALL (SPADCALL |x| (QREFELT $ 24))
          (SPADCALL |n| (QREFELT $ 25)) (QREFELT $ 62))
      (QREFELT $ 26))) 

(DEFUN |GUESS;ShiftSXGF| (|expr| |x| |n| $)
  (PROG (#0=#:G55511 |i| #1=#:G55512 |l|)
    (RETURN
      (SEQ (COND
             ((ZEROP |n|) |expr|)
             ('T
              (SEQ (LETT |l|
                         (PROGN
                           (LETT #0# NIL . #2=(|GUESS;ShiftSXGF|))
                           (SEQ (LETT |i| 0 . #2#)
                                (LETT #1# (- |n| 1) . #2#) G190
                                (COND
                                  ((QSGREATERP |i| #1#) (GO G191)))
                                (SEQ (EXIT
                                      (LETT #0#
                                       (CONS
                                        (SPADCALL
                                         (SPADCALL
                                          (SPADCALL
                                           (SPADCALL |expr| |x| |i|
                                            (QREFELT $ 298))
                                           (SPADCALL
                                            (SPADCALL |i|
                                             (QREFELT $ 202))
                                            (QREFELT $ 25))
                                           (QREFELT $ 35))
                                          (SPADCALL |x| (QREFELT $ 24))
                                          (|spadConstant| $ 29)
                                          (QREFELT $ 26))
                                         (SPADCALL
                                          (SPADCALL |x| (QREFELT $ 24))
                                          |i| (QREFELT $ 59))
                                         (QREFELT $ 60))
                                        #0#) . #2#)))
                                (LETT |i| (QSADD1 |i|) . #2#) (GO G190)
                                G191 (EXIT (NREVERSE0 #0#)))) . #2#)
                   (EXIT (SPADCALL
                             (SPADCALL |expr|
                                 (SPADCALL (ELT $ 62) |l|
                                     (QREFELT $ 224))
                                 (QREFELT $ 116))
                             (SPADCALL (SPADCALL |x| (QREFELT $ 24))
                                 |n| (QREFELT $ 59))
                             (QREFELT $ 35)))))))))) 

(DEFUN |GUESS;ShiftSS| (|s| |n| $)
  (SPADCALL |s|
      (SPADCALL (CONS #'|GUESS;ShiftSS!0| $) |n| (QREFELT $ 331)))) 

(DEFUN |GUESS;ShiftSS!0| (|#1| $) (SPADCALL |#1| (QREFELT $ 328))) 

(DEFUN |GUESS;ShiftSF| (|s| |n| $)
  (SPADCALL |s|
      (SPADCALL (CONS #'|GUESS;ShiftSF!0| $) |n| (QREFELT $ 335)))) 

(DEFUN |GUESS;ShiftSF!0| (|#1| $) (SPADCALL |#1| (QREFELT $ 332))) 

(DEFUN |GUESS;ShiftAX| (|l| |n| |f| $)
  (SPADCALL (SPADCALL (SPADCALL |n| (QREFELT $ 24)) |l| (QREFELT $ 59))
            |f| (QREFELT $ 60))) 

(DEFUN |GUESS;ShiftAXGF| (|l| |x| |f| $)
  (PROG (#0=#:G55522 |i| |s|)
    (RETURN
      (SEQ (COND
             ((ZEROP |l|) |f|)
             ('T
              (SEQ (LETT |s|
                         (PROGN
                           (LETT #0# NIL . #1=(|GUESS;ShiftAXGF|))
                           (SEQ (LETT |i| 1 . #1#) G190
                                (COND
                                  ((QSGREATERP |i| |l|) (GO G191)))
                                (SEQ (EXIT
                                      (LETT #0#
                                       (CONS
                                        (SPADCALL
                                         (SPADCALL
                                          (SPADCALL
                                           (SPADCALL |l| |i|
                                            (QREFELT $ 337))
                                           (QREFELT $ 25))
                                          (SPADCALL
                                           (SPADCALL |x|
                                            (QREFELT $ 24))
                                           |i| (QREFELT $ 59))
                                          (QREFELT $ 60))
                                         (SPADCALL |f| |x| |i|
                                          (QREFELT $ 298))
                                         (QREFELT $ 60))
                                        #0#) . #1#)))
                                (LETT |i| (QSADD1 |i|) . #1#) (GO G190)
                                G191 (EXIT (NREVERSE0 #0#)))) . #1#)
                   (EXIT (SPADCALL (ELT $ 62) |s| (QREFELT $ 224)))))))))) 

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

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

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

(DEFUN |GUESS;shiftHP;LR;70| (|options| $)
  (PROG (|partitions|)
    (RETURN
      (SEQ (LETT |partitions|
                 (|GUESS;FilteredPartitionStream| |options| $)
                 |GUESS;shiftHP;LR;70|)
           (EXIT (COND
                   ((SPADCALL |options| (QREFELT $ 306))
                    (COND
                      ((EQL (SPADCALL |options| (QREFELT $ 249)) 1)
                       (VECTOR (CONS #'|GUESS;shiftHP;LR;70!0|
                                     (VECTOR $ |partitions|))
                               (|GUESS;ADEdegreeStream| |partitions| $)
                               (CONS #'|GUESS;shiftHP;LR;70!1|
                                     (VECTOR $ |partitions|))
                               (CONS #'|GUESS;shiftHP;LR;70!3|
                                     (VECTOR $ |partitions|))
                               (CONS (|function| |GUESS;ShiftA|) $)
                               (CONS (|function| |GUESS;ShiftAF|) $)
                               (CONS (|function| |GUESS;ShiftAXGF|) $)
                               (CONS (|function| |GUESS;ShiftC|) $)))
                      ('T
                       (|error| "Guess: no support for the Shift operator with displayAsGF                            and maxPower>1"))))
                   ('T
                    (VECTOR (CONS #'|GUESS;shiftHP;LR;70!4|
                                  (VECTOR $ |partitions|))
                            (|GUESS;ADEdegreeStream| |partitions| $)
                            (CONS #'|GUESS;shiftHP;LR;70!5|
                                  (VECTOR $ |partitions|))
                            (CONS #'|GUESS;shiftHP;LR;70!6|
                                  (VECTOR $ |partitions|))
                            (CONS (|function| |GUESS;ShiftA|) $)
                            (CONS (|function| |GUESS;ShiftAF|) $)
                            (CONS (|function| |GUESS;ShiftAX|) $)
                            (CONS (|function| |GUESS;ShiftC|) $))))))))) 

(DEFUN |GUESS;shiftHP;LR;70!6| (|#1| |#2| $$)
  (PROG ($)
    (LETT $ (QREFELT $$ 0) |GUESS;shiftHP;LR;70|)
    (RETURN
      (PROGN
        (|GUESS;ADEEXPRRStream| |#1| |#2| (QREFELT $$ 1)
            (CONS (|function| |GUESS;ShiftSX|) $)
            (CONS (|function| |GUESS;diff1X|) $) $))))) 

(DEFUN |GUESS;shiftHP;LR;70!5| (|#1| $$)
  (PROG ($)
    (LETT $ (QREFELT $$ 0) |GUESS;shiftHP;LR;70|)
    (RETURN
      (PROGN
        (|GUESS;ADEtestStream2| |#1| (QREFELT $$ 1)
            (CONS (|function| |GUESS;ShiftSF|) $)
            (SPADCALL
                (SPADCALL (|spadConstant| $ 308)
                    (SPADCALL (|spadConstant| $ 347)
                        (|spadConstant| $ 269) (QREFELT $ 348))
                    (QREFELT $ 349))
                (SPADCALL (|spadConstant| $ 344) (QREFELT $ 345))
                (QREFELT $ 350))
            $))))) 

(DEFUN |GUESS;shiftHP;LR;70!4| (|#1| $$)
  (PROG ($)
    (LETT $ (QREFELT $$ 0) |GUESS;shiftHP;LR;70|)
    (RETURN
      (PROGN
        (|GUESS;ADEguessStream2| |#1| (QREFELT $$ 1)
            (CONS (|function| |GUESS;ShiftSS|) $)
            (SPADCALL
                (SPADCALL (|spadConstant| $ 307)
                    (SPADCALL (|spadConstant| $ 12)
                        (|spadConstant| $ 269) (QREFELT $ 341))
                    (QREFELT $ 342))
                (SPADCALL (|spadConstant| $ 344) (QREFELT $ 345))
                (QREFELT $ 346))
            $))))) 

(DEFUN |GUESS;shiftHP;LR;70!3| (|#1| |#2| $$)
  (PROG ($)
    (LETT $ (QREFELT $$ 0) |GUESS;shiftHP;LR;70|)
    (RETURN
      (PROGN
        (|GUESS;ADEEXPRRStream| |#1| |#2| (QREFELT $$ 1)
            (CONS (|function| |GUESS;ShiftSXGF|) $)
            (CONS #'|GUESS;shiftHP;LR;70!2| $) $))))) 

(DEFUN |GUESS;shiftHP;LR;70!2| (|#1| $)
  (SPADCALL (|spadConstant| $ 177)
      (SPADCALL (|spadConstant| $ 177) (SPADCALL |#1| (QREFELT $ 24))
          (QREFELT $ 116))
      (QREFELT $ 35))) 

(DEFUN |GUESS;shiftHP;LR;70!1| (|#1| $$)
  (PROG ($)
    (LETT $ (QREFELT $$ 0) |GUESS;shiftHP;LR;70|)
    (RETURN
      (PROGN
        (|GUESS;ADEtestStream| |#1| (QREFELT $$ 1)
            (CONS (|function| |GUESS;ShiftSF|) $)
            (SPADCALL
                (SPADCALL (|spadConstant| $ 308)
                    (SPADCALL (|spadConstant| $ 347)
                        (|spadConstant| $ 269) (QREFELT $ 348))
                    (QREFELT $ 349))
                (SPADCALL (|spadConstant| $ 344) (QREFELT $ 345))
                (QREFELT $ 350))
            $))))) 

(DEFUN |GUESS;shiftHP;LR;70!0| (|#1| $$)
  (PROG ($)
    (LETT $ (QREFELT $$ 0) |GUESS;shiftHP;LR;70|)
    (RETURN
      (PROGN
        (|GUESS;ADEguessStream| |#1| (QREFELT $$ 1)
            (CONS (|function| |GUESS;ShiftSS|) $)
            (SPADCALL
                (SPADCALL (|spadConstant| $ 307)
                    (SPADCALL (|spadConstant| $ 12)
                        (|spadConstant| $ 269) (QREFELT $ 341))
                    (QREFELT $ 342))
                (SPADCALL (|spadConstant| $ 344) (QREFELT $ 345))
                (QREFELT $ 346))
            $))))) 

(DEFUN |GUESS;qShiftAX| (|q| |l| |n| |f| $)
  (SPADCALL
      (SPADCALL (SPADCALL |q| (QREFELT $ 24))
          (SPADCALL |l| (SPADCALL |n| (QREFELT $ 24)) (QREFELT $ 352))
          (QREFELT $ 172))
      |f| (QREFELT $ 60))) 

(DEFUN |GUESS;qShiftA| (|q| |k| |l| |f| $)
  (SPADCALL (SPADCALL |q| (QREFELT $ 353)) |k| |l| |f| (QREFELT $ 354))) 

(DEFUN |GUESS;qShiftAF| (|q| |k| |l| |f| $)
  (SPADCALL (SPADCALL (SPADCALL |q| (QREFELT $ 209)) (QREFELT $ 321))
      |k| |l| |f| (QREFELT $ 355))) 

(DEFUN |GUESS;qShiftC| (|q| |total| $)
  (SPADCALL (SPADCALL |q| (QREFELT $ 353)) |total| (QREFELT $ 356))) 

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

(DEFUN |GUESS;shiftHP;SM;75!7| (|#1| $$)
  (PROG ($ |q|)
    (LETT $ (QREFELT $$ 1) . #0=(|GUESS;shiftHP;SM;75|))
    (LETT |q| (QREFELT $$ 0) . #0#)
    (RETURN
      (PROGN
        (PROG (|partitions|)
          (RETURN
            (SEQ (LETT |partitions|
                       (|GUESS;FilteredPartitionStream| |#1| $) NIL)
                 (EXIT (COND
                         ((SPADCALL |#1| (QREFELT $ 306))
                          (|error| "Guess: no support for the qShift operator with displayAsGF"))
                         ('T
                          (VECTOR (CONS #'|GUESS;shiftHP;SM;75!0|
                                        (VECTOR $ |partitions|))
                                  (|GUESS;ADEdegreeStream| |partitions|
                                      $)
                                  (CONS #'|GUESS;shiftHP;SM;75!1|
                                        (VECTOR $ |partitions|))
                                  (CONS #'|GUESS;shiftHP;SM;75!2|
                                        (VECTOR $ |partitions|))
                                  (CONS #'|GUESS;shiftHP;SM;75!3|
                                        (VECTOR $ |q|))
                                  (CONS #'|GUESS;shiftHP;SM;75!4|
                                        (VECTOR $ |q|))
                                  (CONS #'|GUESS;shiftHP;SM;75!5|
                                        (VECTOR $ |q|))
                                  (CONS #'|GUESS;shiftHP;SM;75!6|
                                        (VECTOR $ |q|))))))))))))) 

(DEFUN |GUESS;shiftHP;SM;75!6| (|#1| $$)
  (|GUESS;qShiftC| (QREFELT $$ 1) |#1| (QREFELT $$ 0))) 

(DEFUN |GUESS;shiftHP;SM;75!5| (|#1| |#2| |#3| $$)
  (|GUESS;qShiftAX| (QREFELT $$ 1) |#1| |#2| |#3| (QREFELT $$ 0))) 

(DEFUN |GUESS;shiftHP;SM;75!4| (|#1| |#2| |#3| $$)
  (|GUESS;qShiftAF| (QREFELT $$ 1) |#1| |#2| |#3| (QREFELT $$ 0))) 

(DEFUN |GUESS;shiftHP;SM;75!3| (|#1| |#2| |#3| $$)
  (|GUESS;qShiftA| (QREFELT $$ 1) |#1| |#2| |#3| (QREFELT $$ 0))) 

(DEFUN |GUESS;shiftHP;SM;75!2| (|#1| |#2| $$)
  (PROG ($)
    (LETT $ (QREFELT $$ 0) NIL)
    (RETURN
      (PROGN
        (|GUESS;ADEEXPRRStream| |#1| |#2| (QREFELT $$ 1)
            (CONS (|function| |GUESS;ShiftSX|) $)
            (CONS (|function| |GUESS;diff1X|) $) $))))) 

(DEFUN |GUESS;shiftHP;SM;75!1| (|#1| $$)
  (PROG ($)
    (LETT $ (QREFELT $$ 0) NIL)
    (RETURN
      (PROGN
        (|GUESS;ADEtestStream2| |#1| (QREFELT $$ 1)
            (CONS (|function| |GUESS;ShiftSF|) $)
            (SPADCALL
                (SPADCALL (|spadConstant| $ 308)
                    (SPADCALL (|spadConstant| $ 347)
                        (|spadConstant| $ 269) (QREFELT $ 348))
                    (QREFELT $ 349))
                (SPADCALL (|spadConstant| $ 344) (QREFELT $ 345))
                (QREFELT $ 350))
            $))))) 

(DEFUN |GUESS;shiftHP;SM;75!0| (|#1| $$)
  (PROG ($)
    (LETT $ (QREFELT $$ 0) NIL)
    (RETURN
      (PROGN
        (|GUESS;ADEguessStream2| |#1| (QREFELT $$ 1)
            (CONS (|function| |GUESS;ShiftSS|) $)
            (SPADCALL
                (SPADCALL (|spadConstant| $ 307)
                    (SPADCALL (|spadConstant| $ 12)
                        (|spadConstant| $ 269) (QREFELT $ 341))
                    (QREFELT $ 342))
                (SPADCALL (|spadConstant| $ 344) (QREFELT $ 345))
                (QREFELT $ 346))
            $))))) 

(DEFUN |GUESS;makeEXPRR| (DAX |x| |p| |expr| $)
  (COND
    ((SPADCALL |p| (QREFELT $ 55)) (|spadConstant| $ 29))
    ('T
     (SPADCALL
         (SPADCALL
             (SPADCALL (SPADCALL |p| (QREFELT $ 56)) (QREFELT $ 11))
             (SPADCALL (SPADCALL |p| (QREFELT $ 58)) |x| |expr| DAX)
             (QREFELT $ 60))
         (|GUESS;makeEXPRR| DAX |x| (SPADCALL |p| (QREFELT $ 61))
             |expr| $)
         (QREFELT $ 62))))) 

(DEFUN |GUESS;list2UFPSF| (|list| $)
  (SPADCALL (SPADCALL |list| (QREFELT $ 359)) (QREFELT $ 360))) 

(DEFUN |GUESS;list2UFPSSUPF| (|list| $)
  (PROG (#0=#:G55543 |i| |e| #1=#:G55544 |l|)
    (RETURN
      (SEQ (LETT |l|
                 (SPADCALL
                     (PROGN
                       (LETT #0# NIL . #2=(|GUESS;list2UFPSSUPF|))
                       (SEQ (LETT |i| 0 . #2#) (LETT |e| NIL . #2#)
                            (LETT #1# |list| . #2#) G190
                            (COND
                              ((OR (ATOM #1#)
                                   (PROGN
                                     (LETT |e| (CAR #1#) . #2#)
                                     NIL))
                               (GO G191)))
                            (SEQ (EXIT (LETT #0#
                                        (CONS
                                         (SPADCALL |e| (QREFELT $ 321))
                                         #0#) . #2#)))
                            (LETT #1#
                                  (PROG1 (CDR #1#)
                                    (LETT |i| (QSADD1 |i|) . #2#)) . #2#)
                            (GO G190) G191 (EXIT (NREVERSE0 #0#))))
                     (QREFELT $ 363)) . #2#)
           (EXIT (SPADCALL (SPADCALL |l| (QREFELT $ 364))
                     (SPADCALL
                         (SPADCALL (|spadConstant| $ 12) 1
                             (QREFELT $ 78))
                         (LENGTH |list|) (QREFELT $ 348))
                     (QREFELT $ 365))))))) 

(DEFUN |GUESS;SUPF2SUPSUPF| (|p| $)
  (SPADCALL (CONS #'|GUESS;SUPF2SUPSUPF!0| $) |p| (QREFELT $ 369))) 

(DEFUN |GUESS;SUPF2SUPSUPF!0| (|#1| $)
  (SPADCALL |#1| (QREFELT $ 321))) 

(DEFUN |GUESS;UFPSF2SUPF| (|f| |deg| $)
  (SPADCALL (SPADCALL |f| |deg| (QREFELT $ 371)) (QREFELT $ 372))) 

(DEFUN |GUESS;getListSUPF| (|s| |o| |deg| $)
  (SPADCALL (CONS #'|GUESS;getListSUPF!0| (VECTOR $ |deg|))
      (SPADCALL
          (SPADCALL (SPADCALL |s| |o| (QREFELT $ 373)) (QREFELT $ 374))
          (QREFELT $ 375))
      (QREFELT $ 378))) 

(DEFUN |GUESS;getListSUPF!0| (|#1| $$)
  (|GUESS;UFPSF2SUPF| |#1| (QREFELT $$ 1) (QREFELT $$ 0))) 

(DEFUN |GUESS;S2EXPRR| (|s| $)
  (COND
    ((|domainEqual| (QREFELT $ 6) (QREFELT $ 7))
     (SPADCALL |s| (QREFELT $ 11)))
    ((|domainEqual| (QREFELT $ 6) (|Fraction| (QREFELT $ 7)))
     (SPADCALL (SPADCALL |s| (QREFELT $ 39)) (QREFELT $ 11)))
    ('T
     (|error| "Type parameter F should be either equal to S or equal                         to Fraction S")))) 

(DEFUN |GUESS;guessInterpolate| (|guessList| |eta| D $)
  (PROG (|vguessList| |vguessListF|)
    (RETURN
      (SEQ (COND
             ((|domainEqual| (QREFELT $ 6) (QREFELT $ 7))
              (SEQ (LETT |vguessList|
                         (SPADCALL |guessList| (QREFELT $ 381))
                         . #0=(|GUESS;guessInterpolate|))
                   (EXIT (SPADCALL
                             (SPADCALL
                                 (SPADCALL (ELT $ 382) |eta|
                                     (QREFELT $ 384))
                                 (QVELT D 7))
                             (QVELT D 4) |vguessList| |eta|
                             (QREFELT $ 386)))))
             ((|domainEqual| (QREFELT $ 6) (|Fraction| (QREFELT $ 7)))
              (SEQ (LETT |vguessListF|
                         (SPADCALL |guessList| (QREFELT $ 388)) . #0#)
                   (EXIT (SPADCALL
                             (SPADCALL
                                 (SPADCALL (ELT $ 382) |eta|
                                     (QREFELT $ 384))
                                 (QVELT D 7))
                             (QVELT D 4) |vguessListF| |eta|
                             (QREFELT $ 390)))))
             ('T
              (|error| "Type parameter F should be either equal to S or equal                         to Fraction S"))))))) 

(DEFUN |GUESS;guessInterpolate2| (|guessList| |sumEta| |maxEta| D $)
  (PROG (|vguessList| |vguessListF|)
    (RETURN
      (SEQ (COND
             ((|domainEqual| (QREFELT $ 6) (QREFELT $ 7))
              (SEQ (LETT |vguessList|
                         (SPADCALL |guessList| (QREFELT $ 381))
                         . #0=(|GUESS;guessInterpolate2|))
                   (EXIT (SPADCALL (SPADCALL |sumEta| (QVELT D 7))
                             (QVELT D 4) |vguessList| |sumEta| |maxEta|
                             (QREFELT $ 392)))))
             ((|domainEqual| (QREFELT $ 6) (|Fraction| (QREFELT $ 7)))
              (SEQ (LETT |vguessListF|
                         (SPADCALL |guessList| (QREFELT $ 388)) . #0#)
                   (EXIT (SPADCALL (SPADCALL |sumEta| (QVELT D 7))
                             (QVELT D 4) |vguessListF| |sumEta|
                             |maxEta| (QREFELT $ 393)))))
             ('T
              (|error| "Type parameter F should be either equal to S or equal                         to Fraction S"))))))) 

(DEFUN |GUESS;testInterpolant|
       (|resi| |list| |testList| |exprList| |initials| |guessDegree| D
               |dummy| |op| |options| $)
  (PROG (|i| #0=#:G55665 |nonZeroCoefficient| #1=#:G55570 |resiSUPF|
             |d| |c| |iterate?| #2=#:G55574 #3=#:G55666 #4=#:G55664
             #5=#:G55595 |g| |resiF| #6=#:G55667 |e| #7=#:G55669 |p|
             #8=#:G55668 |ex| |res| |ord|)
    (RETURN
      (SEQ (EXIT (SEQ (COND
                        ((EQL (SPADCALL |options| (QREFELT $ 123)) -1)
                         (COND
                           ((|BooleanEquality|
                                (SPADCALL |options| (QREFELT $ 394))
                                'NIL)
                            (COND
                              ((SPADCALL
                                   (SPADCALL |resi| (QREFELT $ 395))
                                   (QREFELT $ 396))
                               (EXIT (PROGN
                                       (LETT #4# (CONS 0 "failed")
                                        . #9=(|GUESS;testInterpolant|))
                                       (GO #4#)))))))))
                      (LETT |nonZeroCoefficient| 0 . #9#)
                      (SEQ (EXIT (SEQ (LETT |i| 1 . #9#)
                                      (LETT #0# (LENGTH |resi|) . #9#)
                                      G190
                                      (COND
                                        ((QSGREATERP |i| #0#)
                                         #10=(GO G191)))
                                      (SEQ
                                       (EXIT
                                        (COND
                                          ((NULL
                                            (SPADCALL
                                             (SPADCALL |resi| |i|
                                              (QREFELT $ 397))
                                             (QREFELT $ 396)))
                                           (COND
                                             ((ZEROP
                                               |nonZeroCoefficient|)
                                              (LETT
                                               |nonZeroCoefficient|
                                               |i| . #9#))
                                             ('T
                                              (SEQ
                                               (LETT
                                                |nonZeroCoefficient|
                                                0 . #9#)
                                               (EXIT
                                                (PROGN
                                                  (LETT #1#
                                                   |$NoValue| . #9#)
                                                  (GO #1#))))))))))
                                      (LETT |i| (QSADD1 |i|) . #9#)
                                      #11=(GO G190) G191 (EXIT NIL)))
                           #1# (EXIT #1#))
                      (COND
                        ((ZEROP |nonZeroCoefficient|)
                         (SEQ (LETT |resiSUPF|
                                    (SPADCALL
                                     (CONS #'|GUESS;testInterpolant!0|
                                      $)
                                     |resi| (QREFELT $ 401)) . #9#)
                              (LETT |iterate?| 'T . #9#)
                              (SEQ (EXIT
                                    (SEQ
                                     (LETT |d|
                                      (+ |guessDegree| 1) . #9#)
                                     G190 NIL
                                     (SEQ
                                      (LETT |c|
                                       (SPADCALL (QVELT D 5)
                                        (SPADCALL |testList|
                                         (QREFELT $ 403))
                                        |d|
                                        (SPADCALL |resiSUPF|
                                         (QREFELT $ 405))
                                        (QREFELT $ 406)) . #9#)
                                      (EXIT
                                       (COND
                                         ((NULL
                                           (SPADCALL |c|
                                            (QREFELT $ 55)))
                                          (SEQ
                                           (LETT |iterate?|
                                            (SPADCALL |c|
                                             (QREFELT $ 407)) . #9#)
                                           (EXIT
                                            (PROGN
                                              (LETT #2#
                                               |$NoValue| . #9#)
                                              (GO #2#))))))))
                                     (LETT |d| (+ |d| 1) . #9#) #11#
                                     G191 (EXIT NIL)))
                                   #2# (EXIT #2#))
                              (EXIT (COND
                                      (|iterate?|
                                       (PROGN
                                         (LETT #4#
                                          (CONS 0 "failed") . #9#)
                                         (GO #4#)))))))
                        ((SPADCALL
                             (SPADCALL |exprList| |nonZeroCoefficient|
                                 (QREFELT $ 408))
                             (SPADCALL |op| (QREFELT $ 410))
                             (QREFELT $ 411))
                         (PROGN
                           (LETT #4# (CONS 0 "failed") . #9#)
                           (GO #4#)))
                        ('T
                         (SEQ (LETT |e| NIL . #9#)
                              (LETT #3# |list| . #9#) G190
                              (COND
                                ((OR (ATOM #3#)
                                     (PROGN
                                       (LETT |e| (CAR #3#) . #9#)
                                       NIL))
                                 #10#))
                              (SEQ (EXIT
                                    (COND
                                      ((NULL
                                        (SPADCALL |e| (QREFELT $ 412)))
                                       (PROGN
                                         (LETT #4#
                                          (CONS 0 "failed") . #9#)
                                         (GO #4#))))))
                              (LETT #3# (CDR #3#) . #9#) #11# G191
                              (EXIT NIL))))
                      (COND
                        ((|HasCategory| (QREFELT $ 7) '(|Field|))
                         (LETT |g|
                               (SPADCALL
                                   (SPADCALL
                                    (PROG2
                                     (LETT #5#
                                      (SPADCALL
                                       (CONS
                                        #'|GUESS;testInterpolant!1| $)
                                       (REVERSE |resi|)
                                       (QREFELT $ 419)) . #9#)
                                     (QCDR #5#)
                                      (|check-union| (QEQCAR #5# 0)
                                       (|SparseUnivariatePolynomial|
                                        (QREFELT $ 7))
                                       #5#))
                                    (QREFELT $ 103))
                                   (QREFELT $ 420)) . #9#))
                        ('T
                         (LETT |g|
                               (SPADCALL |resi| (QREFELT $ 422)) . #9#)))
                      (LETT |resiF|
                            (SPADCALL
                                (CONS #'|GUESS;testInterpolant!2|
                                      (VECTOR (QREFELT $ 7) $ |g|))
                                |resi| (QREFELT $ 426)) . #9#)
                      (COND
                        ((SPADCALL |options| (QREFELT $ 124))
                         (SPADCALL
                             (SPADCALL "trying possible solution "
                                 (SPADCALL |resiF| (QREFELT $ 427))
                                 (QREFELT $ 127))
                             (QREFELT $ 130))))
                      (LETT |ex|
                            (PROGN
                              (LETT #6# NIL . #9#)
                              (SEQ (LETT |e| NIL . #9#)
                                   (LETT #7# |exprList| . #9#)
                                   (LETT |p| NIL . #9#)
                                   (LETT #8# |resiF| . #9#) G190
                                   (COND
                                     ((OR (ATOM #8#)
                                       (PROGN
                                         (LETT |p| (CAR #8#) . #9#)
                                         NIL)
                                       (ATOM #7#)
                                       (PROGN
                                         (LETT |e| (CAR #7#) . #9#)
                                         NIL))
                                      #10#))
                                   (SEQ
                                    (EXIT
                                     (LETT #6#
                                      (CONS
                                       (|GUESS;makeEXPRR| (QVELT D 6)
                                        |dummy| |p| |e| $)
                                       #6#) . #9#)))
                                   (LETT #8#
                                    (PROG1 (CDR #8#)
                                      (LETT #7# (CDR #7#) . #9#)) . #9#)
                                   #11# G191 (EXIT (NREVERSE0 #6#)))) . #9#)
                      (COND
                        ((SPADCALL |options| (QREFELT $ 306))
                         (SEQ (LETT |res|
                                    (SPADCALL |op| |dummy|
                                     (SPADCALL
                                      (SPADCALL |options|
                                       (QREFELT $ 428))
                                      (QREFELT $ 24))
                                     (SPADCALL
                                      (SPADCALL |options|
                                       (QREFELT $ 175))
                                      (QREFELT $ 24))
                                     (SPADCALL
                                      (SPADCALL (ELT $ 62) |ex|
                                       (QREFELT $ 224))
                                      (QREFELT $ 32))
                                     (REVERSE |initials|)
                                     (QREFELT $ 430)) . #9#)
                              (EXIT (LETT |ord| 0 . #9#))))
                        ('T
                         (SEQ (LETT |res|
                                    (SPADCALL |op| |dummy|
                                     (SPADCALL
                                      (SPADCALL |options|
                                       (QREFELT $ 175))
                                      (QREFELT $ 24))
                                     (SPADCALL
                                      (SPADCALL |options|
                                       (QREFELT $ 175))
                                      (QREFELT $ 24))
                                     (SPADCALL
                                      (SPADCALL (ELT $ 62) |ex|
                                       (QREFELT $ 224))
                                      (QREFELT $ 32))
                                     (REVERSE |initials|)
                                     (QREFELT $ 431)) . #9#)
                              (EXIT (LETT |ord|
                                     (|GUESS;checkResult| |res|
                                      (SPADCALL |options|
                                       (QREFELT $ 175))
                                      (LENGTH |list|) |list| |options|
                                      $) . #9#)))))
                      (EXIT (CONS 1 (CONS |res| |ord|)))))
           #4# (EXIT #4#))))) 

(DEFUN |GUESS;testInterpolant!2| (|#1| $$)
  (PROG ($)
    (LETT $ (QREFELT $$ 1) |GUESS;testInterpolant|)
    (RETURN
      (PROGN
        (PROG (#0=#:G55595)
          (RETURN
            (|GUESS;SUPS2SUPF|
                (PROG2 (LETT #0#
                             (SPADCALL |#1| (QREFELT $$ 2)
                                 (QREFELT $ 423))
                             NIL)
                       (QCDR #0#)
                  (|check-union| (QEQCAR #0# 0)
                      (|SparseUnivariatePolynomial| (QREFELT $$ 0))
                      #0#))
                $))))))) 

(DEFUN |GUESS;testInterpolant!1| (|#1| $)
  (COND
    ((SPADCALL |#1| (QREFELT $ 396)) (|spadConstant| $ 272))
    ('T (|spadConstant| $ 270)))) 

(DEFUN |GUESS;testInterpolant!0| (|#1| $)
  (|GUESS;SUPF2SUPSUPF| (|GUESS;SUPS2SUPF| |#1| $) $)) 

(DEFUN |GUESS;guessHPaux| (|list| D |options| $)
  (PROG (|listDegree| |a| |op| |x| |dummy| #0=#:G56264 |e| #1=#:G56265
            |initials| |guessS| |degreeS| |testS| |exprS| |o|
            #2=#:G55676 #3=#:G56261 |maxEta| #4=#:G55702 |maxParams|
            #5=#:G56266 #6=#:G55707 #7=#:G56267 #8=#:G56268
            |newGuessDegree| #9=#:G56269 #10=#:G55716 #11=#:G56270
            #12=#:G56271 #13=#:G56196 |newMaxParams| #14=#:G56272
            #15=#:G56197 #16=#:G56273 #17=#:G56274 #18=#:G56275
            #19=#:G56210 #20=#:G56276 #21=#:G56277 |guessDegree|
            #22=#:G56278 #23=#:G56220 #24=#:G56279 #25=#:G56280 |eta|
            |iterate?| #26=#:G56232 |guessList| |testList| |exprList|
            #27=#:G56236 #28=#:G56237 #29=#:G56247 #30=#:G56238 MS M
            |i| #31=#:G56249 |res| |reslist| #32=#:G56263)
    (RETURN
      (SEQ (EXIT (SEQ (LETT |reslist| NIL . #33=(|GUESS;guessHPaux|))
                      (LETT |listDegree|
                            (- (- (LENGTH |list|) 1)
                               (SPADCALL |options| (QREFELT $ 174))) . #33#)
                      (COND
                        ((< |listDegree| 0)
                         (PROGN
                           (LETT #32# |reslist| . #33#)
                           (GO #32#))))
                      (LETT |a|
                            (SPADCALL |options| (QREFELT $ 432)) . #33#)
                      (LETT |op| (SPADCALL |a| (QREFELT $ 433)) . #33#)
                      (LETT |x|
                            (SPADCALL |options| (QREFELT $ 428)) . #33#)
                      (LETT |dummy| (SPADCALL (QREFELT $ 434)) . #33#)
                      (LETT |initials|
                            (PROGN
                              (LETT #0# NIL . #33#)
                              (SEQ (LETT |e| NIL . #33#)
                                   (LETT #1# |list| . #33#) G190
                                   (COND
                                     ((OR (ATOM #1#)
                                       (PROGN
                                         (LETT |e| (CAR #1#) . #33#)
                                         NIL))
                                      #34=(GO G191)))
                                   (SEQ
                                    (EXIT
                                     (LETT #0#
                                      (CONS
                                       (SPADCALL |e| (QREFELT $ 11))
                                       #0#) . #33#)))
                                   (LETT #1# (CDR #1#) . #33#)
                                   #35=(GO G190) G191
                                   (EXIT (NREVERSE0 #0#)))) . #33#)
                      (LETT |guessS|
                            (SPADCALL (|GUESS;list2UFPSF| |list| $)
                                (QVELT D 0)) . #33#)
                      (LETT |degreeS| (QVELT D 1) . #33#)
                      (LETT |testS|
                            (SPADCALL (|GUESS;list2UFPSSUPF| |list| $)
                                (QVELT D 2)) . #33#)
                      (LETT |exprS|
                            (SPADCALL
                                (SPADCALL |op|
                                    (SPADCALL |dummy| (QREFELT $ 24))
                                    (QREFELT $ 435))
                                |dummy| (QVELT D 3)) . #33#)
                      (LETT |iterate?| 'NIL . #33#)
                      (SEQ (EXIT (SEQ (LETT |o| 2 . #33#) G190 NIL
                                      (SEQ
                                       (EXIT
                                        (COND
                                          ((SPADCALL
                                            (SPADCALL |guessS|
                                             (PROG1
                                              (LETT #2#
                                               (- |o| 1) . #33#)
                                               (|check-subtype|
                                                (>= #2# 0)
                                                '(|NonNegativeInteger|)
                                                #2#))
                                             (QREFELT $ 436))
                                            (QREFELT $ 437))
                                           (PROGN
                                             (LETT #3#
                                              |$NoValue| . #33#)
                                             (GO #3#)))
                                          ('T
                                           (SEQ
                                            (LETT |guessDegree|
                                             (- |listDegree|
                                              (SPADCALL |degreeS| |o|
                                               (QREFELT $ 438))) . #33#)
                                            (EXIT
                                             (COND
                                               ((< |guessDegree| 0)
                                                (PROGN
                                                  (LETT #3#
                                                   |$NoValue| . #33#)
                                                  (GO #3#)))
                                               ('T
                                                (SEQ
                                                 (COND
                                                   ((SPADCALL |options|
                                                     (QREFELT $ 124))
                                                    (SEQ
                                                     (SPADCALL
                                                      (SPADCALL
                                                       "Trying order "
                                                       (SPADCALL |o|
                                                        (QREFELT $ 126))
                                                       (QREFELT $ 127))
                                                      (QREFELT $ 130))
                                                     (EXIT
                                                      (SPADCALL
                                                       (SPADCALL
                                                        "guessDegree is "
                                                        (SPADCALL
                                                         |guessDegree|
                                                         (QREFELT $
                                                          439))
                                                        (QREFELT $ 127))
                                                       (QREFELT $ 130))))))
                                                 (COND
                                                   ((SPADCALL |options|
                                                     (QREFELT $ 394))
                                                    (COND
                                                      ((<
                                                        (+
                                                         |guessDegree|
                                                         2)
                                                        |o|)
                                                       (PROGN
                                                         (LETT #32#
                                                          |reslist| . #33#)
                                                         (GO #32#)))
                                                      ('T
                                                       (SEQ
                                                        (LETT |maxEta|
                                                         (+ 1
                                                          (SPADCALL
                                                           |options|
                                                           (QREFELT $
                                                            123))) . #33#)
                                                        (EXIT
                                                         (COND
                                                           ((EQL
                                                             |maxEta|
                                                             0)
                                                            (LETT
                                                             |maxEta|
                                                             (+
                                                              |guessDegree|
                                                              1) . #33#))))))))
                                                   ('T
                                                    (SEQ
                                                     (LETT |maxParams|
                                                      (DIVIDE2
                                                       (+
                                                        (PROG1
                                                         (LETT #4#
                                                          |guessDegree| . #33#)
                                                          (|check-subtype|
                                                           (>= #4# 0)
                                                           '(|NonNegativeInteger|)
                                                           #4#))
                                                        1)
                                                       |o|) . #33#)
                                                     (COND
                                                       ((SPADCALL
                                                         |options|
                                                         (QREFELT $
                                                          124))
                                                        (SPADCALL
                                                         (SPADCALL
                                                          "maxParams: "
                                                          (|coerceRe2E|
                                                           |maxParams|
                                                           (ELT
                                                            (|Record|
                                                             (|:|
                                                              |quotient|
                                                              (|NonNegativeInteger|))
                                                             (|:|
                                                              |remainder|
                                                              (|NonNegativeInteger|)))
                                                            0))
                                                          (QREFELT $
                                                           127))
                                                         (QREFELT $
                                                          130))))
                                                     (COND
                                                       ((EQL
                                                         (QCAR
                                                          |maxParams|)
                                                         0)
                                                        (COND
                                                          ((<
                                                            (QCDR
                                                             |maxParams|)
                                                            (- |o| 1))
                                                           (PROGN
                                                             (LETT #32#
                                                              |reslist| . #33#)
                                                             (GO #32#))))))
                                                     (EXIT
                                                      (COND
                                                        ((SPADCALL
                                                          (SPADCALL
                                                           |options|
                                                           (QREFELT $
                                                            123))
                                                          -1
                                                          (QREFELT $
                                                           440))
                                                         (COND
                                                           ((<
                                                             (SPADCALL
                                                              |options|
                                                              (QREFELT
                                                               $ 123))
                                                             (QCAR
                                                              |maxParams|))
                                                            (COND
                                                              ((SPADCALL
                                                                (SPADCALL
                                                                 |guessS|
                                                                 |o|
                                                                 (QREFELT
                                                                  $
                                                                  436))
                                                                (QREFELT
                                                                 $ 437))
                                                               (COND
                                                                 ((SPADCALL
                                                                   (SPADCALL
                                                                    |options|
                                                                    (QREFELT
                                                                     $
                                                                     123))
                                                                   -1
                                                                   (QREFELT
                                                                    $
                                                                    440))
                                                                  (COND
                                                                    ((<
                                                                      (SPADCALL
                                                                       |options|
                                                                       (QREFELT
                                                                        $
                                                                        123))
                                                                      (QCAR
                                                                       |maxParams|))
                                                                     (SEQ
                                                                      (LETT
                                                                       |guessDegree|
                                                                       (-
                                                                        (SPADCALL
                                                                         |o|
                                                                         (+
                                                                          1
                                                                          (SPADCALL
                                                                           |options|
                                                                           (QREFELT
                                                                            $
                                                                            123)))
                                                                         (QREFELT
                                                                          $
                                                                          318))
                                                                        2) . #33#)
                                                                      (EXIT
                                                                       (LETT
                                                                        |eta|
                                                                        (PROGN
                                                                          (LETT
                                                                           #5#
                                                                           NIL . #33#)
                                                                          (SEQ
                                                                           (LETT
                                                                            |i|
                                                                            1 . #33#)
                                                                           G190
                                                                           (COND
                                                                             ((QSGREATERP
                                                                               |i|
                                                                               |o|)
                                                                              #34#))
                                                                           (SEQ
                                                                            (EXIT
                                                                             (LETT
                                                                              #5#
                                                                              (CONS
                                                                               (PROG1
                                                                                (LETT
                                                                                 #6#
                                                                                 (COND
                                                                                   ((<
                                                                                     |i|
                                                                                     |o|)
                                                                                    (+
                                                                                     (SPADCALL
                                                                                      |options|
                                                                                      (QREFELT
                                                                                       $
                                                                                       123))
                                                                                     1))
                                                                                   ('T
                                                                                    (SPADCALL
                                                                                     |options|
                                                                                     (QREFELT
                                                                                      $
                                                                                      123)))) . #33#)
                                                                                 (|check-subtype|
                                                                                  (>=
                                                                                   #6#
                                                                                   0)
                                                                                  '(|NonNegativeInteger|)
                                                                                  #6#))
                                                                               #5#) . #33#)))
                                                                           (LETT
                                                                            |i|
                                                                            (QSADD1
                                                                             |i|) . #33#)
                                                                           #35#
                                                                           G191
                                                                           (EXIT
                                                                            (NREVERSE0
                                                                             #5#)))) . #33#))))
                                                                    ('T
                                                                     (LETT
                                                                      |eta|
                                                                      (PROGN
                                                                        (LETT
                                                                         #7#
                                                                         NIL . #33#)
                                                                        (SEQ
                                                                         (LETT
                                                                          |i|
                                                                          1 . #33#)
                                                                         G190
                                                                         (COND
                                                                           ((QSGREATERP
                                                                             |i|
                                                                             |o|)
                                                                            #34#))
                                                                         (SEQ
                                                                          (EXIT
                                                                           (LETT
                                                                            #7#
                                                                            (CONS
                                                                             (COND
                                                                               ((<
                                                                                 (QCDR
                                                                                  |maxParams|)
                                                                                 |i|)
                                                                                (QCAR
                                                                                 |maxParams|))
                                                                               ('T
                                                                                (+
                                                                                 (QCAR
                                                                                  |maxParams|)
                                                                                 1)))
                                                                             #7#) . #33#)))
                                                                         (LETT
                                                                          |i|
                                                                          (QSADD1
                                                                           |i|) . #33#)
                                                                         #35#
                                                                         G191
                                                                         (EXIT
                                                                          (NREVERSE0
                                                                           #7#)))) . #33#))))
                                                                 ('T
                                                                  (LETT
                                                                   |eta|
                                                                   (PROGN
                                                                     (LETT
                                                                      #8#
                                                                      NIL . #33#)
                                                                     (SEQ
                                                                      (LETT
                                                                       |i|
                                                                       1 . #33#)
                                                                      G190
                                                                      (COND
                                                                        ((QSGREATERP
                                                                          |i|
                                                                          |o|)
                                                                         #34#))
                                                                      (SEQ
                                                                       (EXIT
                                                                        (LETT
                                                                         #8#
                                                                         (CONS
                                                                          (COND
                                                                            ((<
                                                                              (QCDR
                                                                               |maxParams|)
                                                                              |i|)
                                                                             (QCAR
                                                                              |maxParams|))
                                                                            ('T
                                                                             (+
                                                                              (QCAR
                                                                               |maxParams|)
                                                                              1)))
                                                                          #8#) . #33#)))
                                                                      (LETT
                                                                       |i|
                                                                       (QSADD1
                                                                        |i|) . #33#)
                                                                      #35#
                                                                      G191
                                                                      (EXIT
                                                                       (NREVERSE0
                                                                        #8#)))) . #33#))))
                                                              ('T
                                                               (SEQ
                                                                (LETT
                                                                 |newGuessDegree|
                                                                 (-
                                                                  |listDegree|
                                                                  (SPADCALL
                                                                   |degreeS|
                                                                   (+
                                                                    |o|
                                                                    1)
                                                                   (QREFELT
                                                                    $
                                                                    438))) . #33#)
                                                                (EXIT
                                                                 (COND
                                                                   ((<
                                                                     |newGuessDegree|
                                                                     0)
                                                                    (COND
                                                                      ((SPADCALL
                                                                        (SPADCALL
                                                                         |options|
                                                                         (QREFELT
                                                                          $
                                                                          123))
                                                                        -1
                                                                        (QREFELT
                                                                         $
                                                                         440))
                                                                       (COND
                                                                         ((<
                                                                           (SPADCALL
                                                                            |options|
                                                                            (QREFELT
                                                                             $
                                                                             123))
                                                                           (QCAR
                                                                            |maxParams|))
                                                                          (SEQ
                                                                           (LETT
                                                                            |guessDegree|
                                                                            (-
                                                                             (SPADCALL
                                                                              |o|
                                                                              (+
                                                                               1
                                                                               (SPADCALL
                                                                                |options|
                                                                                (QREFELT
                                                                                 $
                                                                                 123)))
                                                                              (QREFELT
                                                                               $
                                                                               318))
                                                                             2) . #33#)
                                                                           (EXIT
                                                                            (LETT
                                                                             |eta|
                                                                             (PROGN
                                                                               (LETT
                                                                                #9#
                                                                                NIL . #33#)
                                                                               (SEQ
                                                                                (LETT
                                                                                 |i|
                                                                                 1 . #33#)
                                                                                G190
                                                                                (COND
                                                                                  ((QSGREATERP
                                                                                    |i|
                                                                                    |o|)
                                                                                   #34#))
                                                                                (SEQ
                                                                                 (EXIT
                                                                                  (LETT
                                                                                   #9#
                                                                                   (CONS
                                                                                    (PROG1
                                                                                     (LETT
                                                                                      #10#
                                                                                      (COND
                                                                                        ((<
                                                                                          |i|
                                                                                          |o|)
                                                                                         (+
                                                                                          (SPADCALL
                                                                                           |options|
                                                                                           (QREFELT
                                                                                            $
                                                                                            123))
                                                                                          1))
                                                                                        ('T
                                                                                         (SPADCALL
                                                                                          |options|
                                                                                          (QREFELT
                                                                                           $
                                                                                           123)))) . #33#)
                                                                                      (|check-subtype|
                                                                                       (>=
                                                                                        #10#
                                                                                        0)
                                                                                       '(|NonNegativeInteger|)
                                                                                       #10#))
                                                                                    #9#) . #33#)))
                                                                                (LETT
                                                                                 |i|
                                                                                 (QSADD1
                                                                                  |i|) . #33#)
                                                                                #35#
                                                                                G191
                                                                                (EXIT
                                                                                 (NREVERSE0
                                                                                  #9#)))) . #33#))))
                                                                         ('T
                                                                          (LETT
                                                                           |eta|
                                                                           (PROGN
                                                                             (LETT
                                                                              #11#
                                                                              NIL . #33#)
                                                                             (SEQ
                                                                              (LETT
                                                                               |i|
                                                                               1 . #33#)
                                                                              G190
                                                                              (COND
                                                                                ((QSGREATERP
                                                                                  |i|
                                                                                  |o|)
                                                                                 #34#))
                                                                              (SEQ
                                                                               (EXIT
                                                                                (LETT
                                                                                 #11#
                                                                                 (CONS
                                                                                  (COND
                                                                                    ((<
                                                                                      (QCDR
                                                                                       |maxParams|)
                                                                                      |i|)
                                                                                     (QCAR
                                                                                      |maxParams|))
                                                                                    ('T
                                                                                     (+
                                                                                      (QCAR
                                                                                       |maxParams|)
                                                                                      1)))
                                                                                  #11#) . #33#)))
                                                                              (LETT
                                                                               |i|
                                                                               (QSADD1
                                                                                |i|) . #33#)
                                                                              #35#
                                                                              G191
                                                                              (EXIT
                                                                               (NREVERSE0
                                                                                #11#)))) . #33#))))
                                                                      ('T
                                                                       (LETT
                                                                        |eta|
                                                                        (PROGN
                                                                          (LETT
                                                                           #12#
                                                                           NIL . #33#)
                                                                          (SEQ
                                                                           (LETT
                                                                            |i|
                                                                            1 . #33#)
                                                                           G190
                                                                           (COND
                                                                             ((QSGREATERP
                                                                               |i|
                                                                               |o|)
                                                                              #34#))
                                                                           (SEQ
                                                                            (EXIT
                                                                             (LETT
                                                                              #12#
                                                                              (CONS
                                                                               (COND
                                                                                 ((<
                                                                                   (QCDR
                                                                                    |maxParams|)
                                                                                   |i|)
                                                                                  (QCAR
                                                                                   |maxParams|))
                                                                                 ('T
                                                                                  (+
                                                                                   (QCAR
                                                                                    |maxParams|)
                                                                                   1)))
                                                                               #12#) . #33#)))
                                                                           (LETT
                                                                            |i|
                                                                            (QSADD1
                                                                             |i|) . #33#)
                                                                           #35#
                                                                           G191
                                                                           (EXIT
                                                                            (NREVERSE0
                                                                             #12#)))) . #33#))))
                                                                   ((EQL
                                                                     (QCAR
                                                                      (LETT
                                                                       |newMaxParams|
                                                                       (DIVIDE2
                                                                        (+
                                                                         (PROG1
                                                                          (LETT
                                                                           #13#
                                                                           |newGuessDegree| . #33#)
                                                                           (|check-subtype|
                                                                            (>=
                                                                             #13#
                                                                             0)
                                                                            '(|NonNegativeInteger|)
                                                                            #13#))
                                                                         1)
                                                                        (+
                                                                         |o|
                                                                         1)) . #33#))
                                                                     0)
                                                                    (COND
                                                                      ((<
                                                                        (QCDR
                                                                         |newMaxParams|)
                                                                        |o|)
                                                                       (COND
                                                                         ((SPADCALL
                                                                           (SPADCALL
                                                                            |options|
                                                                            (QREFELT
                                                                             $
                                                                             123))
                                                                           -1
                                                                           (QREFELT
                                                                            $
                                                                            440))
                                                                          (COND
                                                                            ((<
                                                                              (SPADCALL
                                                                               |options|
                                                                               (QREFELT
                                                                                $
                                                                                123))
                                                                              (QCAR
                                                                               |maxParams|))
                                                                             (SEQ
                                                                              (LETT
                                                                               |guessDegree|
                                                                               (-
                                                                                (SPADCALL
                                                                                 |o|
                                                                                 (+
                                                                                  1
                                                                                  (SPADCALL
                                                                                   |options|
                                                                                   (QREFELT
                                                                                    $
                                                                                    123)))
                                                                                 (QREFELT
                                                                                  $
                                                                                  318))
                                                                                2) . #33#)
                                                                              (EXIT
                                                                               (LETT
                                                                                |eta|
                                                                                (PROGN
                                                                                  (LETT
                                                                                   #14#
                                                                                   NIL . #33#)
                                                                                  (SEQ
                                                                                   (LETT
                                                                                    |i|
                                                                                    1 . #33#)
                                                                                   G190
                                                                                   (COND
                                                                                     ((QSGREATERP
                                                                                       |i|
                                                                                       |o|)
                                                                                      #34#))
                                                                                   (SEQ
                                                                                    (EXIT
                                                                                     (LETT
                                                                                      #14#
                                                                                      (CONS
                                                                                       (PROG1
                                                                                        (LETT
                                                                                         #15#
                                                                                         (COND
                                                                                           ((<
                                                                                             |i|
                                                                                             |o|)
                                                                                            (+
                                                                                             (SPADCALL
                                                                                              |options|
                                                                                              (QREFELT
                                                                                               $
                                                                                               123))
                                                                                             1))
                                                                                           ('T
                                                                                            (SPADCALL
                                                                                             |options|
                                                                                             (QREFELT
                                                                                              $
                                                                                              123)))) . #33#)
                                                                                         (|check-subtype|
                                                                                          (>=
                                                                                           #15#
                                                                                           0)
                                                                                          '(|NonNegativeInteger|)
                                                                                          #15#))
                                                                                       #14#) . #33#)))
                                                                                   (LETT
                                                                                    |i|
                                                                                    (QSADD1
                                                                                     |i|) . #33#)
                                                                                   #35#
                                                                                   G191
                                                                                   (EXIT
                                                                                    (NREVERSE0
                                                                                     #14#)))) . #33#))))
                                                                            ('T
                                                                             (LETT
                                                                              |eta|
                                                                              (PROGN
                                                                                (LETT
                                                                                 #16#
                                                                                 NIL . #33#)
                                                                                (SEQ
                                                                                 (LETT
                                                                                  |i|
                                                                                  1 . #33#)
                                                                                 G190
                                                                                 (COND
                                                                                   ((QSGREATERP
                                                                                     |i|
                                                                                     |o|)
                                                                                    #34#))
                                                                                 (SEQ
                                                                                  (EXIT
                                                                                   (LETT
                                                                                    #16#
                                                                                    (CONS
                                                                                     (COND
                                                                                       ((<
                                                                                         (QCDR
                                                                                          |maxParams|)
                                                                                         |i|)
                                                                                        (QCAR
                                                                                         |maxParams|))
                                                                                       ('T
                                                                                        (+
                                                                                         (QCAR
                                                                                          |maxParams|)
                                                                                         1)))
                                                                                     #16#) . #33#)))
                                                                                 (LETT
                                                                                  |i|
                                                                                  (QSADD1
                                                                                   |i|) . #33#)
                                                                                 #35#
                                                                                 G191
                                                                                 (EXIT
                                                                                  (NREVERSE0
                                                                                   #16#)))) . #33#))))
                                                                         ('T
                                                                          (LETT
                                                                           |eta|
                                                                           (PROGN
                                                                             (LETT
                                                                              #17#
                                                                              NIL . #33#)
                                                                             (SEQ
                                                                              (LETT
                                                                               |i|
                                                                               1 . #33#)
                                                                              G190
                                                                              (COND
                                                                                ((QSGREATERP
                                                                                  |i|
                                                                                  |o|)
                                                                                 #34#))
                                                                              (SEQ
                                                                               (EXIT
                                                                                (LETT
                                                                                 #17#
                                                                                 (CONS
                                                                                  (COND
                                                                                    ((<
                                                                                      (QCDR
                                                                                       |maxParams|)
                                                                                      |i|)
                                                                                     (QCAR
                                                                                      |maxParams|))
                                                                                    ('T
                                                                                     (+
                                                                                      (QCAR
                                                                                       |maxParams|)
                                                                                      1)))
                                                                                  #17#) . #33#)))
                                                                              (LETT
                                                                               |i|
                                                                               (QSADD1
                                                                                |i|) . #33#)
                                                                              #35#
                                                                              G191
                                                                              (EXIT
                                                                               (NREVERSE0
                                                                                #17#)))) . #33#))))
                                                                      ('T
                                                                       (LETT
                                                                        |iterate?|
                                                                        'T . #33#))))
                                                                   ('T
                                                                    (LETT
                                                                     |iterate?|
                                                                     'T . #33#))))))))
                                                           ((SPADCALL
                                                             (SPADCALL
                                                              |options|
                                                              (QREFELT
                                                               $ 123))
                                                             -1
                                                             (QREFELT $
                                                              440))
                                                            (COND
                                                              ((<
                                                                (SPADCALL
                                                                 |options|
                                                                 (QREFELT
                                                                  $
                                                                  123))
                                                                (QCAR
                                                                 |maxParams|))
                                                               (SEQ
                                                                (LETT
                                                                 |guessDegree|
                                                                 (-
                                                                  (SPADCALL
                                                                   |o|
                                                                   (+ 1
                                                                    (SPADCALL
                                                                     |options|
                                                                     (QREFELT
                                                                      $
                                                                      123)))
                                                                   (QREFELT
                                                                    $
                                                                    318))
                                                                  2) . #33#)
                                                                (EXIT
                                                                 (LETT
                                                                  |eta|
                                                                  (PROGN
                                                                    (LETT
                                                                     #18#
                                                                     NIL . #33#)
                                                                    (SEQ
                                                                     (LETT
                                                                      |i|
                                                                      1 . #33#)
                                                                     G190
                                                                     (COND
                                                                       ((QSGREATERP
                                                                         |i|
                                                                         |o|)
                                                                        #34#))
                                                                     (SEQ
                                                                      (EXIT
                                                                       (LETT
                                                                        #18#
                                                                        (CONS
                                                                         (PROG1
                                                                          (LETT
                                                                           #19#
                                                                           (COND
                                                                             ((<
                                                                               |i|
                                                                               |o|)
                                                                              (+
                                                                               (SPADCALL
                                                                                |options|
                                                                                (QREFELT
                                                                                 $
                                                                                 123))
                                                                               1))
                                                                             ('T
                                                                              (SPADCALL
                                                                               |options|
                                                                               (QREFELT
                                                                                $
                                                                                123)))) . #33#)
                                                                           (|check-subtype|
                                                                            (>=
                                                                             #19#
                                                                             0)
                                                                            '(|NonNegativeInteger|)
                                                                            #19#))
                                                                         #18#) . #33#)))
                                                                     (LETT
                                                                      |i|
                                                                      (QSADD1
                                                                       |i|) . #33#)
                                                                     #35#
                                                                     G191
                                                                     (EXIT
                                                                      (NREVERSE0
                                                                       #18#)))) . #33#))))
                                                              ('T
                                                               (LETT
                                                                |eta|
                                                                (PROGN
                                                                  (LETT
                                                                   #20#
                                                                   NIL . #33#)
                                                                  (SEQ
                                                                   (LETT
                                                                    |i|
                                                                    1 . #33#)
                                                                   G190
                                                                   (COND
                                                                     ((QSGREATERP
                                                                       |i|
                                                                       |o|)
                                                                      #34#))
                                                                   (SEQ
                                                                    (EXIT
                                                                     (LETT
                                                                      #20#
                                                                      (CONS
                                                                       (COND
                                                                         ((<
                                                                           (QCDR
                                                                            |maxParams|)
                                                                           |i|)
                                                                          (QCAR
                                                                           |maxParams|))
                                                                         ('T
                                                                          (+
                                                                           (QCAR
                                                                            |maxParams|)
                                                                           1)))
                                                                       #20#) . #33#)))
                                                                   (LETT
                                                                    |i|
                                                                    (QSADD1
                                                                     |i|) . #33#)
                                                                   #35#
                                                                   G191
                                                                   (EXIT
                                                                    (NREVERSE0
                                                                     #20#)))) . #33#))))
                                                           ('T
                                                            (LETT |eta|
                                                             (PROGN
                                                               (LETT
                                                                #21#
                                                                NIL . #33#)
                                                               (SEQ
                                                                (LETT
                                                                 |i|
                                                                 1 . #33#)
                                                                G190
                                                                (COND
                                                                  ((QSGREATERP
                                                                    |i|
                                                                    |o|)
                                                                   #34#))
                                                                (SEQ
                                                                 (EXIT
                                                                  (LETT
                                                                   #21#
                                                                   (CONS
                                                                    (COND
                                                                      ((<
                                                                        (QCDR
                                                                         |maxParams|)
                                                                        |i|)
                                                                       (QCAR
                                                                        |maxParams|))
                                                                      ('T
                                                                       (+
                                                                        (QCAR
                                                                         |maxParams|)
                                                                        1)))
                                                                    #21#) . #33#)))
                                                                (LETT
                                                                 |i|
                                                                 (QSADD1
                                                                  |i|) . #33#)
                                                                #35#
                                                                G191
                                                                (EXIT
                                                                 (NREVERSE0
                                                                  #21#)))) . #33#))))
                                                        ((SPADCALL
                                                          (SPADCALL
                                                           |options|
                                                           (QREFELT $
                                                            123))
                                                          -1
                                                          (QREFELT $
                                                           440))
                                                         (COND
                                                           ((<
                                                             (SPADCALL
                                                              |options|
                                                              (QREFELT
                                                               $ 123))
                                                             (QCAR
                                                              |maxParams|))
                                                            (SEQ
                                                             (LETT
                                                              |guessDegree|
                                                              (-
                                                               (SPADCALL
                                                                |o|
                                                                (+ 1
                                                                 (SPADCALL
                                                                  |options|
                                                                  (QREFELT
                                                                   $
                                                                   123)))
                                                                (QREFELT
                                                                 $ 318))
                                                               2) . #33#)
                                                             (EXIT
                                                              (LETT
                                                               |eta|
                                                               (PROGN
                                                                 (LETT
                                                                  #22#
                                                                  NIL . #33#)
                                                                 (SEQ
                                                                  (LETT
                                                                   |i|
                                                                   1 . #33#)
                                                                  G190
                                                                  (COND
                                                                    ((QSGREATERP
                                                                      |i|
                                                                      |o|)
                                                                     #34#))
                                                                  (SEQ
                                                                   (EXIT
                                                                    (LETT
                                                                     #22#
                                                                     (CONS
                                                                      (PROG1
                                                                       (LETT
                                                                        #23#
                                                                        (COND
                                                                          ((<
                                                                            |i|
                                                                            |o|)
                                                                           (+
                                                                            (SPADCALL
                                                                             |options|
                                                                             (QREFELT
                                                                              $
                                                                              123))
                                                                            1))
                                                                          ('T
                                                                           (SPADCALL
                                                                            |options|
                                                                            (QREFELT
                                                                             $
                                                                             123)))) . #33#)
                                                                        (|check-subtype|
                                                                         (>=
                                                                          #23#
                                                                          0)
                                                                         '(|NonNegativeInteger|)
                                                                         #23#))
                                                                      #22#) . #33#)))
                                                                  (LETT
                                                                   |i|
                                                                   (QSADD1
                                                                    |i|) . #33#)
                                                                  #35#
                                                                  G191
                                                                  (EXIT
                                                                   (NREVERSE0
                                                                    #22#)))) . #33#))))
                                                           ('T
                                                            (LETT |eta|
                                                             (PROGN
                                                               (LETT
                                                                #24#
                                                                NIL . #33#)
                                                               (SEQ
                                                                (LETT
                                                                 |i|
                                                                 1 . #33#)
                                                                G190
                                                                (COND
                                                                  ((QSGREATERP
                                                                    |i|
                                                                    |o|)
                                                                   #34#))
                                                                (SEQ
                                                                 (EXIT
                                                                  (LETT
                                                                   #24#
                                                                   (CONS
                                                                    (COND
                                                                      ((<
                                                                        (QCDR
                                                                         |maxParams|)
                                                                        |i|)
                                                                       (QCAR
                                                                        |maxParams|))
                                                                      ('T
                                                                       (+
                                                                        (QCAR
                                                                         |maxParams|)
                                                                        1)))
                                                                    #24#) . #33#)))
                                                                (LETT
                                                                 |i|
                                                                 (QSADD1
                                                                  |i|) . #33#)
                                                                #35#
                                                                G191
                                                                (EXIT
                                                                 (NREVERSE0
                                                                  #24#)))) . #33#))))
                                                        ('T
                                                         (LETT |eta|
                                                          (PROGN
                                                            (LETT #25#
                                                             NIL . #33#)
                                                            (SEQ
                                                             (LETT |i|
                                                              1 . #33#)
                                                             G190
                                                             (COND
                                                               ((QSGREATERP
                                                                 |i|
                                                                 |o|)
                                                                #34#))
                                                             (SEQ
                                                              (EXIT
                                                               (LETT
                                                                #25#
                                                                (CONS
                                                                 (COND
                                                                   ((<
                                                                     (QCDR
                                                                      |maxParams|)
                                                                     |i|)
                                                                    (QCAR
                                                                     |maxParams|))
                                                                   ('T
                                                                    (+
                                                                     (QCAR
                                                                      |maxParams|)
                                                                     1)))
                                                                 #25#) . #33#)))
                                                             (LETT |i|
                                                              (QSADD1
                                                               |i|) . #33#)
                                                             #35# G191
                                                             (EXIT
                                                              (NREVERSE0
                                                               #25#)))) . #33#)))))))
                                                 (EXIT
                                                  (COND
                                                    (|iterate?|
                                                     (SEQ
                                                      (LETT |iterate?|
                                                       'NIL . #33#)
                                                      (EXIT
                                                       (COND
                                                         ((SPADCALL
                                                           |options|
                                                           (QREFELT $
                                                            124))
                                                          (SPADCALL
                                                           "iterating"
                                                           (QREFELT $
                                                            146)))))))
                                                    ('T
                                                     (SEQ
                                                      (LETT |guessList|
                                                       (|GUESS;getListSUPF|
                                                        |guessS| |o|
                                                        (PROG1
                                                         (LETT #26#
                                                          |guessDegree| . #33#)
                                                          (|check-subtype|
                                                           (>= #26# 0)
                                                           '(|NonNegativeInteger|)
                                                           #26#))
                                                        $) . #33#)
                                                      (LETT |testList|
                                                       (SPADCALL
                                                        (SPADCALL
                                                         (SPADCALL
                                                          |testS| |o|
                                                          (QREFELT $
                                                           441))
                                                         (QREFELT $
                                                          442))
                                                        (QREFELT $ 443)) . #33#)
                                                      (LETT |exprList|
                                                       (SPADCALL
                                                        (SPADCALL
                                                         (SPADCALL
                                                          |exprS| |o|
                                                          (QREFELT $
                                                           444))
                                                         (QREFELT $
                                                          445))
                                                        (QREFELT $ 446)) . #33#)
                                                      (COND
                                                        ((SPADCALL
                                                          |options|
                                                          (QREFELT $
                                                           124))
                                                         (SEQ
                                                          (SPADCALL
                                                           "The list of expressions is"
                                                           (QREFELT $
                                                            146))
                                                          (EXIT
                                                           (SPADCALL
                                                            (SPADCALL
                                                             |exprList|
                                                             (QREFELT $
                                                              447))
                                                            (QREFELT $
                                                             130))))))
                                                      (EXIT
                                                       (COND
                                                         ((SPADCALL
                                                           |options|
                                                           (QREFELT $
                                                            394))
                                                          (SEQ
                                                           (LETT MS
                                                            (|GUESS;guessInterpolate2|
                                                             |guessList|
                                                             (+
                                                              (PROG1
                                                               (LETT
                                                                #27#
                                                                |guessDegree| . #33#)
                                                                (|check-subtype|
                                                                 (>=
                                                                  #27#
                                                                  0)
                                                                 '(|NonNegativeInteger|)
                                                                 #27#))
                                                              1)
                                                             (PROG1
                                                              (LETT
                                                               #28#
                                                               |maxEta| . #33#)
                                                               (|check-subtype|
                                                                (>=
                                                                 #28#
                                                                 0)
                                                                '(|NonNegativeInteger|)
                                                                #28#))
                                                             D $) . #33#)
                                                           (EXIT
                                                            (SEQ
                                                             (EXIT
                                                              (SEQ G190
                                                               NIL
                                                               (SEQ
                                                                (EXIT
                                                                 (COND
                                                                   ((SPADCALL
                                                                     MS
                                                                     (QREFELT
                                                                      $
                                                                      448))
                                                                    (PROGN
                                                                      (LETT
                                                                       #29#
                                                                       |$NoValue| . #33#)
                                                                      (GO
                                                                       #29#)))
                                                                   ('T
                                                                    (SEQ
                                                                     (LETT
                                                                      M
                                                                      (SPADCALL
                                                                       MS
                                                                       (QREFELT
                                                                        $
                                                                        449)) . #33#)
                                                                     (SEQ
                                                                      (LETT
                                                                       |i|
                                                                       1 . #33#)
                                                                      G190
                                                                      (COND
                                                                        ((QSGREATERP
                                                                          |i|
                                                                          |o|)
                                                                         #34#))
                                                                      (SEQ
                                                                       (LETT
                                                                        |res|
                                                                        (|GUESS;testInterpolant|
                                                                         (SPADCALL
                                                                          (SPADCALL
                                                                           M
                                                                           |i|
                                                                           (QREFELT
                                                                            $
                                                                            450))
                                                                          (QREFELT
                                                                           $
                                                                           451))
                                                                         |list|
                                                                         |testList|
                                                                         |exprList|
                                                                         |initials|
                                                                         (PROG1
                                                                          (LETT
                                                                           #30#
                                                                           |guessDegree| . #33#)
                                                                           (|check-subtype|
                                                                            (>=
                                                                             #30#
                                                                             0)
                                                                            '(|NonNegativeInteger|)
                                                                            #30#))
                                                                         D
                                                                         |dummy|
                                                                         |op|
                                                                         |options|
                                                                         $) . #33#)
                                                                       (EXIT
                                                                        (COND
                                                                          ((QEQCAR
                                                                            |res|
                                                                            0)
                                                                           "iterate")
                                                                          ('T
                                                                           (SEQ
                                                                            (COND
                                                                              ((NULL
                                                                                (SPADCALL
                                                                                 (QCDR
                                                                                  |res|)
                                                                                 |reslist|
                                                                                 (QREFELT
                                                                                  $
                                                                                  452)))
                                                                               (LETT
                                                                                |reslist|
                                                                                (CONS
                                                                                 (QCDR
                                                                                  |res|)
                                                                                 |reslist|) . #33#)))
                                                                            (EXIT
                                                                             (COND
                                                                               ((SPADCALL
                                                                                 |options|
                                                                                 (QREFELT
                                                                                  $
                                                                                  173))
                                                                                (PROGN
                                                                                  (LETT
                                                                                   #32#
                                                                                   |reslist| . #33#)
                                                                                  (GO
                                                                                   #32#))))))))))
                                                                      (LETT
                                                                       |i|
                                                                       (QSADD1
                                                                        |i|) . #33#)
                                                                      #35#
                                                                      G191
                                                                      (EXIT
                                                                       NIL))
                                                                     (EXIT
                                                                      (LETT
                                                                       MS
                                                                       (SPADCALL
                                                                        MS
                                                                        (QREFELT
                                                                         $
                                                                         453)) . #33#)))))))
                                                               NIL #35#
                                                               G191
                                                               (EXIT
                                                                NIL)))
                                                             #29#
                                                             (EXIT
                                                              #29#)))))
                                                         ('T
                                                          (SEQ
                                                           (LETT M
                                                            (|GUESS;guessInterpolate|
                                                             |guessList|
                                                             |eta| D $) . #33#)
                                                           (EXIT
                                                            (SEQ
                                                             (LETT |i|
                                                              1 . #33#)
                                                             G190
                                                             (COND
                                                               ((QSGREATERP
                                                                 |i|
                                                                 |o|)
                                                                #34#))
                                                             (SEQ
                                                              (LETT
                                                               |res|
                                                               (|GUESS;testInterpolant|
                                                                (SPADCALL
                                                                 (SPADCALL
                                                                  M |i|
                                                                  (QREFELT
                                                                   $
                                                                   450))
                                                                 (QREFELT
                                                                  $
                                                                  451))
                                                                |list|
                                                                |testList|
                                                                |exprList|
                                                                |initials|
                                                                (PROG1
                                                                 (LETT
                                                                  #31#
                                                                  |guessDegree| . #33#)
                                                                  (|check-subtype|
                                                                   (>=
                                                                    #31#
                                                                    0)
                                                                   '(|NonNegativeInteger|)
                                                                   #31#))
                                                                D
                                                                |dummy|
                                                                |op|
                                                                |options|
                                                                $) . #33#)
                                                              (EXIT
                                                               (COND
                                                                 ((QEQCAR
                                                                   |res|
                                                                   0)
                                                                  "iterate")
                                                                 ('T
                                                                  (SEQ
                                                                   (COND
                                                                     ((NULL
                                                                       (SPADCALL
                                                                        (QCDR
                                                                         |res|)
                                                                        |reslist|
                                                                        (QREFELT
                                                                         $
                                                                         452)))
                                                                      (LETT
                                                                       |reslist|
                                                                       (CONS
                                                                        (QCDR
                                                                         |res|)
                                                                        |reslist|) . #33#)))
                                                                   (EXIT
                                                                    (COND
                                                                      ((SPADCALL
                                                                        |options|
                                                                        (QREFELT
                                                                         $
                                                                         173))
                                                                       (PROGN
                                                                         (LETT
                                                                          #32#
                                                                          |reslist| . #33#)
                                                                         (GO
                                                                          #32#))))))))))
                                                             (LETT |i|
                                                              (QSADD1
                                                               |i|) . #33#)
                                                             #35# G191
                                                             (EXIT NIL))))))))))))))))))))
                                      (LETT |o| (QSADD1 |o|) . #33#)
                                      #35# G191 (EXIT NIL)))
                           #3# (EXIT #3#))
                      (EXIT |reslist|)))
           #32# (EXIT #32#))))) 

(DEFUN |GUESS;guessHP;MM;87| (D $)
  (CONS #'|GUESS;guessHP;MM;87!0| (VECTOR $ D))) 

(DEFUN |GUESS;guessHP;MM;87!0| (|#1| |#2| $$)
  (|GUESS;guessHPaux| |#1| (SPADCALL |#2| (QREFELT $$ 1)) |#2|
      (QREFELT $$ 0))) 

(DEFUN |GUESS;guessADE;LLL;88| (|list| |options| $)
  (PROG (|opts|)
    (RETURN
      (SEQ (LETT |opts| (CONS (SPADCALL 'T (QREFELT $ 456)) |options|)
                 |GUESS;guessADE;LLL;88|)
           (EXIT (|GUESS;guessHPaux| |list|
                     (SPADCALL |opts| (QREFELT $ 317)) |opts| $)))))) 

(DEFUN |GUESS;guessADE;LL;89| (|list| $)
  (SPADCALL |list| NIL (QREFELT $ 457))) 

(DEFUN |GUESS;guessAlg;LLL;90| (|list| |options| $)
  (SPADCALL |list| (CONS (SPADCALL 0 (QREFELT $ 459)) |options|)
      (QREFELT $ 457))) 

(DEFUN |GUESS;guessAlg;LL;91| (|list| $)
  (SPADCALL |list| NIL (QREFELT $ 460))) 

(DEFUN |GUESS;guessHolo;LLL;92| (|list| |options| $)
  (SPADCALL |list| (CONS (SPADCALL 1 (QREFELT $ 462)) |options|)
      (QREFELT $ 457))) 

(DEFUN |GUESS;guessHolo;LL;93| (|list| $)
  (SPADCALL |list| NIL (QREFELT $ 463))) 

(DEFUN |GUESS;guessPade;LLL;94| (|list| |options| $)
  (PROG (|opts|)
    (RETURN
      (SEQ (LETT |opts|
                 (APPEND |options|
                         (LIST (SPADCALL 0 (QREFELT $ 459))
                               (SPADCALL 1 (QREFELT $ 462))
                               (SPADCALL 'T (QREFELT $ 465))))
                 |GUESS;guessPade;LLL;94|)
           (EXIT (SPADCALL |list| |opts| (QREFELT $ 457))))))) 

(DEFUN |GUESS;guessPade;LL;95| (|list| $)
  (SPADCALL |list| NIL (QREFELT $ 466))) 

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

(DEFUN |GUESS;guessADE;SM;96!0| (|#1| |#2| $$)
  (PROG ($)
    (LETT $ (QREFELT $$ 1) |GUESS;guessADE;SM;96|)
    (RETURN
      (PROGN
        (PROG (|opts|)
          (RETURN
            (SEQ (LETT |opts|
                       (SPADCALL
                           (SPADCALL (|spadConstant| $ 270)
                               (QREFELT $ 456))
                           |#2| (QREFELT $ 468))
                       NIL)
                 (EXIT (|GUESS;guessHPaux| |#1|
                           (SPADCALL |opts|
                               (SPADCALL (QREFELT $$ 0)
                                   (QREFELT $ 327)))
                           |opts| $))))))))) 

(DEFUN |GUESS;guessRec;LLL;97| (|list| |options| $)
  (PROG (|opts|)
    (RETURN
      (SEQ (LETT |opts|
                 (CONS (SPADCALL 'NIL (QREFELT $ 456)) |options|)
                 |GUESS;guessRec;LLL;97|)
           (EXIT (|GUESS;guessHPaux| |list|
                     (SPADCALL |opts| (QREFELT $ 351)) |opts| $)))))) 

(DEFUN |GUESS;guessRec;LL;98| (|list| $)
  (SPADCALL |list| NIL (QREFELT $ 470))) 

(DEFUN |GUESS;guessPRec;LLL;99| (|list| |options| $)
  (SPADCALL |list| (CONS (SPADCALL 1 (QREFELT $ 462)) |options|)
      (QREFELT $ 470))) 

(DEFUN |GUESS;guessPRec;LL;100| (|list| $)
  (SPADCALL |list| NIL (QREFELT $ 472))) 

(DEFUN |GUESS;guessRat;LLL;101| (|list| |options| $)
  (PROG (|opts|)
    (RETURN
      (SEQ (LETT |opts|
                 (APPEND |options|
                         (LIST (SPADCALL 0 (QREFELT $ 474))
                               (SPADCALL 1 (QREFELT $ 462))
                               (SPADCALL 'T (QREFELT $ 465))))
                 |GUESS;guessRat;LLL;101|)
           (EXIT (SPADCALL |list| |opts| (QREFELT $ 470))))))) 

(DEFUN |GUESS;guessRat;LL;102| (|list| $)
  (SPADCALL |list| NIL (QREFELT $ 475))) 

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

(DEFUN |GUESS;guessRec;SM;103!0| (|#1| |#2| $$)
  (PROG ($)
    (LETT $ (QREFELT $$ 1) |GUESS;guessRec;SM;103|)
    (RETURN
      (PROGN
        (PROG (|opts|)
          (RETURN
            (SEQ (LETT |opts|
                       (SPADCALL
                           (SPADCALL (|spadConstant| $ 272)
                               (QREFELT $ 456))
                           |#2| (QREFELT $ 468))
                       NIL)
                 (EXIT (|GUESS;guessHPaux| |#1|
                           (SPADCALL |opts|
                               (SPADCALL (QREFELT $$ 0)
                                   (QREFELT $ 357)))
                           |opts| $))))))))) 

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

(DEFUN |GUESS;guessPRec;SM;104!0| (|#1| |#2| $$)
  (PROG ($)
    (LETT $ (QREFELT $$ 1) |GUESS;guessPRec;SM;104|)
    (RETURN
      (PROGN
        (PROG (|opts|)
          (RETURN
            (SEQ (LETT |opts|
                       (SPADCALL (LIST (SPADCALL (|spadConstant| $ 272)
                                        (QREFELT $ 456))
                                       (SPADCALL (|spadConstant| $ 269)
                                        (QREFELT $ 462)))
                                 |#2| (QREFELT $ 478))
                       NIL)
                 (EXIT (|GUESS;guessHPaux| |#1|
                           (SPADCALL |opts|
                               (SPADCALL (QREFELT $$ 0)
                                   (QREFELT $ 357)))
                           |opts| $))))))))) 

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

(DEFUN |GUESS;guessRat;SM;105!0| (|#1| |#2| $$)
  (PROG ($)
    (LETT $ (QREFELT $$ 1) |GUESS;guessRat;SM;105|)
    (RETURN
      (PROGN
        (PROG (|opts|)
          (RETURN
            (SEQ (LETT |opts|
                       (SPADCALL |#2|
                                 (LIST (SPADCALL (|spadConstant| $ 272)
                                        (QREFELT $ 456))
                                       (SPADCALL (|spadConstant| $ 267)
                                        (QREFELT $ 474))
                                       (SPADCALL (|spadConstant| $ 269)
                                        (QREFELT $ 462))
                                       (SPADCALL (|spadConstant| $ 270)
                                        (QREFELT $ 465)))
                                 (QREFELT $ 478))
                       NIL)
                 (EXIT (|GUESS;guessHPaux| |#1|
                           (SPADCALL |opts|
                               (SPADCALL (QREFELT $$ 0)
                                   (QREFELT $ 357)))
                           |opts| $))))))))) 

(DEFUN |GUESS;guess;LLLLL;106| (|list| |guessers| |ops| |options| $)
  (PROG (|maxLevel| |xx| #0=#:G56317 |len| |guesser| #1=#:G56346
            #2=#:G56347 #3=#:G56348 |prodList| #4=#:G56349 #5=#:G56350
            |prodGuess| #6=#:G56351 #7=#:G56345 #8=#:G56352 |i|
            #9=#:G56353 |sumList| |var| #10=#:G56354 #11=#:G56355
            |sumGuess| |guess| #12=#:G56356 |res|)
    (RETURN
      (SEQ (EXIT (SEQ (LETT |maxLevel|
                            (SPADCALL |options| (QREFELT $ 481))
                            . #13=(|GUESS;guess;LLLLL;106|))
                      (LETT |xx|
                            (SPADCALL |options| (QREFELT $ 175)) . #13#)
                      (COND
                        ((SPADCALL |options| (QREFELT $ 124))
                         (SEQ (SPADCALL
                                  (SPADCALL "guessing level "
                                      (SPADCALL |maxLevel|
                                       (QREFELT $ 439))
                                      (QREFELT $ 127))
                                  (QREFELT $ 130))
                              (EXIT (SPADCALL
                                     (SPADCALL "guessing "
                                      (SPADCALL |list| (QREFELT $ 482))
                                      (QREFELT $ 127))
                                     (QREFELT $ 130))))))
                      (LETT |res| NIL . #13#)
                      (LETT |len|
                            (PROG1 (LETT #0# (LENGTH |list|) . #13#)
                              (|check-subtype| (> #0# 0)
                                  '(|PositiveInteger|) #0#)) . #13#)
                      (COND
                        ((NULL (< 1 |len|))
                         (PROGN (LETT #7# |res| . #13#) (GO #7#))))
                      (SEQ (LETT |guesser| NIL . #13#)
                           (LETT #1# |guessers| . #13#) G190
                           (COND
                             ((OR (ATOM #1#)
                                  (PROGN
                                    (LETT |guesser| (CAR #1#) . #13#)
                                    NIL))
                              #14=(GO G191)))
                           (SEQ (LETT |res|
                                      (APPEND
                                       (SPADCALL |list| |options|
                                        |guesser|)
                                       |res|) . #13#)
                                (COND
                                  ((SPADCALL |options| (QREFELT $ 124))
                                   (SPADCALL
                                    (SPADCALL "res "
                                     (SPADCALL |res| (QREFELT $ 483))
                                     (QREFELT $ 127))
                                    (QREFELT $ 130))))
                                (EXIT (COND
                                        ((SPADCALL |options|
                                          (QREFELT $ 173))
                                         (COND
                                           ((NULL (NULL |res|))
                                            (PROGN
                                              (LETT #7# |res| . #13#)
                                              (GO #7#))))))))
                           (LETT #1# (CDR #1#) . #13#) #15=(GO G190)
                           G191 (EXIT NIL))
                      (COND
                        ((EQL |maxLevel| 0)
                         (PROGN (LETT #7# |res| . #13#) (GO #7#))))
                      (COND
                        ((SPADCALL '|guessProduct| |ops|
                             (QREFELT $ 485))
                         (COND
                           ((NULL (SPADCALL (|spadConstant| $ 27)
                                      |list| (QREFELT $ 486)))
                            (SEQ (LETT |prodList|
                                       (PROGN
                                         (LETT #2# NIL . #13#)
                                         (SEQ (LETT |i| 1 . #13#)
                                          (LETT #3# (- |len| 1) . #13#)
                                          G190
                                          (COND
                                            ((QSGREATERP |i| #3#) #14#))
                                          (SEQ
                                           (EXIT
                                            (LETT #2#
                                             (CONS
                                              (SPADCALL
                                               (SPADCALL |list|
                                                (+ |i| 1)
                                                (QREFELT $ 34))
                                               (SPADCALL |list| |i|
                                                (QREFELT $ 34))
                                               (QREFELT $ 157))
                                              #2#) . #13#)))
                                          (LETT |i|
                                           (QSADD1 |i|) . #13#)
                                          #15# G191
                                          (EXIT (NREVERSE0 #2#)))) . #13#)
                                 (EXIT (COND
                                         ((NULL
                                           (SPADCALL (ELT $ 494)
                                            |prodList| (QREFELT $ 496)))
                                          (SEQ
                                           (LETT |var|
                                            (SPADCALL '|p|
                                             (LIST
                                              (SPADCALL |len|
                                               (QREFELT $ 497)))
                                             (QREFELT $ 499)) . #13#)
                                           (LETT |prodGuess|
                                            (PROGN
                                              (LETT #4# NIL . #13#)
                                              (SEQ
                                               (LETT |guess|
                                                NIL . #13#)
                                               (LETT #5#
                                                (SPADCALL |prodList|
                                                 |guessers| |ops|
                                                 (APPEND
                                                  (LIST
                                                   (SPADCALL |var|
                                                    (QREFELT $ 500))
                                                   (SPADCALL
                                                    (- |maxLevel| 1)
                                                    (QREFELT $ 501)))
                                                  |options|)
                                                 (QREFELT $ 503)) . #13#)
                                               G190
                                               (COND
                                                 ((OR (ATOM #5#)
                                                   (PROGN
                                                     (LETT |guess|
                                                      (CAR #5#) . #13#)
                                                     NIL))
                                                  #14#))
                                               (SEQ
                                                (EXIT
                                                 (LETT #4#
                                                  (CONS
                                                   (CONS
                                                    (SPADCALL
                                                     (SPADCALL
                                                      (SPADCALL |list|
                                                       (+
                                                        (QCDR |guess|)
                                                        1)
                                                       (QREFELT $ 34))
                                                      (QREFELT $ 11))
                                                     (SPADCALL
                                                      (QCAR |guess|)
                                                      (SPADCALL |var|
                                                       (SPADCALL
                                                        (SPADCALL
                                                         (QCDR |guess|)
                                                         (QREFELT $ 25))
                                                        (SPADCALL
                                                         (SPADCALL |xx|
                                                          (QREFELT $
                                                           24))
                                                         (|spadConstant|
                                                          $ 177)
                                                         (QREFELT $
                                                          116))
                                                        (QREFELT $ 213))
                                                       (QREFELT $ 215))
                                                      (QREFELT $ 217))
                                                     (QREFELT $ 60))
                                                    (QCDR |guess|))
                                                   #4#) . #13#)))
                                               (LETT #5#
                                                (CDR #5#) . #13#)
                                               #15# G191
                                               (EXIT (NREVERSE0 #4#)))) . #13#)
                                           (COND
                                             ((SPADCALL |options|
                                               (QREFELT $ 124))
                                              (SPADCALL
                                               (SPADCALL "prodGuess "
                                                (SPADCALL |prodGuess|
                                                 (QREFELT $ 483))
                                                (QREFELT $ 127))
                                               (QREFELT $ 130))))
                                           (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
                                                      (CONS
                                                       #'|GUESS;guess;LLLLL;106!0|
                                                       (VECTOR $
                                                        |guess|))
                                                      |res|
                                                      (QREFELT $ 504))
                                                     'NIL)
                                                    ('T 'T))
                                                  (LETT |res|
                                                   (CONS |guess| |res|) . #13#)))))
                                             (LETT #6#
                                              (CDR #6#) . #13#)
                                             #15# G191 (EXIT NIL))))))))))))
                      (COND
                        ((SPADCALL |options| (QREFELT $ 173))
                         (COND
                           ((NULL (NULL |res|))
                            (PROGN (LETT #7# |res| . #13#) (GO #7#))))))
                      (COND
                        ((SPADCALL '|guessSum| |ops| (QREFELT $ 485))
                         (SEQ (LETT |sumList|
                                    (PROGN
                                      (LETT #8# NIL . #13#)
                                      (SEQ (LETT |i| 1 . #13#)
                                       (LETT #9# (- |len| 1) . #13#)
                                       G190
                                       (COND
                                         ((QSGREATERP |i| #9#) #14#))
                                       (SEQ
                                        (EXIT
                                         (LETT #8#
                                          (CONS
                                           (SPADCALL
                                            (SPADCALL |list| (+ |i| 1)
                                             (QREFELT $ 34))
                                            (SPADCALL |list| |i|
                                             (QREFELT $ 34))
                                            (QREFELT $ 113))
                                           #8#) . #13#)))
                                       (LETT |i| (QSADD1 |i|) . #13#)
                                       #15# G191
                                       (EXIT (NREVERSE0 #8#)))) . #13#)
                              (EXIT (COND
                                      ((NULL
                                        (SPADCALL
                                         (CONS
                                          #'|GUESS;guess;LLLLL;106!1|
                                          (VECTOR $ |sumList|))
                                         |sumList| (QREFELT $ 496)))
                                       (SEQ
                                        (LETT |var|
                                         (SPADCALL '|s|
                                          (LIST
                                           (SPADCALL |len|
                                            (QREFELT $ 497)))
                                          (QREFELT $ 499)) . #13#)
                                        (LETT |sumGuess|
                                         (PROGN
                                           (LETT #10# NIL . #13#)
                                           (SEQ
                                            (LETT |guess| NIL . #13#)
                                            (LETT #11#
                                             (SPADCALL |sumList|
                                              |guessers| |ops|
                                              (APPEND
                                               (LIST
                                                (SPADCALL |var|
                                                 (QREFELT $ 500))
                                                (SPADCALL
                                                 (- |maxLevel| 1)
                                                 (QREFELT $ 501)))
                                               |options|)
                                              (QREFELT $ 503)) . #13#)
                                            G190
                                            (COND
                                              ((OR (ATOM #11#)
                                                (PROGN
                                                  (LETT |guess|
                                                   (CAR #11#) . #13#)
                                                  NIL))
                                               #14#))
                                            (SEQ
                                             (EXIT
                                              (LETT #10#
                                               (CONS
                                                (CONS
                                                 (SPADCALL
                                                  (SPADCALL
                                                   (SPADCALL |list|
                                                    (+ (QCDR |guess|)
                                                     1)
                                                    (QREFELT $ 34))
                                                   (QREFELT $ 11))
                                                  (SPADCALL
                                                   (QCAR |guess|)
                                                   (SPADCALL |var|
                                                    (SPADCALL
                                                     (SPADCALL
                                                      (QCDR |guess|)
                                                      (QREFELT $ 25))
                                                     (SPADCALL
                                                      (SPADCALL |xx|
                                                       (QREFELT $ 24))
                                                      (|spadConstant| $
                                                       177)
                                                      (QREFELT $ 116))
                                                     (QREFELT $ 213))
                                                    (QREFELT $ 215))
                                                   (QREFELT $ 506))
                                                  (QREFELT $ 62))
                                                 (QCDR |guess|))
                                                #10#) . #13#)))
                                            (LETT #11#
                                             (CDR #11#) . #13#)
                                            #15# G191
                                            (EXIT (NREVERSE0 #10#)))) . #13#)
                                        (EXIT
                                         (SEQ (LETT |guess| NIL . #13#)
                                          (LETT #12# |sumGuess| . #13#)
                                          G190
                                          (COND
                                            ((OR (ATOM #12#)
                                              (PROGN
                                                (LETT |guess|
                                                 (CAR #12#) . #13#)
                                                NIL))
                                             #14#))
                                          (SEQ
                                           (EXIT
                                            (COND
                                              ((COND
                                                 ((SPADCALL
                                                   (CONS
                                                    #'|GUESS;guess;LLLLL;106!2|
                                                    (VECTOR $ |guess|))
                                                   |res|
                                                   (QREFELT $ 504))
                                                  'NIL)
                                                 ('T 'T))
                                               (LETT |res|
                                                (CONS |guess| |res|) . #13#)))))
                                          (LETT #12# (CDR #12#) . #13#)
                                          #15# G191 (EXIT NIL))))))))))
                      (EXIT |res|)))
           #7# (EXIT #7#))))) 

(DEFUN |GUESS;guess;LLLLL;106!2| (|#1| $$)
  (SPADCALL (QCAR (QREFELT $$ 1)) (QCAR |#1|)
      (QREFELT (QREFELT $$ 0) 31))) 

(DEFUN |GUESS;guess;LLLLL;106!1| (|#1| $$)
  (PROG ($)
    (LETT $ (QREFELT $$ 0) |GUESS;guess;LLLLL;106|)
    (RETURN
      (PROGN
        (SPADCALL |#1|
            (SPADCALL (QREFELT $$ 1) (|spadConstant| $ 505)
                (QREFELT $ 34))
            (QREFELT $ 178)))))) 

(DEFUN |GUESS;guess;LLLLL;106!0| (|#1| $$)
  (SPADCALL (QCAR (QREFELT $$ 1)) (QCAR |#1|)
      (QREFELT (QREFELT $$ 0) 31))) 

(DEFUN |GUESS;guess;LL;107| (|list| $)
  (SPADCALL |list| (LIST (ELT $ 475))
      (LIST '|guessProduct| '|guessSum|) NIL (QREFELT $ 503))) 

(DEFUN |GUESS;guess;LLL;108| (|list| |options| $)
  (SPADCALL |list| (LIST (ELT $ 475))
      (LIST '|guessProduct| '|guessSum|) |options| (QREFELT $ 503))) 

(DEFUN |GUESS;guess;LLLL;109| (|list| |guessers| |ops| $)
  (SPADCALL |list| |guessers| |ops| NIL (QREFELT $ 503))) 

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

(DEFUN |Guess;| (|#1| |#2| |#3| |#4| |#5| |#6|)
  (PROG (DV$1 DV$2 DV$3 DV$4 DV$5 DV$6 |dv$| $ |pv$|)
    (RETURN
      (PROGN
        (LETT DV$1 (|devaluate| |#1|) . #0=(|Guess|))
        (LETT DV$2 (|devaluate| |#2|) . #0#)
        (LETT DV$3 (|devaluate| |#3|) . #0#)
        (LETT DV$4 (|devaluate| |#4|) . #0#)
        (LETT DV$5 (|devaluate| |#5|) . #0#)
        (LETT DV$6 (|devaluate| |#6|) . #0#)
        (LETT |dv$|
              (LIST '|Guess| DV$1 DV$2 DV$3 DV$4 DV$5 DV$6) . #0#)
        (LETT $ (GETREFV 510) . #0#)
        (QSETREFV $ 0 |dv$|)
        (QSETREFV $ 3
            (LETT |pv$|
                  (|buildPredVector| 0 0
                      (LIST (AND (|HasCategory| |#1|
                                     '(|RetractableTo| (|Symbol|)))
                                 (|HasCategory| |#2|
                                     '(|RetractableTo| (|Symbol|)))))) . #0#))
        (|haddProp| |$ConstructorCache| '|Guess|
            (LIST DV$1 DV$2 DV$3 DV$4 DV$5 DV$6) (CONS 1 $))
        (|stuffDomainSlots| $)
        (QSETREFV $ 6 |#1|)
        (QSETREFV $ 7 |#2|)
        (QSETREFV $ 8 |#3|)
        (QSETREFV $ 9 |#4|)
        (QSETREFV $ 10 |#5|)
        (QSETREFV $ 11 |#6|)
        (COND
          ((|HasCategory| |#1| '(|RetractableTo| (|Symbol|)))
           (COND
             ((|HasCategory| |#2| '(|RetractableTo| (|Symbol|)))
              (QSETREFV $ 192
                  (CONS (|dispatchFunction| |GUESS;guessExpRat;SM;23|)
                        $))))))
        (COND
          ((|HasCategory| |#1| '(|RetractableTo| (|Symbol|)))
           (COND
             ((|HasCategory| |#2| '(|RetractableTo| (|Symbol|)))
              (PROGN
                (QSETREFV $ 218
                    (CONS (|dispatchFunction|
                              |GUESS;guessBinRat;SM;35|)
                          $)))))))
        (COND
          ((|HasCategory| |#1| '(|RetractableTo| (|Symbol|)))
           (COND
             ((|HasCategory| |#2| '(|RetractableTo| (|Symbol|)))
              (PROGN
                (QSETREFV $ 327
                    (CONS (|dispatchFunction| |GUESS;diffHP;SM;60|) $)))))))
        (COND
          ((|HasCategory| |#1| '(|RetractableTo| (|Symbol|)))
           (COND
             ((|HasCategory| |#2| '(|RetractableTo| (|Symbol|)))
              (PROGN
                (QSETREFV $ 357
                    (CONS (|dispatchFunction| |GUESS;shiftHP;SM;75|) $)))))))
        (COND
          ((|HasCategory| |#1| '(|RetractableTo| (|Symbol|)))
           (COND
             ((|HasCategory| |#2| '(|RetractableTo| (|Symbol|)))
              (QSETREFV $ 469
                  (CONS (|dispatchFunction| |GUESS;guessADE;SM;96|) $))))))
        (COND
          ((|HasCategory| |#1| '(|RetractableTo| (|Symbol|)))
           (COND
             ((|HasCategory| |#2| '(|RetractableTo| (|Symbol|)))
              (PROGN
                (QSETREFV $ 477
                    (CONS (|dispatchFunction| |GUESS;guessRec;SM;103|)
                          $))
                (QSETREFV $ 479
                    (CONS (|dispatchFunction| |GUESS;guessPRec;SM;104|)
                          $))
                (QSETREFV $ 480
                    (CONS (|dispatchFunction| |GUESS;guessRat;SM;105|)
                          $)))))))
        $)))) 

(MAKEPROP '|Guess| '|infovec|
    (LIST '#(NIL NIL NIL NIL NIL NIL (|local| |#1|) (|local| |#2|)
             (|local| |#3|) (|local| |#4|) (|local| |#5|)
             (|local| |#6|) (0 . |One|) (4 . |One|) (|Integer|)
             (|List| 14) (8 . |elt|) (14 . +) (|Mapping| 14 14 14)
             (20 . |reduce|) (|PositiveInteger|) (27 . *)
             (33 . |denominator|) (|Symbol|) (38 . |coerce|)
             (43 . |coerce|) (48 . |eval|) (55 . |Zero|) (59 . |Zero|)
             (63 . |Zero|) (|Boolean|) (67 . =) (73 . |numerator|)
             (|List| 6) (78 . |elt|) (84 . /) (90 . |retract|)
             (95 . ~=) (|Fraction| 7) (101 . |coerce|)
             (|SparseUnivariatePolynomial| 6) (|Mapping| 6 7)
             (|SparseUnivariatePolynomial| 7)
             (|SparseUnivariatePolynomialFunctions2| 7 6) (106 . |map|)
             (|SparseMultivariatePolynomial| 6 72) (112 . |coerce|)
             (|Fraction| 45) (117 . |coerce|) (122 . |numer|)
             (|SparseMultivariatePolynomial| 7 72) (127 . |coerce|)
             (132 . |denom|) (|Fraction| 50) (137 . /) (143 . |zero?|)
             (148 . |leadingCoefficient|) (|NonNegativeInteger|)
             (153 . |degree|) (158 . **) (164 . *) (170 . |reductum|)
             (175 . +) (|Fraction| 40) (181 . |numer|) (186 . |denom|)
             (|MPolyCatFunctions2| 72 (|IndexedExponents| 72)
                 (|IndexedExponents| 72) 7 6 50 45)
             (191 . |map|) (|SparseUnivariatePolynomial| 50)
             (197 . |zero?|) (202 . |Zero|)
             (206 . |leadingCoefficient|)
             (|OrderedVariableList| (NRTEVAL (LIST '|a1| 'A)))
             (211 . |index|) (|List| 72) (216 . |eval|)
             (223 . |retract|) (228 . |degree|) (233 . |monomial|)
             (239 . |reductum|) (244 . +)
             (|Record| (|:| |num| 82) (|:| |den| 50))
             (|SparseUnivariatePolynomial| 53)
             (|UnivariatePolynomialCommonDenominator| 50 53 82)
             (250 . |splitDenominator|) (255 . *) (261 . |retract|)
             (|Mapping| 50 53)
             (|SparseUnivariatePolynomialFunctions2| 53 50)
             (266 . |map|) (272 . |coerce|) (|Fraction| 68) (277 . /)
             (283 . |convert|) (|Mapping| 8 72) (|Mapping| 8 6)
             (|PolynomialCategoryLifting| (|IndexedExponents| 72) 72 6
                 45 8)
             (288 . |map|) (295 . |degree|) (301 . |coerce|)
             (306 . |eval|) (313 . |univariate|) (318 . |degree|)
             (323 . |leadingCoefficient|) (328 . **) (334 . -)
             (339 . *) (345 . |zero?|) (350 . |resultant|)
             (|Union| $ '"failed") (356 . |exquo|) (362 . |coerce|)
             (367 . |coerce|) (372 . -) (378 . *) (384 . +) (390 . -)
             (396 . |last|) (401 . -) (406 . |list|) (411 . **)
             (|List| 455) (|GuessOptionFunctions0|) (417 . |maxDegree|)
             (422 . |debug|) (|OutputForm|) (427 . |coerce|)
             (432 . |hconcat|) (|Void|) (|OutputPackage|)
             (438 . |output|) (|String|) (|MoreSystemCommands|)
             (443 . |systemCommand|) (|Fraction| 82) (|List| 53)
             (|FractionFreeFastGaussian| 53 82) (448 . |interpolate|)
             (|Fraction| $) (455 . |elt|) (461 . -) (467 . |numer|)
             (|List| 7) (|NewtonInterpolation| 7) (472 . |newton|)
             (477 . |elt|) (483 . |output|) (488 . |minimumDegree|)
             (493 . |gcd|) (499 . |primitivePart|) (|Factored| 40)
             (|GeneralizedMultivariateFactorize|
                 (|SingletonAsOrderedSet|) (|IndexedExponents| 72) 6 6
                 40)
             (504 . |factor|)
             (|Record| (|:| |factor| 40) (|:| |exponent| 14))
             (|List| 153) (509 . |factors|) (514 . |coefficient|)
             (520 . /) (526 . -) (531 . |eval|) (538 . |zero?|)
             (543 . |univariate|) (548 . |numer|) (553 . |denom|)
             (558 . /) (564 . |numer|) (569 . |denom|) (574 . /)
             (|Kernel| 8) (580 . |kernel|) (|Kernel| $) (585 . |eval|)
             (592 . **) (598 . |one|) (603 . |safety|)
             (608 . |indexName|) (613 . |first|) (619 . |One|)
             (623 . =) (|Record| (|:| |function| 8) (|:| |order| 57))
             (|List| 179) (|Mapping| 179 8) (|List| 8)
             (|ListFunctions2| 8 179) (629 . |map|) (635 . -) (641 . <)
             (|Mapping| 30 179) (647 . |select|)
             |GUESS;guessExpRat;LL;21| |GUESS;guessExpRat;LLL;22|
             (|Mapping| 180 33 121) (653 . |guessExpRat|) (658 . *)
             (664 . +) (670 . |coerce|) (675 . -) (681 . *)
             (687 . |One|) (|Mapping| 50 50 50) (|List| 50)
             (691 . |reduce|) (698 . |factorial|) (703 . |binomial|)
             (709 . /) (715 . |resultant|) |GUESS;guessBinRat;LL;28|
             |GUESS;guessBinRat;LLL;29| (722 . |One|) (726 . |coerce|)
             (|Mapping| 53 53 53) (731 . |reduce|) (|Segment| 8)
             (738 . SEGMENT) (|SegmentBinding| 8) (744 . |equation|)
             (|SegmentBinding| $) (750 . |product|)
             (756 . |guessBinRat|) (|List| 15) (|Partition|)
             (761 . |powers|) (766 . |second|) (|Mapping| 8 8 8)
             (771 . |reduce|) (|UnivariateFormalPowerSeries| 6)
             (777 . **) (783 . *) (|Mapping| 225 225 225) (|List| 225)
             (789 . |reduce|) (795 . **) (|Mapping| 6 6) (801 . |map|)
             (|UnivariateFormalPowerSeriesFunctions| 6)
             (807 . |hadamard|) (|UnivariateFormalPowerSeries| 40)
             (813 . **) (819 . *) (|Mapping| 236 236 236) (|List| 236)
             (825 . |reduce|) (831 . **) (|Mapping| 40 40)
             (837 . |map|) (|UnivariateFormalPowerSeriesFunctions| 40)
             (843 . |hadamard|) (849 . |One|) (853 . |maxDerivative|)
             (858 . |maxPower|) (863 . |Zero|) (867 . -) (872 . -)
             (|Stream| 15) (|PartitionsAndPermutations|)
             (877 . |partitions|) (883 . |inc|) (|Mapping| 14 14)
             (|Stream| 14) (888 . |generate|) (894 . |partitions|)
             (|Stream| 253) (|Mapping| 253 14)
             (|StreamFunctions2| 14 253) (899 . |map|)
             (|StreamFunctions1| 15) (905 . |concat|) (910 . |Zero|)
             (914 . =) (920 . |One|) (924 . |true|) (928 . |first|)
             (933 . |false|) (937 . |#|) (|Mapping| 30 15)
             (942 . |select|) (948 . |cons|) (954 . |conjugates|)
             (959 . |homogeneous|) (964 . |rest|) (|Stream| 225)
             (|Mapping| 225 15) (|StreamFunctions2| 15 225)
             (969 . |map|) (975 . |empty?|) (980 . |max|) (|Stream| 57)
             (|Mapping| 57 15 57) (|StreamFunctions2| 15 57)
             (986 . |scan|) (|Stream| 236) (|Mapping| 236 15)
             (|StreamFunctions2| 15 236) (993 . |map|) (|Stream| 8)
             (|Mapping| 8 15) (|StreamFunctions2| 15 8) (999 . |map|)
             (1005 . D) (1012 . D) (1018 . D)
             (|FractionFreeFastGaussian| 7 42) (1024 . |DiffAction|)
             (|FractionFreeFastGaussian| 40 236) (1031 . |DiffAction|)
             (1038 . |DiffC|) (1043 . |displayAsGF|) (1048 . |One|)
             (1052 . |One|) (|Mapping| 280 225) (|Mapping| 290 236)
             (|Mapping| 294 8 23) (|Mapping| 7 57 57 42)
             (|Mapping| 40 57 57 236) (|Mapping| 8 57 23 8)
             (|Mapping| 142 57)
             (|Record| (|:| |guessStream| 309) (|:| |degreeStream| 286)
                 (|:| |testStream| 310) (|:| |exprStream| 311)
                 (|:| A 312) (|:| AF 313) (|:| AX 314) (|:| C 315))
             |GUESS;diffHP;LR;56| (1056 . *) (|Mapping| 6 14)
             (1062 . |multiplyCoefficients|) (1068 . |coerce|)
             (|Mapping| 40 14) (1073 . |multiplyCoefficients|)
             (|List| 57) (1079 . |repeating|) (|Mapping| 316 121)
             (1084 . |diffHP|) (1089 . |quoByVar|) (|Mapping| 225 225)
             (|MappingPackage1| 225) (1094 . **) (1100 . |quoByVar|)
             (|Mapping| 236 236) (|MappingPackage1| 236) (1105 . **)
             (|IntegerCombinatoricFunctions| 14) (1111 . |stirling2|)
             (1117 . |ShiftAction|) (1124 . |ShiftAction|)
             (1131 . |ShiftC|) (1136 . |monomial|) (1142 . -)
             (|Fraction| 14) (1148 . |One|) (1152 . -) (1157 . **)
             (1163 . |One|) (1167 . |monomial|) (1173 . -) (1179 . **)
             |GUESS;shiftHP;LR;70| (1185 . *) (1191 . |coerce|)
             (1196 . |qShiftAction|) (1204 . |qShiftAction|)
             (1212 . |qShiftC|) (1218 . |shiftHP|) (|Stream| 6)
             (1223 . |coerce|) (1228 . |series|) (|List| 40)
             (|Stream| 40) (1233 . |coerce|) (1238 . |series|)
             (1243 . +) (|SparseUnivariatePolynomial| 40)
             (|Mapping| 40 6)
             (|SparseUnivariatePolynomialFunctions2| 6 40)
             (1249 . |map|) (|UnivariatePolynomial| (NRTEVAL '|x|) 6)
             (1255 . |univariatePolynomial|) (1261 . |makeSUP|)
             (1266 . |first|) (1272 . |complete|) (1277 . |entries|)
             (|Mapping| 40 225) (|ListFunctions2| 225 40)
             (1282 . |map|) (|List| 42) (|Vector| 42) (1288 . |vector|)
             (1293 . +) (|Mapping| 57 57 57) (1299 . |reduce|)
             (|Matrix| 42) (1305 . |generalInterpolation|)
             (|Vector| 40) (1313 . |vector|)
             (|FractionFreeFastGaussianFractions| 7 42 40)
             (1318 . |generalInterpolation|) (|Stream| 385)
             (1326 . |generalInterpolation|)
             (1335 . |generalInterpolation|) (1344 . |allDegrees|)
             (1349 . |last|) (1354 . |zero?|) (1359 . |elt|)
             (|List| 366) (|Mapping| 366 42) (|ListFunctions2| 42 366)
             (1365 . |map|) (|Vector| 236) (1371 . |vector|)
             (|Vector| 366) (1376 . |vector|)
             (1381 . |generalCoefficient|) (1389 . |ground?|)
             (1394 . |elt|) (|BasicOperator|) (1400 . |name|)
             (1405 . |freeOf?|) (1411 . |zero?|) (1416 . |zero?|)
             (1421 . |zero?|) (1426 . |zero?|) (1431 . |zero?|)
             (|Union| 42 '"failed") (|Mapping| 30 42) (1436 . |find|)
             (1442 . |coerce|) (|List| $) (1447 . |gcd|)
             (1452 . |exquo|) (|Mapping| 40 42)
             (|ListFunctions2| 42 40) (1458 . |map|) (1464 . |coerce|)
             (1469 . |variableName|) (|RecurrenceOperator| 14 8)
             (1474 . |evalADE|) (1484 . |evalRec|)
             (1494 . |functionName|) (1499 . |operator|) (1504 . |new|)
             (1508 . |elt|) (1514 . |rest|) (1520 . |empty?|)
             (1525 . |elt|) (1531 . |coerce|) (1536 . ~=)
             (1542 . |first|) (1548 . |complete|) (1553 . |entries|)
             (1558 . |first|) (1564 . |complete|) (1569 . |entries|)
             (1574 . |coerce|) (1579 . |empty?|) (1584 . |first|)
             (1589 . |column|) (1595 . |entries|) (1600 . |member?|)
             (1606 . |rest|) |GUESS;guessHP;MM;87| (|GuessOption|)
             (1611 . |displayAsGF|) |GUESS;guessADE;LLL;88|
             |GUESS;guessADE;LL;89| (1616 . |maxDerivative|)
             |GUESS;guessAlg;LLL;90| |GUESS;guessAlg;LL;91|
             (1621 . |maxPower|) |GUESS;guessHolo;LLL;92|
             |GUESS;guessHolo;LL;93| (1626 . |allDegrees|)
             |GUESS;guessPade;LLL;94| |GUESS;guessPade;LL;95|
             (1631 . |cons|) (1637 . |guessADE|)
             |GUESS;guessRec;LLL;97| |GUESS;guessRec;LL;98|
             |GUESS;guessPRec;LLL;99| |GUESS;guessPRec;LL;100|
             (1642 . |maxShift|) |GUESS;guessRat;LLL;101|
             |GUESS;guessRat;LL;102| (1647 . |guessRec|)
             (1652 . |append|) (1658 . |guessPRec|) (1663 . |guessRat|)
             (1668 . |maxLevel|) (1673 . |coerce|) (1678 . |coerce|)
             (|List| 23) (1683 . |member?|) (1689 . |member?|)
             (1695 . |one?|) (1700 . |one?|) (1705 . |one?|)
             (1710 . |one?|) (1715 . |one?|) (1720 . |one?|)
             (1725 . |one?|) (1730 . |one?|) (|Mapping| 30 6)
             (1735 . |every?|) (1741 . |coerce|) (|List| 125)
             (1746 . |subscript|) (1752 . |indexName|)
             (1757 . |maxLevel|) (|List| 191) |GUESS;guess;LLLLL;106|
             (1762 . |any?|) (1768 . |One|) (1772 . |summation|)
             |GUESS;guess;LL;107| |GUESS;guess;LLL;108|
             |GUESS;guess;LLLL;109|)
          '#(|shiftHP| 1778 |guessRec| 1788 |guessRat| 1804 |guessPade|
             1820 |guessPRec| 1831 |guessHolo| 1847 |guessHP| 1858
             |guessExpRat| 1863 |guessBinRat| 1879 |guessAlg| 1895
             |guessADE| 1906 |guess| 1922 |diffHP| 1948)
          'NIL
          (CONS (|makeByteWordVec2| 1 'NIL)
                (CONS '#()
                      (CONS '#()
                            (|makeByteWordVec2| 509
                                '(0 6 0 12 0 7 0 13 2 15 14 0 14 16 2
                                  14 0 0 0 17 3 15 14 18 0 14 19 2 14 0
                                  20 0 21 1 8 0 0 22 1 8 0 23 24 1 8 0
                                  14 25 3 8 0 0 0 0 26 0 6 0 27 0 7 0
                                  28 0 8 0 29 2 8 30 0 0 31 1 8 0 0 32
                                  2 33 6 0 14 34 2 8 0 0 0 35 1 8 9 0
                                  36 2 6 30 0 0 37 1 38 0 7 39 2 43 40
                                  41 42 44 1 45 0 6 46 1 47 0 45 48 1
                                  38 7 0 49 1 50 0 7 51 1 38 7 0 52 2
                                  53 0 50 50 54 1 40 30 0 55 1 40 6 0
                                  56 1 40 57 0 58 2 8 0 0 57 59 2 8 0 0
                                  0 60 1 40 0 0 61 2 8 0 0 0 62 1 63 40
                                  0 64 1 63 40 0 65 2 66 45 41 50 67 1
                                  68 30 0 69 0 40 0 70 1 68 50 0 71 1
                                  72 0 20 73 3 45 0 0 74 33 75 1 45 6 0
                                  76 1 68 57 0 77 2 40 0 6 57 78 1 68 0
                                  0 79 2 40 0 0 0 80 1 83 81 82 84 2 53
                                  0 0 50 85 1 53 50 0 86 2 88 68 87 82
                                  89 1 68 0 50 90 2 91 0 68 68 92 1 72
                                  23 0 93 3 96 8 94 95 45 97 2 50 57 0
                                  72 98 1 7 0 14 99 3 50 0 0 72 7 100 1
                                  50 42 0 101 1 42 57 0 102 1 42 7 0
                                  103 2 7 0 0 57 104 1 7 0 0 105 2 7 0
                                  0 0 106 1 7 30 0 107 2 42 7 0 0 108 2
                                  7 109 0 0 110 1 50 0 72 111 1 53 0 50
                                  112 2 6 0 0 0 113 2 53 0 0 0 114 2 53
                                  0 0 0 115 2 8 0 0 0 116 1 15 14 0 117
                                  1 14 0 0 118 1 15 0 14 119 2 53 0 0
                                  14 120 1 122 14 121 123 1 122 30 121
                                  124 1 57 125 0 126 2 125 0 0 0 127 1
                                  129 128 125 130 1 132 128 131 133 3
                                  136 134 135 135 57 137 2 82 53 138 53
                                  139 2 53 0 0 0 140 1 53 50 0 141 1
                                  143 42 142 144 2 131 0 0 0 145 1 129
                                  128 131 146 1 42 57 0 147 2 42 0 0 0
                                  148 1 42 0 0 149 1 151 150 40 152 1
                                  150 154 0 155 2 40 6 0 57 156 2 6 0 0
                                  0 157 1 6 0 0 158 3 45 0 0 72 6 159 1
                                  45 30 0 160 1 45 40 0 161 1 134 82 0
                                  162 1 134 82 0 163 2 91 0 0 0 164 1
                                  91 68 0 165 1 91 68 0 166 2 63 0 40
                                  40 167 1 168 0 23 169 3 8 0 0 170 0
                                  171 2 8 0 0 0 172 1 122 30 121 173 1
                                  122 57 121 174 1 122 23 121 175 2 33
                                  0 0 57 176 0 8 0 177 2 6 30 0 0 178 2
                                  183 180 181 182 184 2 14 0 0 0 185 2
                                  14 30 0 0 186 2 180 0 187 0 188 1 0
                                  191 23 192 2 50 0 14 0 193 2 50 0 0 0
                                  194 1 50 0 14 195 2 50 0 0 0 196 2 50
                                  0 0 0 197 0 50 0 198 3 200 50 199 0
                                  50 201 1 14 0 0 202 2 8 0 0 0 203 2
                                  53 0 0 0 204 3 50 0 0 0 72 205 0 53 0
                                  208 1 6 0 23 209 3 135 53 210 0 53
                                  211 2 212 0 8 8 213 2 214 0 23 212
                                  215 2 8 0 0 216 217 1 0 191 23 218 1
                                  220 219 15 221 1 15 14 0 222 2 182 8
                                  223 0 224 2 225 0 0 57 226 2 225 0 0
                                  0 227 2 229 225 228 0 230 2 6 0 0 57
                                  231 2 225 0 232 0 233 2 234 225 225
                                  225 235 2 236 0 0 57 237 2 236 0 0 0
                                  238 2 240 236 239 0 241 2 40 0 0 57
                                  242 2 236 0 243 0 244 2 245 236 236
                                  236 246 0 9 0 247 1 122 14 121 248 1
                                  122 14 121 249 0 9 0 250 1 8 0 0 251
                                  1 9 0 0 252 2 254 253 14 14 255 1 14
                                  0 0 256 2 258 0 257 14 259 1 254 253
                                  14 260 2 263 261 262 258 264 1 265
                                  253 261 266 0 57 0 267 2 14 30 0 0
                                  268 0 57 0 269 0 30 0 270 1 15 14 0
                                  271 0 30 0 272 1 15 57 0 273 2 253 0
                                  274 0 275 2 253 0 15 0 276 1 254 253
                                  253 277 1 122 30 121 278 1 253 0 0
                                  279 2 282 280 281 253 283 1 15 30 0
                                  284 2 57 0 0 0 285 3 288 286 57 287
                                  253 289 2 292 290 291 253 293 2 296
                                  294 295 253 297 3 8 0 0 23 57 298 2
                                  225 0 0 57 299 2 236 0 0 57 300 3 301
                                  7 57 57 42 302 3 303 40 57 57 236 304
                                  1 301 142 57 305 1 122 30 121 306 0
                                  225 0 307 0 236 0 308 2 14 0 57 0 318
                                  2 225 0 319 0 320 1 40 0 6 321 2 236
                                  0 322 0 323 1 286 0 324 325 1 0 326
                                  23 327 1 225 0 0 328 2 330 329 329 57
                                  331 1 236 0 0 332 2 334 333 333 57
                                  335 2 336 14 14 14 337 3 301 7 57 57
                                  42 338 3 303 40 57 57 236 339 1 301
                                  142 57 340 2 225 0 6 57 341 2 225 0 0
                                  0 342 0 343 0 344 1 343 0 0 345 2 225
                                  0 0 343 346 0 40 0 347 2 236 0 40 57
                                  348 2 236 0 0 0 349 2 236 0 0 343 350
                                  2 8 0 57 0 352 1 7 0 23 353 4 301 7 7
                                  57 57 42 354 4 303 40 40 57 57 236
                                  355 2 301 142 7 57 356 1 0 326 23 357
                                  1 358 0 33 359 1 225 0 358 360 1 362
                                  0 361 363 1 236 0 362 364 2 236 0 0 0
                                  365 2 368 366 367 40 369 2 225 370 0
                                  57 371 1 370 40 0 372 2 280 0 0 57
                                  373 1 280 0 0 374 1 280 229 0 375 2
                                  377 361 376 229 378 1 380 0 379 381 2
                                  57 0 0 0 382 2 324 57 383 0 384 4 301
                                  385 142 312 380 324 386 1 387 0 361
                                  388 4 389 385 142 312 387 324 390 5
                                  301 391 142 312 380 57 57 392 5 389
                                  391 142 312 387 57 57 393 1 122 30
                                  121 394 1 379 42 0 395 1 42 30 0 396
                                  2 379 42 0 14 397 2 400 398 399 379
                                  401 1 402 0 240 403 1 404 0 398 405 4
                                  303 40 313 402 57 404 406 1 40 30 0
                                  407 2 182 8 0 14 408 1 409 23 0 410 2
                                  8 30 0 23 411 1 6 30 0 412 1 8 30 0
                                  413 1 225 30 0 414 1 57 30 0 415 1
                                  236 30 0 416 2 379 417 418 0 419 1 42
                                  0 7 420 1 42 0 421 422 2 42 109 0 0
                                  423 2 425 361 424 379 426 1 361 125 0
                                  427 1 122 23 121 428 6 429 8 409 23 8
                                  8 8 182 430 6 429 8 409 23 8 8 8 182
                                  431 1 122 23 121 432 1 409 0 23 433 0
                                  23 0 434 2 8 0 409 0 435 2 280 0 0 57
                                  436 1 280 30 0 437 2 286 57 0 14 438
                                  1 14 125 0 439 2 14 30 0 0 440 2 290
                                  0 0 57 441 1 290 0 0 442 1 290 240 0
                                  443 2 294 0 0 57 444 1 294 0 0 445 1
                                  294 182 0 446 1 182 125 0 447 1 391
                                  30 0 448 1 391 385 0 449 2 385 380 0
                                  14 450 1 380 379 0 451 2 180 30 179 0
                                  452 1 391 0 0 453 1 455 0 30 456 1
                                  455 0 14 459 1 455 0 14 462 1 455 0
                                  30 465 2 121 0 455 0 468 1 0 191 23
                                  469 1 455 0 14 474 1 0 191 23 477 2
                                  121 0 0 0 478 1 0 191 23 479 1 0 191
                                  23 480 1 122 14 121 481 1 33 125 0
                                  482 1 180 125 0 483 2 484 30 23 0 485
                                  2 33 30 6 0 486 1 7 30 0 487 1 8 30 0
                                  488 1 225 30 0 489 1 57 30 0 490 1
                                  236 30 0 491 1 40 30 0 492 1 42 30 0
                                  493 1 6 30 0 494 2 33 30 495 0 496 1
                                  20 125 0 497 2 23 0 0 498 499 1 455 0
                                  23 500 1 455 0 14 501 2 180 30 187 0
                                  504 0 20 0 505 2 8 0 0 216 506 1 1
                                  326 23 357 1 0 316 121 351 1 1 191 23
                                  477 1 0 180 33 471 2 0 180 33 121 470
                                  1 1 191 23 480 2 0 180 33 121 475 1 0
                                  180 33 476 2 0 180 33 121 466 1 0 180
                                  33 467 1 1 191 23 479 2 0 180 33 121
                                  472 1 0 180 33 473 1 0 180 33 464 2 0
                                  180 33 121 463 1 0 191 326 454 1 1
                                  191 23 192 2 0 180 33 121 190 1 0 180
                                  33 189 1 1 191 23 218 2 0 180 33 121
                                  207 1 0 180 33 206 1 0 180 33 461 2 0
                                  180 33 121 460 1 1 191 23 469 1 0 180
                                  33 458 2 0 180 33 121 457 2 0 180 33
                                  121 508 1 0 180 33 507 4 0 180 33 502
                                  484 121 503 3 0 180 33 502 484 509 1
                                  1 326 23 327 1 0 316 121 317)))))
          '|lookupComplete|)) 
