
(/VERSIONCHECK 2) 

(DEFUN |GUESSP1;m1| (|var| $) (SPADCALL |var| (QREFELT $ 9))) 

(DEFUN |GUESSP1;m3| (|var| $) (SPADCALL |var| (QREFELT $ 11))) 

(DEFUN |GUESSP1;m2| (|coeff| $) (SPADCALL |coeff| (QREFELT $ 12))) 

(DEFUN |GUESSP1;S2EXPRR| (|p| $)
  (SPADCALL (CONS #'|GUESSP1;S2EXPRR!0| $) (CONS #'|GUESSP1;S2EXPRR!1| $) |p|
            (QREFELT $ 17))) 

(DEFUN |GUESSP1;S2EXPRR!1| (|coeff| $) (|GUESSP1;m2| |coeff| $)) 

(DEFUN |GUESSP1;S2EXPRR!0| (|var| $) (|GUESSP1;m1| |var| $)) 

(DEFUN |GUESSP1;F2EXPRR;FE;5| (|p| $)
  (SPADCALL (|GUESSP1;S2EXPRR| (SPADCALL |p| (QREFELT $ 19)) $)
            (|GUESSP1;S2EXPRR| (SPADCALL |p| (QREFELT $ 20)) $) (QREFELT $ 21))) 

(DEFUN |GUESSP1;retractVar| (|v| $)
  (PROG (|r| |v2|)
    (RETURN
     (SEQ (LETT |v2| (|GUESSP1;m3| |v| $) . #1=(|GUESSP1;retractVar|))
          (LETT |r| (SPADCALL |v2| (QREFELT $ 24)) . #1#)
          (EXIT
           (COND
            ((QEQCAR |r| 1)
             (SPADCALL (SPADCALL |v2| (QREFELT $ 25)) (QREFELT $ 26)))
            ('T (SPADCALL (QCDR |r|) (QREFELT $ 27))))))))) 

(DEFUN |GUESSP1;SMP2S| (|p| $)
  (SPADCALL (CONS #'|GUESSP1;SMP2S!0| $) (CONS #'|GUESSP1;SMP2S!1| $) |p|
            (QREFELT $ 34))) 

(DEFUN |GUESSP1;SMP2S!1| (|coeff| $)
  (SPADCALL (SPADCALL |coeff| (QREFELT $ 29)) (QREFELT $ 27))) 

(DEFUN |GUESSP1;SMP2S!0| (|var| $) (|GUESSP1;retractVar| |var| $)) 

(DEFUN |GUESSP1;EXPRR2F;EF;8| (|p| $)
  (SPADCALL (|GUESSP1;SMP2S| (SPADCALL |p| (QREFELT $ 36)) $)
            (|GUESSP1;SMP2S| (SPADCALL |p| (QREFELT $ 37)) $) (QREFELT $ 38))) 

(DEFUN |GuessPolynomialFunctions| (#1=#:G2102)
  (PROG ()
    (RETURN
     (PROG (#2=#:G2103)
       (RETURN
        (COND
         ((LETT #2#
                (|lassocShiftWithFunction| (LIST (|devaluate| #1#))
                                           (HGET |$ConstructorCache|
                                                 '|GuessPolynomialFunctions|)
                                           '|domainEqualList|)
                . #3=(|GuessPolynomialFunctions|))
          (|CDRwithIncrement| #2#))
         ('T
          (UNWIND-PROTECT
              (PROG1 (|GuessPolynomialFunctions;| #1#) (LETT #2# T . #3#))
            (COND
             ((NOT #2#)
              (HREM |$ConstructorCache| '|GuessPolynomialFunctions|))))))))))) 

(DEFUN |GuessPolynomialFunctions;| (|#1|)
  (PROG (|pv$| $ |dv$| DV$1)
    (RETURN
     (PROGN
      (LETT DV$1 (|devaluate| |#1|) . #1=(|GuessPolynomialFunctions|))
      (LETT |dv$| (LIST '|GuessPolynomialFunctions| DV$1) . #1#)
      (LETT $ (GETREFV 40) . #1#)
      (QSETREFV $ 0 |dv$|)
      (QSETREFV $ 3 (LETT |pv$| (|buildPredVector| 0 0 NIL) . #1#))
      (|haddProp| |$ConstructorCache| '|GuessPolynomialFunctions| (LIST DV$1)
                  (CONS 1 $))
      (|stuffDomainSlots| $)
      (QSETREFV $ 6 |#1|)
      (COND
       ((|HasCategory| (|Expression| (|Integer|))
                       (LIST '|RetractableTo| (|devaluate| |#1|)))
        (PROGN
         (QSETREFV $ 22 (CONS (|dispatchFunction| |GUESSP1;F2EXPRR;FE;5|) $))
         (QSETREFV $ 39 (CONS (|dispatchFunction| |GUESSP1;EXPRR2F;EF;8|) $))))
       ('T
        (|error|
         "retraction and coercion to EXPR INT is not implemented for this Ring")))
      $)))) 

(MAKEPROP '|GuessPolynomialFunctions| '|infovec|
          (LIST
           '#(NIL NIL NIL NIL NIL NIL (|local| |#1|) (|Symbol|)
              (|Expression| 28) (0 . |coerce|) (|Kernel| $) (5 . |coerce|)
              (10 . |coerce|) (|Mapping| 8 7) (|Mapping| 8 6) (|Polynomial| 6)
              (|PolynomialCategoryLifting| (|IndexedExponents| 7) 7 6 15 8)
              (15 . |map|) (|Fraction| 15) (22 . |numer|) (27 . |denom|)
              (32 . /) (38 . F2EXPRR) (|Union| 6 '"failed")
              (43 . |retractIfCan|) (48 . |retract|) (53 . |coerce|)
              (58 . |coerce|) (|Integer|) (63 . |coerce|)
              (|Mapping| 15 (|Kernel| 8)) (|Mapping| 15 28)
              (|SparseMultivariatePolynomial| 28 (|Kernel| 8))
              (|PolynomialCategoryLifting| (|IndexedExponents| (|Kernel| 8))
                                           (|Kernel| 8) 28 32 15)
              (68 . |map|) (|SparseMultivariatePolynomial| 28 10)
              (75 . |numer|) (80 . |denom|) (85 . /) (91 . EXPRR2F))
           '#(F2EXPRR 96 EXPRR2F 101) 'NIL
           (CONS (|makeByteWordVec2| 1 'NIL)
                 (CONS '#()
                       (CONS '#()
                             (|makeByteWordVec2| 39
                                                 '(1 8 0 7 9 1 8 0 10 11 1 8 0
                                                   6 12 3 16 8 13 14 15 17 1 18
                                                   15 0 19 1 18 15 0 20 2 8 0 0
                                                   0 21 1 0 8 18 22 1 8 23 0 24
                                                   1 8 7 0 25 1 15 0 7 26 1 15
                                                   0 6 27 1 6 0 28 29 3 33 15
                                                   30 31 32 34 1 8 35 0 36 1 8
                                                   35 0 37 2 18 0 15 15 38 1 0
                                                   18 8 39 1 0 8 18 22 1 0 18 8
                                                   39)))))
           '|lookupComplete|)) 
