
(/VERSIONCHECK 2) 

(DEFUN |SUP;**;$Pi$;1| (|p| |np| $)
  (SPADCALL |p| |np| (QREFELT $ 12))) 

(DEFUN |SUP;^;$Pi$;2| (|p| |np| $) (SPADCALL |p| |np| (QREFELT $ 12))) 

(DEFUN |SUP;^;$Nni$;3| (|p| |n| $) (SPADCALL |p| |n| (QREFELT $ 12))) 

(DEFUN |SUP;**;$Nni$;4| (|p| |n| $)
  (PROG (|cc| |y| #0=#:G1854 #1=#:G1855 |t| #2=#:G1856 |rec| |qn| |rn|)
    (RETURN
      (SEQ (EXIT (COND
                   ((NULL |p|) (|spadConstant| $ 17))
                   ((ZEROP |n|) (|spadConstant| $ 18))
                   ((EQL |n| 1) |p|)
                   ('T
                    (COND
                      ((NULL (CDR |p|))
                       (COND
                         ((SPADCALL
                              (LETT |cc|
                                    (SPADCALL (QCDR (|SPADfirst| |p|))
                                     |n| (QREFELT $ 21))
                                    . #3=(|SUP;**;$Nni$;4|))
                              (QREFELT $ 23))
                          (|spadConstant| $ 17))
                         ('T
                          (LIST (CONS (* |n| (QCAR (|SPADfirst| |p|)))
                                      |cc|)))))
                      ('T
                       (SEQ (COND
                              ((< (SPADCALL (QREFELT $ 24)) 3)
                               (PROGN
                                 (LETT #0#
                                       (SPADCALL |p| |n|
                                        (QREFELT $ 26)) . #3#)
                                 (GO #0#))))
                            (LETT |y| (|spadConstant| $ 18) . #3#)
                            (LETT |rec|
                                  (DIVIDE2 |n|
                                           (SPADCALL (QREFELT $ 24))) . #3#)
                            (LETT |qn| (QCAR |rec|) . #3#)
                            (LETT |rn| (QCDR |rec|) . #3#)
                            (SEQ G190 NIL
                                 (SEQ (COND
                                        ((EQL |rn| 1)
                                         (LETT |y|
                                          (SPADCALL |y| |p|
                                           (QREFELT $ 27)) . #3#)))
                                      (COND
                                        ((< 1 |rn|)
                                         (LETT |y|
                                          (SPADCALL |y|
                                           (SPADCALL
                                            (LIST (|SPADfirst| |p|))
                                            (CDR |p|) |rn|
                                            (QREFELT $ 28))
                                           (QREFELT $ 27)) . #3#)))
                                      (EXIT
                                       (COND
                                         ((ZEROP |qn|)
                                          (PROGN
                                            (LETT #0# |y| . #3#)
                                            (GO #0#)))
                                         ('T
                                          (SEQ
                                           (LETT |p|
                                            (PROGN
                                              (LETT #1# NIL . #3#)
                                              (SEQ (LETT |t| NIL . #3#)
                                               (LETT #2# |p| . #3#)
                                               G190
                                               (COND
                                                 ((OR (ATOM #2#)
                                                   (PROGN
                                                     (LETT |t|
                                                      (CAR #2#) . #3#)
                                                     NIL))
                                                  (GO G191)))
                                               (SEQ
                                                (EXIT
                                                 (LETT #1#
                                                  (CONS
                                                   (CONS
                                                    (* (QCAR |t|)
                                                     (SPADCALL
                                                      (QREFELT $ 24)))
                                                    (SPADCALL
                                                     (QCDR |t|)
                                                     (QREFELT $ 29)))
                                                   #1#) . #3#)))
                                               (LETT #2#
                                                (CDR #2#) . #3#)
                                               #4=(GO G190) G191
                                               (EXIT (NREVERSE0 #1#)))) . #3#)
                                           (LETT |rec|
                                            (DIVIDE2 |qn|
                                             (SPADCALL (QREFELT $ 24))) . #3#)
                                           (LETT |qn|
                                            (QCAR |rec|) . #3#)
                                           (EXIT
                                            (LETT |rn|
                                             (QCDR |rec|) . #3#)))))))
                                 NIL #4# G191 (EXIT NIL))
                            (EXIT |y|)))))))
           #0# (EXIT #0#))))) 

(PUT '|SUP;zero?;$B;5| '|SPADreplace| 'NULL) 

(DEFUN |SUP;zero?;$B;5| (|p| $) (NULL |p|)) 

(DEFUN |SUP;one?;$B;6| (|p| $)
  (COND
    ((OR (OR (NULL |p|) (NULL (NULL (CDR |p|))))
         (NULL (ZEROP (QCAR (|SPADfirst| |p|)))))
     'NIL)
    ('T
     (SPADCALL (QCDR (|SPADfirst| |p|)) (|spadConstant| $ 19)
         (QREFELT $ 31))))) 

(DEFUN |SUP;ground?;$B;7| (|p| $)
  (COND
    ((NULL |p|) 'T)
    ((NULL (CDR |p|)) (ZEROP (QCAR (|SPADfirst| |p|))))
    ('T 'NIL))) 

(DEFUN |SUP;multiplyExponents;$Nni$;8| (|p| |n| $)
  (PROG (#0=#:G1867 |u| #1=#:G1868)
    (RETURN
      (SEQ (PROGN
             (LETT #0# NIL . #2=(|SUP;multiplyExponents;$Nni$;8|))
             (SEQ (LETT |u| NIL . #2#) (LETT #1# |p| . #2#) G190
                  (COND
                    ((OR (ATOM #1#)
                         (PROGN (LETT |u| (CAR #1#) . #2#) NIL))
                     (GO G191)))
                  (SEQ (EXIT (LETT #0#
                                   (CONS
                                    (CONS (* (QCAR |u|) |n|)
                                     (QCDR |u|))
                                    #0#) . #2#)))
                  (LETT #1# (CDR #1#) . #2#) (GO G190) G191
                  (EXIT (NREVERSE0 #0#)))))))) 

(DEFUN |SUP;divideExponents;$NniU;9| (|p| |n| $)
  (PROG (|m| |u| #0=#:G1878)
    (RETURN
      (SEQ (COND
             ((NULL |p|) (CONS 0 |p|))
             (#1='T
              (SEQ (LETT |m|
                         (SPADCALL (QCAR (|SPADfirst| |p|)) |n|
                             (QREFELT $ 36))
                         . #2=(|SUP;divideExponents;$NniU;9|))
                   (EXIT (COND
                           ((QEQCAR |m| 1) (CONS 1 "failed"))
                           (#1#
                            (SEQ (LETT |u|
                                       (SPADCALL (CDR |p|) |n|
                                        (QREFELT $ 37)) . #2#)
                                 (EXIT (COND
                                         ((QEQCAR |u| 1)
                                          (CONS 1 "failed"))
                                         (#1#
                                          (CONS 0
                                           (CONS
                                            (CONS
                                             (PROG1
                                              (LETT #0#
                                               (QCDR |m|) . #2#)
                                               (|check-subtype|
                                                (>= #0# 0)
                                                '(|NonNegativeInteger|)
                                                #0#))
                                             (QCDR (|SPADfirst| |p|)))
                                            (QCDR |u|))))))))))))))))) 

(DEFUN |SUP;karatsubaDivide;$NniR;10| (|p| |n| $)
  (PROG (|t| #0=#:G1889 |lowp| #1=#:G1886 |highp|)
    (RETURN
      (SEQ (COND
             ((ZEROP |n|) (CONS |p| (|spadConstant| $ 17)))
             ('T
              (SEQ (LETT |lowp| |p|
                         . #2=(|SUP;karatsubaDivide;$NniR;10|))
                   (LETT |highp| NIL . #2#)
                   (SEQ (EXIT (SEQ G190 NIL
                                   (SEQ
                                    (COND
                                      ((NULL |lowp|)
                                       (PROGN
                                         (LETT #0# |$NoValue| . #2#)
                                         (GO #0#))))
                                    (LETT |t|
                                     (|SPADfirst| |lowp|) . #2#)
                                    (COND
                                      ((< (QCAR |t|) |n|)
                                       (PROGN
                                         (LETT #0# |$NoValue| . #2#)
                                         (GO #0#))))
                                    (LETT |lowp| (CDR |lowp|) . #2#)
                                    (EXIT
                                     (LETT |highp|
                                      (CONS
                                       (CONS
                                        (PROG2
                                         (LETT #1#
                                          (SPADCALL (QCAR |t|) |n|
                                           (QREFELT $ 39)) . #2#)
                                         (QCDR #1#)
                                          (|check-union| (QEQCAR #1# 0)
                                           (|NonNegativeInteger|) #1#))
                                        (QCDR |t|))
                                       |highp|) . #2#)))
                                   NIL (GO G190) G191 (EXIT NIL)))
                        #0# (EXIT #0#))
                   (EXIT (CONS (REVERSE |highp|) |lowp|))))))))) 

(DEFUN |SUP;shiftRight;$Nni$;11| (|p| |n| $)
  (PROG (#0=#:G1899 |t| #1=#:G1900 #2=#:G1895)
    (RETURN
      (SEQ (PROGN
             (LETT #0# NIL . #3=(|SUP;shiftRight;$Nni$;11|))
             (SEQ (LETT |t| NIL . #3#) (LETT #1# |p| . #3#) G190
                  (COND
                    ((OR (ATOM #1#)
                         (PROGN (LETT |t| (CAR #1#) . #3#) NIL))
                     (GO G191)))
                  (SEQ (EXIT (LETT #0#
                                   (CONS
                                    (CONS
                                     (PROG2
                                      (LETT #2#
                                       (SPADCALL (QCAR |t|) |n|
                                        (QREFELT $ 39)) . #3#)
                                      (QCDR #2#)
                                       (|check-union| (QEQCAR #2# 0)
                                        (|NonNegativeInteger|) #2#))
                                     (QCDR |t|))
                                    #0#) . #3#)))
                  (LETT #1# (CDR #1#) . #3#) (GO G190) G191
                  (EXIT (NREVERSE0 #0#)))))))) 

(DEFUN |SUP;shiftLeft;$Nni$;12| (|p| |n| $)
  (PROG (#0=#:G1903 |t| #1=#:G1904)
    (RETURN
      (SEQ (PROGN
             (LETT #0# NIL . #2=(|SUP;shiftLeft;$Nni$;12|))
             (SEQ (LETT |t| NIL . #2#) (LETT #1# |p| . #2#) G190
                  (COND
                    ((OR (ATOM #1#)
                         (PROGN (LETT |t| (CAR #1#) . #2#) NIL))
                     (GO G191)))
                  (SEQ (EXIT (LETT #0#
                                   (CONS
                                    (CONS (+ (QCAR |t|) |n|)
                                     (QCDR |t|))
                                    #0#) . #2#)))
                  (LETT #1# (CDR #1#) . #2#) (GO G190) G191
                  (EXIT (NREVERSE0 #0#)))))))) 

(DEFUN |SUP;pomopo!;$RNni2$;13| (|p1| |r| |e| |p2| $)
  (PROG (|tm| #0=#:G1914 |e2| |c2| |u| |rout|)
    (RETURN
      (SEQ (LETT |rout| NIL . #1=(|SUP;pomopo!;$RNni2$;13|))
           (SEQ (LETT |tm| NIL . #1#) (LETT #0# |p2| . #1#) G190
                (COND
                  ((OR (ATOM #0#)
                       (PROGN (LETT |tm| (CAR #0#) . #1#) NIL))
                   #2=(GO G191)))
                (SEQ (LETT |e2| (+ |e| (QCAR |tm|)) . #1#)
                     (LETT |c2|
                           (SPADCALL |r| (QCDR |tm|) (QREFELT $ 44)) . #1#)
                     (EXIT (COND
                             ((SPADCALL |c2| (|spadConstant| $ 38)
                                  (QREFELT $ 31))
                              "next term")
                             ('T
                              (SEQ (SEQ G190
                                    (COND
                                      ((NULL
                                        (COND
                                          ((NULL |p1|) 'NIL)
                                          ('T
                                           (< |e2|
                                            (QCAR (|SPADfirst| |p1|))))))
                                       #2#))
                                    (SEQ
                                     (LETT |rout|
                                      (CONS (|SPADfirst| |p1|) |rout|) . #1#)
                                     (EXIT
                                      (LETT |p1| (CDR |p1|) . #1#)))
                                    NIL #3=(GO G190) G191 (EXIT NIL))
                                   (COND
                                     ((OR (NULL |p1|)
                                       (< (QCAR (|SPADfirst| |p1|))
                                        |e2|))
                                      (EXIT
                                       (LETT |rout|
                                        (CONS (CONS |e2| |c2|) |rout|) . #1#))))
                                   (SEQ
                                    (LETT |u|
                                     (SPADCALL
                                      (QCDR (|SPADfirst| |p1|)) |c2|
                                      (QREFELT $ 45)) . #1#)
                                    (EXIT
                                     (COND
                                       ((NULL
                                         (SPADCALL |u|
                                          (|spadConstant| $ 38)
                                          (QREFELT $ 31)))
                                        (LETT |rout|
                                         (CONS (CONS |e2| |u|) |rout|) . #1#)))))
                                   (EXIT (LETT |p1| (CDR |p1|) . #1#)))))))
                (LETT #0# (CDR #0#) . #1#) #3# G191 (EXIT NIL))
           (EXIT (NRECONC |rout| |p1|)))))) 

(PUT '|SUP;univariate;2$;14| '|SPADreplace| '(XLAM (|p|) |p|)) 

(DEFUN |SUP;univariate;2$;14| (|p| $) |p|) 

(PUT '|SUP;multivariate;$Saos$;15| '|SPADreplace|
     '(XLAM (|sup| |v|) |sup|)) 

(DEFUN |SUP;multivariate;$Saos$;15| (|sup| |v| $) |sup|) 

(DEFUN |SUP;univariate;$SaosSup;16| (|p| |v| $)
  (COND
    ((SPADCALL |p| (QREFELT $ 30)) (|spadConstant| $ 52))
    ('T
     (SPADCALL
         (SPADCALL
             (SPADCALL (SPADCALL |p| (QREFELT $ 53)) (QREFELT $ 54))
             (SPADCALL |p| (QREFELT $ 55)) (QREFELT $ 56))
         (SPADCALL (SPADCALL |p| (QREFELT $ 57)) |v| (QREFELT $ 59))
         (QREFELT $ 60))))) 

(DEFUN |SUP;multivariate;SupSaos$;17| (|supp| |v| $)
  (PROG (|lc|)
    (RETURN
      (SEQ (COND
             ((SPADCALL |supp| (QREFELT $ 61)) (|spadConstant| $ 17))
             ('T
              (SEQ (LETT |lc| (SPADCALL |supp| (QREFELT $ 62))
                         |SUP;multivariate;SupSaos$;17|)
                   (EXIT (COND
                           ((< 0 (SPADCALL |lc| (QREFELT $ 55)))
                            (|error| "bad form polynomial"))
                           ('T
                            (SPADCALL
                                (SPADCALL
                                    (SPADCALL |lc| (QREFELT $ 53))
                                    (SPADCALL |supp| (QREFELT $ 63))
                                    (QREFELT $ 64))
                                (SPADCALL
                                    (SPADCALL |supp| (QREFELT $ 65))
                                    |v| (QREFELT $ 66))
                                (QREFELT $ 67)))))))))))) 

(DEFUN |SUP;squareFreePolynomial;SupF;18| (|pp| $)
  (SPADCALL |pp| (QREFELT $ 70))) 

(DEFUN |SUP;factorPolynomial;SupF;19| (|pp| $)
  (SPADCALL |pp| (QREFELT $ 76))) 

(DEFUN |SUP;factorSquareFreePolynomial;SupF;20| (|pp| $)
  (SPADCALL |pp| (QREFELT $ 76))) 

(DEFUN |SUP;gcdPolynomial;3Sup;21| (|pp| |qq| $)
  (SPADCALL |pp| |qq| (QREFELT $ 79))) 

(DEFUN |SUP;factor;$F;22| (|p| $) (SPADCALL |p| (QREFELT $ 83))) 

(DEFUN |SUP;solveLinearPolynomialEquation;LSupU;23| (|lpp| |pp| $)
  (SPADCALL |lpp| |pp| (QREFELT $ 89))) 

(DEFUN |SUP;solveLinearPolynomialEquation;LSupU;24| (|lpp| |pp| $)
  (SPADCALL |lpp| |pp| (QREFELT $ 94))) 

(DEFUN |SUP;factorPolynomial;SupF;25| (|pp| $)
  (SPADCALL |pp| (QREFELT $ 95))) 

(DEFUN |SUP;factorSquareFreePolynomial;SupF;26| (|pp| $)
  (SPADCALL |pp| (QREFELT $ 96))) 

(DEFUN |SUP;exquo;2$U;27| (|p1| |p2| $)
  (PROG (|a| |ee| #0=#:G1957 |rout|)
    (RETURN
      (SEQ (EXIT (COND
                   ((NULL |p2|) (|error| "Division by 0"))
                   ((SPADCALL |p2| (|spadConstant| $ 18)
                        (QREFELT $ 97))
                    (CONS 0 |p1|))
                   ((SPADCALL |p1| |p2| (QREFELT $ 97))
                    (CONS 0 (|spadConstant| $ 18)))
                   (#1='T
                    (SEQ (LETT |rout| NIL . #2=(|SUP;exquo;2$U;27|))
                         (SEQ G190
                              (COND
                                ((NULL (COND
                                         ((NULL |p1|) 'NIL)
                                         ('T 'T)))
                                 (GO G191)))
                              (SEQ (LETT |a|
                                    (SPADCALL (QCDR (|SPADfirst| |p1|))
                                     (QCDR (|SPADfirst| |p2|))
                                     (QREFELT $ 98)) . #2#)
                                   (EXIT
                                    (COND
                                      ((QEQCAR |a| 1)
                                       (PROGN
                                         (LETT #0#
                                          (CONS 1 "failed") . #2#)
                                         (GO #0#)))
                                      ('T
                                       (SEQ
                                        (LETT |ee|
                                         (SPADCALL
                                          (QCAR (|SPADfirst| |p1|))
                                          (QCAR (|SPADfirst| |p2|))
                                          (QREFELT $ 39)) . #2#)
                                        (EXIT
                                         (COND
                                           ((QEQCAR |ee| 1)
                                            (PROGN
                                              (LETT #0#
                                               (CONS 1 "failed") . #2#)
                                              (GO #0#)))
                                           ('T
                                            (SEQ
                                             (LETT |p1|
                                              (SPADCALL (CDR |p1|)
                                               (QCDR |ee|) (QCDR |a|)
                                               (CDR |p2|)
                                               (QREFELT $ 99)) . #2#)
                                             (EXIT
                                              (LETT |rout|
                                               (CONS
                                                (CONS (QCDR |ee|)
                                                 (QCDR |a|))
                                                |rout|) . #2#)))))))))))
                              NIL (GO G190) G191 (EXIT NIL))
                         (EXIT (COND
                                 ((NULL |p1|)
                                  (CONS 0 (REVERSE |rout|)))
                                 (#1# (CONS 1 "failed"))))))))
           #0# (EXIT #0#))))) 

(DEFUN |SUP;exquo;2$U;28| (|p1| |p2| $)
  (PROG (|a| |ee| #0=#:G1972 |rout|)
    (RETURN
      (SEQ (EXIT (COND
                   ((NULL |p2|) (|error| "Division by 0"))
                   ((SPADCALL |p2| (|spadConstant| $ 18)
                        (QREFELT $ 97))
                    (CONS 0 |p1|))
                   (#1='T
                    (SEQ (LETT |rout| NIL . #2=(|SUP;exquo;2$U;28|))
                         (SEQ G190
                              (COND
                                ((NULL (COND
                                         ((NULL |p1|) 'NIL)
                                         ('T 'T)))
                                 (GO G191)))
                              (SEQ (LETT |a|
                                    (SPADCALL (QCDR (|SPADfirst| |p1|))
                                     (QCDR (|SPADfirst| |p2|))
                                     (QREFELT $ 98)) . #2#)
                                   (EXIT
                                    (COND
                                      ((QEQCAR |a| 1)
                                       (PROGN
                                         (LETT #0#
                                          (CONS 1 "failed") . #2#)
                                         (GO #0#)))
                                      ('T
                                       (SEQ
                                        (LETT |ee|
                                         (SPADCALL
                                          (QCAR (|SPADfirst| |p1|))
                                          (QCAR (|SPADfirst| |p2|))
                                          (QREFELT $ 39)) . #2#)
                                        (EXIT
                                         (COND
                                           ((QEQCAR |ee| 1)
                                            (PROGN
                                              (LETT #0#
                                               (CONS 1 "failed") . #2#)
                                              (GO #0#)))
                                           ('T
                                            (SEQ
                                             (LETT |p1|
                                              (SPADCALL (CDR |p1|)
                                               (QCDR |ee|) (QCDR |a|)
                                               (CDR |p2|)
                                               (QREFELT $ 99)) . #2#)
                                             (EXIT
                                              (LETT |rout|
                                               (CONS
                                                (CONS (QCDR |ee|)
                                                 (QCDR |a|))
                                                |rout|) . #2#)))))))))))
                              NIL (GO G190) G191 (EXIT NIL))
                         (EXIT (COND
                                 ((NULL |p1|)
                                  (CONS 0 (REVERSE |rout|)))
                                 (#1# (CONS 1 "failed"))))))))
           #0# (EXIT #0#))))) 

(DEFUN |SUP;fmecg;$NniR2$;29| (|p1| |e| |r| |p2| $)
  (PROG (|tm| #0=#:G1982 |e2| |c2| |u| |rout|)
    (RETURN
      (SEQ (LETT |rout| NIL . #1=(|SUP;fmecg;$NniR2$;29|))
           (LETT |r| (SPADCALL |r| (QREFELT $ 101)) . #1#)
           (SEQ (LETT |tm| NIL . #1#) (LETT #0# |p2| . #1#) G190
                (COND
                  ((OR (ATOM #0#)
                       (PROGN (LETT |tm| (CAR #0#) . #1#) NIL))
                   #2=(GO G191)))
                (SEQ (LETT |e2| (+ |e| (QCAR |tm|)) . #1#)
                     (LETT |c2|
                           (SPADCALL |r| (QCDR |tm|) (QREFELT $ 44)) . #1#)
                     (EXIT (COND
                             ((SPADCALL |c2| (|spadConstant| $ 38)
                                  (QREFELT $ 31))
                              "next term")
                             ('T
                              (SEQ (SEQ G190
                                    (COND
                                      ((NULL
                                        (COND
                                          ((NULL |p1|) 'NIL)
                                          ('T
                                           (< |e2|
                                            (QCAR (|SPADfirst| |p1|))))))
                                       #2#))
                                    (SEQ
                                     (LETT |rout|
                                      (CONS (|SPADfirst| |p1|) |rout|) . #1#)
                                     (EXIT
                                      (LETT |p1| (CDR |p1|) . #1#)))
                                    NIL #3=(GO G190) G191 (EXIT NIL))
                                   (COND
                                     ((OR (NULL |p1|)
                                       (< (QCAR (|SPADfirst| |p1|))
                                        |e2|))
                                      (EXIT
                                       (LETT |rout|
                                        (CONS (CONS |e2| |c2|) |rout|) . #1#))))
                                   (SEQ
                                    (LETT |u|
                                     (SPADCALL
                                      (QCDR (|SPADfirst| |p1|)) |c2|
                                      (QREFELT $ 45)) . #1#)
                                    (EXIT
                                     (COND
                                       ((NULL
                                         (SPADCALL |u|
                                          (|spadConstant| $ 38)
                                          (QREFELT $ 31)))
                                        (LETT |rout|
                                         (CONS (CONS |e2| |u|) |rout|) . #1#)))))
                                   (EXIT (LETT |p1| (CDR |p1|) . #1#)))))))
                (LETT #0# (CDR #0#) . #1#) #3# G191 (EXIT NIL))
           (EXIT (NRECONC |rout| |p1|)))))) 

(DEFUN |SUP;pseudoRemainder;3$;30| (|p1| |p2| $)
  (PROG (|co| |e| #0=#:G1983 |u| #1=#:G1990 #2=#:G1988 |e1|)
    (RETURN
      (SEQ (COND
             ((NULL |p2|) (|error| "PseudoDivision by Zero"))
             ((NULL |p1|) (|spadConstant| $ 17))
             (#3='T
              (SEQ (LETT |co| (QCDR (|SPADfirst| |p2|))
                         . #4=(|SUP;pseudoRemainder;3$;30|))
                   (LETT |e| (QCAR (|SPADfirst| |p2|)) . #4#)
                   (LETT |p2| (CDR |p2|) . #4#)
                   (LETT |e1|
                         (PROG1 (LETT #0#
                                      (MAX
                                       (+
                                        (- (QCAR (|SPADfirst| |p1|))
                                         |e|)
                                        1)
                                       0) . #4#)
                           (|check-subtype| (>= #0# 0)
                               '(|NonNegativeInteger|) #0#)) . #4#)
                   (SEQ (EXIT (SEQ G190
                                   (COND
                                     ((NULL
                                       (COND
                                         ((NULL |p1|) 'NIL)
                                         ('T 'T)))
                                      (GO G191)))
                                   (SEQ
                                    (SEQ
                                     (LETT |u|
                                      (SPADCALL
                                       (QCAR (|SPADfirst| |p1|)) |e|
                                       (QREFELT $ 39)) . #4#)
                                     (EXIT
                                      (COND
                                        ((QEQCAR |u| 1)
                                         (PROGN
                                           (LETT #1# |$NoValue| . #4#)
                                           (GO #1#))))))
                                    (LETT |p1|
                                     (SPADCALL
                                      (SPADCALL |co| (CDR |p1|)
                                       (QREFELT $ 102))
                                      (QCDR |u|)
                                      (QCDR (|SPADfirst| |p1|)) |p2|
                                      (QREFELT $ 99)) . #4#)
                                    (EXIT
                                     (LETT |e1|
                                      (PROG1
                                       (LETT #2# (- |e1| 1) . #4#)
                                        (|check-subtype| (>= #2# 0)
                                         '(|NonNegativeInteger|) #2#)) . #4#)))
                                   NIL (GO G190) G191 (EXIT NIL)))
                        #1# (EXIT #1#))
                   (EXIT (COND
                           ((EQL |e1| 0) |p1|)
                           (#3#
                            (SPADCALL
                                (SPADCALL |co| |e1| (QREFELT $ 103))
                                |p1| (QREFELT $ 102)))))))))))) 

(DEFUN |SUP;toutput| (|t1| |v| $)
  (PROG (|mon|)
    (RETURN
      (SEQ (COND
             ((EQL (QCAR |t1|) 0)
              (SPADCALL (QCDR |t1|) (QREFELT $ 106)))
             ('T
              (SEQ (COND
                     ((EQL (QCAR |t1|) 1)
                      (LETT |mon| |v| . #0=(|SUP;toutput|)))
                     ('T
                      (LETT |mon|
                            (SPADCALL |v|
                                (SPADCALL (QCAR |t1|) (QREFELT $ 107))
                                (QREFELT $ 108)) . #0#)))
                   (EXIT (COND
                           ((SPADCALL (QCDR |t1|) (|spadConstant| $ 19)
                                (QREFELT $ 31))
                            |mon|)
                           ('T
                            (SEQ (COND
                                   ((SPADCALL (QCDR |t1|)
                                     (SPADCALL (|spadConstant| $ 19)
                                      (QREFELT $ 101))
                                     (QREFELT $ 31))
                                    (COND
                                      ((SPADCALL
                                        (SPADCALL (QCDR |t1|)
                                         (QREFELT $ 106))
                                        (SPADCALL -1 (QREFELT $ 109))
                                        (QREFELT $ 110))
                                       (EXIT
                                        (SPADCALL |mon|
                                         (QREFELT $ 111)))))))
                                 (EXIT (SPADCALL
                                        (SPADCALL (QCDR |t1|)
                                         (QREFELT $ 106))
                                        |mon| (QREFELT $ 112)))))))))))))) 

(DEFUN |SUP;outputForm;$2Of;32| (|p| |v| $)
  (PROG (#0=#:G2005 |t| #1=#:G2006 |l|)
    (RETURN
      (SEQ (LETT |l|
                 (PROGN
                   (LETT #0# NIL . #2=(|SUP;outputForm;$2Of;32|))
                   (SEQ (LETT |t| NIL . #2#) (LETT #1# |p| . #2#) G190
                        (COND
                          ((OR (ATOM #1#)
                               (PROGN (LETT |t| (CAR #1#) . #2#) NIL))
                           (GO G191)))
                        (SEQ (EXIT (LETT #0#
                                    (CONS (|SUP;toutput| |t| |v| $)
                                     #0#) . #2#)))
                        (LETT #1# (CDR #1#) . #2#) (GO G190) G191
                        (EXIT (NREVERSE0 #0#)))) . #2#)
           (EXIT (COND
                   ((NULL |l|) (SPADCALL 0 (QREFELT $ 109)))
                   ('T (SPADCALL (ELT $ 113) |l| (QREFELT $ 116))))))))) 

(DEFUN |SUP;coerce;$Of;33| (|p| $) (SPADCALL |p| "?" (QREFELT $ 117))) 

(DEFUN |SUP;elt;$2R;34| (|p| |val| $)
  (PROG (|tm| #0=#:G2013 |n| #1=#:G2009 |co|)
    (RETURN
      (SEQ (COND
             ((NULL |p|) (|spadConstant| $ 38))
             (#2='T
              (SEQ (LETT |co| (QCDR (|SPADfirst| |p|))
                         . #3=(|SUP;elt;$2R;34|))
                   (LETT |n| (QCAR (|SPADfirst| |p|)) . #3#)
                   (SEQ (LETT |tm| NIL . #3#)
                        (LETT #0# (CDR |p|) . #3#) G190
                        (COND
                          ((OR (ATOM #0#)
                               (PROGN (LETT |tm| (CAR #0#) . #3#) NIL))
                           (GO G191)))
                        (SEQ (EXIT (LETT |co|
                                    (SPADCALL
                                     (SPADCALL |co|
                                      (SPADCALL |val|
                                       (PROG1
                                        (LETT #1#
                                         (- |n|
                                          (LETT |n| (QCAR |tm|) . #3#)) . #3#)
                                         (|check-subtype| (>= #1# 0)
                                          '(|NonNegativeInteger|) #1#))
                                       (QREFELT $ 103))
                                      (QREFELT $ 44))
                                     (QCDR |tm|) (QREFELT $ 45)) . #3#)))
                        (LETT #0# (CDR #0#) . #3#) (GO G190) G191
                        (EXIT NIL))
                   (EXIT (COND
                           ((EQL |n| 0) |co|)
                           (#2#
                            (SPADCALL |co|
                                (SPADCALL |val| |n| (QREFELT $ 103))
                                (QREFELT $ 44)))))))))))) 

(DEFUN |SUP;elt;3$;35| (|p| |val| $)
  (PROG (|tm| #0=#:G2019 |n| #1=#:G2015 |coef|)
    (RETURN
      (SEQ (COND
             ((NULL |p|) (|spadConstant| $ 17))
             (#2='T
              (SEQ (LETT |coef|
                         (SPADCALL (QCDR (|SPADfirst| |p|))
                             (QREFELT $ 54))
                         . #3=(|SUP;elt;3$;35|))
                   (LETT |n| (QCAR (|SPADfirst| |p|)) . #3#)
                   (SEQ (LETT |tm| NIL . #3#)
                        (LETT #0# (CDR |p|) . #3#) G190
                        (COND
                          ((OR (ATOM #0#)
                               (PROGN (LETT |tm| (CAR #0#) . #3#) NIL))
                           (GO G191)))
                        (SEQ (EXIT (LETT |coef|
                                    (SPADCALL
                                     (SPADCALL |coef|
                                      (SPADCALL |val|
                                       (PROG1
                                        (LETT #1#
                                         (- |n|
                                          (LETT |n| (QCAR |tm|) . #3#)) . #3#)
                                         (|check-subtype| (>= #1# 0)
                                          '(|NonNegativeInteger|) #1#))
                                       (QREFELT $ 12))
                                      (QREFELT $ 27))
                                     (SPADCALL (QCDR |tm|)
                                      (QREFELT $ 54))
                                     (QREFELT $ 67)) . #3#)))
                        (LETT #0# (CDR #0#) . #3#) (GO G190) G191
                        (EXIT NIL))
                   (EXIT (COND
                           ((EQL |n| 0) |coef|)
                           (#2#
                            (SPADCALL |coef|
                                (SPADCALL |val| |n| (QREFELT $ 12))
                                (QREFELT $ 27)))))))))))) 

(DEFUN |SUP;monicDivide;2$R;36| (|p1| |p2| $)
  (PROG (|n| |u| #0=#:G2027 |rout|)
    (RETURN
      (SEQ (COND
             ((NULL |p2|) (|error| "monicDivide: division by 0"))
             ((NULL (SPADCALL (SPADCALL |p2| (QREFELT $ 53))
                        (|spadConstant| $ 19) (QREFELT $ 31)))
              (|error| "Divisor Not Monic"))
             ('T
              (COND
                ((SPADCALL |p2| (|spadConstant| $ 18) (QREFELT $ 97))
                 (CONS |p1| (|spadConstant| $ 17)))
                ((NULL |p1|)
                 (CONS (|spadConstant| $ 17) (|spadConstant| $ 17)))
                ('T
                 (COND
                   ((< (SPADCALL |p1| (QREFELT $ 55))
                       (LETT |n| (SPADCALL |p2| (QREFELT $ 55))
                             . #1=(|SUP;monicDivide;2$R;36|)))
                    (CONS (|spadConstant| $ 17) |p1|))
                   ('T
                    (SEQ (LETT |rout| NIL . #1#)
                         (LETT |p2| (CDR |p2|) . #1#)
                         (SEQ (EXIT (SEQ G190
                                     (COND
                                       ((NULL
                                         (COND
                                           ((NULL |p1|) 'NIL)
                                           ('T 'T)))
                                        (GO G191)))
                                     (SEQ
                                      (LETT |u|
                                       (SPADCALL
                                        (QCAR (|SPADfirst| |p1|)) |n|
                                        (QREFELT $ 39)) . #1#)
                                      (EXIT
                                       (COND
                                         ((QEQCAR |u| 1)
                                          (PROGN
                                            (LETT #0# |$NoValue| . #1#)
                                            (GO #0#)))
                                         ('T
                                          (SEQ
                                           (LETT |rout|
                                            (CONS
                                             (CONS (QCDR |u|)
                                              (QCDR (|SPADfirst| |p1|)))
                                             |rout|) . #1#)
                                           (EXIT
                                            (LETT |p1|
                                             (SPADCALL (CDR |p1|)
                                              (QCAR
                                               (|SPADfirst| |rout|))
                                              (QCDR
                                               (|SPADfirst| |rout|))
                                              |p2| (QREFELT $ 99)) . #1#)))))))
                                     NIL (GO G190) G191 (EXIT NIL)))
                              #0# (EXIT #0#))
                         (EXIT (CONS (NREVERSE |rout|) |p1|))))))))))))) 

(DEFUN |SUP;discriminant;$R;37| (|p| $)
  (SPADCALL |p| (QREFELT $ 123))) 

(DEFUN |SUP;subResultantGcd;3$;38| (|p1| |p2| $)
  (SPADCALL |p1| |p2| (QREFELT $ 125))) 

(DEFUN |SUP;resultant;2$R;39| (|p1| |p2| $)
  (SPADCALL |p1| |p2| (QREFELT $ 127))) 

(DEFUN |SUP;content;$R;40| (|p| $)
  (PROG (|tm| #0=#:G2039 #1=#:G2037 #2=#:G2035 #3=#:G2036)
    (RETURN
      (SEQ (COND
             ((NULL |p|) (|spadConstant| $ 38))
             (#4='T
              (PROGN
                (LETT #3# NIL . #5=(|SUP;content;$R;40|))
                (SEQ (LETT |tm| NIL . #5#) (LETT #0# |p| . #5#) G190
                     (COND
                       ((OR (ATOM #0#)
                            (PROGN (LETT |tm| (CAR #0#) . #5#) NIL))
                        (GO G191)))
                     (SEQ (EXIT (PROGN
                                  (LETT #1# (QCDR |tm|) . #5#)
                                  (COND
                                    (#3#
                                     (LETT #2#
                                      (SPADCALL #2# #1#
                                       (QREFELT $ 129)) . #5#))
                                    ('T
                                     (PROGN
                                       (LETT #2# #1# . #5#)
                                       (LETT #3# 'T . #5#)))))))
                     (LETT #0# (CDR #0#) . #5#) (GO G190) G191
                     (EXIT NIL))
                (COND (#3# #2#) (#4# (|spadConstant| $ 38)))))))))) 

(DEFUN |SUP;primitivePart;2$;41| (|p| $)
  (PROG (|ct| #0=#:G2041)
    (RETURN
      (SEQ (COND
             ((NULL |p|) |p|)
             ('T
              (SEQ (LETT |ct| (SPADCALL |p| (QREFELT $ 130))
                         . #1=(|SUP;primitivePart;2$;41|))
                   (EXIT (SPADCALL
                             (PROG2 (LETT #0#
                                     (SPADCALL |p| |ct|
                                      (QREFELT $ 131)) . #1#)
                                    (QCDR #0#)
                               (|check-union| (QEQCAR #0# 0) $ #0#))
                             (QREFELT $ 132)))))))))) 

(DEFUN |SUP;gcd;3$;42| (|p1| |p2| $)
  (SPADCALL |p1| |p2| (QREFELT $ 134))) 

(DEFUN |SUP;divide;2$R;43| (|p1| |p2| $)
  (PROG (|ct| |n| |u| #0=#:G2052 |rout|)
    (RETURN
      (SEQ (COND
             ((SPADCALL |p2| (QREFELT $ 30)) (|error| "Division by 0"))
             ((SPADCALL |p2| (|spadConstant| $ 18) (QREFELT $ 97))
              (CONS |p1| (|spadConstant| $ 17)))
             ('T
              (SEQ (LETT |ct|
                         (SPADCALL (QCDR (|SPADfirst| |p2|))
                             (QREFELT $ 136))
                         . #1=(|SUP;divide;2$R;43|))
                   (LETT |n| (QCAR (|SPADfirst| |p2|)) . #1#)
                   (LETT |p2| (CDR |p2|) . #1#) (LETT |rout| NIL . #1#)
                   (SEQ (EXIT (SEQ G190
                                   (COND
                                     ((NULL
                                       (COND
                                         ((SPADCALL |p1|
                                           (|spadConstant| $ 17)
                                           (QREFELT $ 97))
                                          'NIL)
                                         ('T 'T)))
                                      (GO G191)))
                                   (SEQ
                                    (LETT |u|
                                     (SPADCALL
                                      (QCAR (|SPADfirst| |p1|)) |n|
                                      (QREFELT $ 39)) . #1#)
                                    (EXIT
                                     (COND
                                       ((QEQCAR |u| 1)
                                        (PROGN
                                          (LETT #0# |$NoValue| . #1#)
                                          (GO #0#)))
                                       ('T
                                        (SEQ
                                         (LETT |rout|
                                          (CONS
                                           (CONS (QCDR |u|)
                                            (SPADCALL |ct|
                                             (QCDR (|SPADfirst| |p1|))
                                             (QREFELT $ 44)))
                                           |rout|) . #1#)
                                         (EXIT
                                          (LETT |p1|
                                           (SPADCALL (CDR |p1|)
                                            (QCAR (|SPADfirst| |rout|))
                                            (QCDR (|SPADfirst| |rout|))
                                            |p2| (QREFELT $ 99)) . #1#)))))))
                                   NIL (GO G190) G191 (EXIT NIL)))
                        #0# (EXIT #0#))
                   (EXIT (CONS (NREVERSE |rout|) |p1|))))))))) 

(DEFUN |SUP;/;$R$;44| (|p| |co| $)
  (SPADCALL (SPADCALL |co| (QREFELT $ 136)) |p| (QREFELT $ 102))) 

(DEFUN |SparseUnivariatePolynomial| (#0=#:G2096)
  (PROG ()
    (RETURN
      (PROG (#1=#:G2097)
        (RETURN
          (COND
            ((LETT #1#
                   (|lassocShiftWithFunction| (LIST (|devaluate| #0#))
                       (HGET |$ConstructorCache|
                             '|SparseUnivariatePolynomial|)
                       '|domainEqualList|)
                   . #2=(|SparseUnivariatePolynomial|))
             (|CDRwithIncrement| #1#))
            ('T
             (UNWIND-PROTECT
               (PROG1 (|SparseUnivariatePolynomial;| #0#)
                 (LETT #1# T . #2#))
               (COND
                 ((NOT #1#)
                  (HREM |$ConstructorCache|
                        '|SparseUnivariatePolynomial|))))))))))) 

(DEFUN |SparseUnivariatePolynomial;| (|#1|)
  (PROG (DV$1 |dv$| $ #0=#:G2095 |pv$|)
    (RETURN
      (PROGN
        (LETT DV$1 (|devaluate| |#1|)
              . #1=(|SparseUnivariatePolynomial|))
        (LETT |dv$| (LIST '|SparseUnivariatePolynomial| DV$1) . #1#)
        (LETT $ (GETREFV 181) . #1#)
        (QSETREFV $ 0 |dv$|)
        (QSETREFV $ 3
            (LETT |pv$|
                  (|buildPredVector| 0 0
                      (LIST (|HasCategory| |#1|
                                '(|PolynomialFactorizationExplicit|))
                            (|HasCategory| |#1| '(|CommutativeRing|))
                            (|HasCategory| |#1| '(|IntegralDomain|))
                            (OR (|HasCategory| |#1|
                                    '(|CommutativeRing|))
                                (|HasCategory| |#1|
                                    '(|IntegralDomain|)))
                            (|HasCategory| |#1|
                                '(|canonicalUnitNormal|))
                            (AND (|HasCategory|
                                     (|SingletonAsOrderedSet|)
                                     '(|PatternMatchable| (|Float|)))
                                 (|HasCategory| |#1|
                                     '(|PatternMatchable| (|Float|))))
                            (AND (|HasCategory|
                                     (|SingletonAsOrderedSet|)
                                     '(|PatternMatchable| (|Integer|)))
                                 (|HasCategory| |#1|
                                     '(|PatternMatchable| (|Integer|))))
                            (AND (|HasCategory|
                                     (|SingletonAsOrderedSet|)
                                     '(|ConvertibleTo|
                                       (|Pattern| (|Float|))))
                                 (|HasCategory| |#1|
                                     '(|ConvertibleTo|
                                       (|Pattern| (|Float|)))))
                            (AND (|HasCategory|
                                     (|SingletonAsOrderedSet|)
                                     '(|ConvertibleTo|
                                       (|Pattern| (|Integer|))))
                                 (|HasCategory| |#1|
                                     '(|ConvertibleTo|
                                       (|Pattern| (|Integer|)))))
                            (AND (|HasCategory|
                                     (|SingletonAsOrderedSet|)
                                     '(|ConvertibleTo| (|InputForm|)))
                                 (|HasCategory| |#1|
                                     '(|ConvertibleTo| (|InputForm|))))
                            (|HasCategory| |#1| '(|OrderedSet|))
                            (|HasCategory| |#1|
                                '(|LinearlyExplicitRingOver|
                                     (|Integer|)))
                            (|HasCategory| |#1|
                                '(|Algebra| (|Fraction| (|Integer|))))
                            (|HasCategory| |#1|
                                '(|CharacteristicNonZero|))
                            (|HasCategory| |#1|
                                '(|CharacteristicZero|))
                            (|HasCategory| |#1|
                                '(|RetractableTo| (|Integer|)))
                            (|HasCategory| |#1|
                                '(|RetractableTo|
                                     (|Fraction| (|Integer|))))
                            (|HasCategory| |#1| '(|Field|))
                            (|HasCategory| |#1| '(|StepThrough|))
                            (|HasCategory| |#1|
                                '(|PartialDifferentialRing| (|Symbol|)))
                            (OR (|HasCategory| |#1|
                                    '(|Algebra|
                                      (|Fraction| (|Integer|))))
                                (|HasCategory| |#1|
                                    '(|RetractableTo|
                                      (|Fraction| (|Integer|)))))
                            (|HasCategory| |#1| '(|DifferentialRing|))
                            (LETT #0#
                                  (|HasCategory| |#1| '(|GcdDomain|)) . #1#)
                            (OR (|HasCategory| |#1|
                                    '(|CommutativeRing|))
                                (|HasCategory| |#1| '(|Field|)) #0#
                                (|HasCategory| |#1|
                                    '(|IntegralDomain|))
                                (|HasCategory| |#1|
                                    '(|PolynomialFactorizationExplicit|)))
                            (OR (|HasCategory| |#1| '(|Field|)) #0#
                                (|HasCategory| |#1|
                                    '(|IntegralDomain|))
                                (|HasCategory| |#1|
                                    '(|PolynomialFactorizationExplicit|)))
                            (OR (|HasCategory| |#1| '(|Field|)) #0#
                                (|HasCategory| |#1|
                                    '(|PolynomialFactorizationExplicit|))))) . #1#))
        (|haddProp| |$ConstructorCache| '|SparseUnivariatePolynomial|
            (LIST DV$1) (CONS 1 $))
        (|stuffDomainSlots| $)
        (QSETREFV $ 6 |#1|)
        (AND (|HasCategory| $ '(|CharacteristicNonZero|))
             (|HasCategory| |#1| '(|PolynomialFactorizationExplicit|))
             (|augmentPredVector| $ 67108864))
        (AND (OR (AND (|HasCategory| $ '(|CharacteristicNonZero|))
                      (|HasCategory| |#1|
                          '(|PolynomialFactorizationExplicit|)))
                 (|HasCategory| |#1| '(|CharacteristicNonZero|)))
             (|augmentPredVector| $ 134217728))
        (QSETREFV $ 7
            (|Record| (|:| |k| (|NonNegativeInteger|)) (|:| |c| |#1|)))
        (QSETREFV $ 8 (|List| (QREFELT $ 7)))
        (QSETREFV $ 9 63)
        (QSETREFV $ 10
            (|UnivariatePolynomialMultiplicationPackage| |#1| $))
        (COND
          ((|HasCategory| |#1| '(|FieldOfPrimeCharacteristic|))
           (PROGN
             (QSETREFV $ 14
                 (CONS (|dispatchFunction| |SUP;**;$Pi$;1|) $))
             (QSETREFV $ 15
                 (CONS (|dispatchFunction| |SUP;^;$Pi$;2|) $))
             (QSETREFV $ 16
                 (CONS (|dispatchFunction| |SUP;^;$Nni$;3|) $))
             (QSETREFV $ 12
                 (CONS (|dispatchFunction| |SUP;**;$Nni$;4|) $)))))
        (COND
          ((|HasCategory| |#1| '(|FiniteFieldCategory|))
           (COND
             ((|testBitVector| |pv$| 1)
              (PROGN
                (QSETREFV $ 72
                    (CONS (|dispatchFunction|
                              |SUP;squareFreePolynomial;SupF;18|)
                          $))
                (QSETREFV $ 77
                    (CONS (|dispatchFunction|
                              |SUP;factorPolynomial;SupF;19|)
                          $))
                (QSETREFV $ 78
                    (CONS (|dispatchFunction|
                              |SUP;factorSquareFreePolynomial;SupF;20|)
                          $))
                (QSETREFV $ 80
                    (CONS (|dispatchFunction|
                              |SUP;gcdPolynomial;3Sup;21|)
                          $))
                (QSETREFV $ 85
                    (CONS (|dispatchFunction| |SUP;factor;$F;22|) $))
                (QSETREFV $ 92
                    (CONS (|dispatchFunction|
                              |SUP;solveLinearPolynomialEquation;LSupU;23|)
                          $))))))
          ((|testBitVector| |pv$| 1)
           (PROGN
             (QSETREFV $ 92
                 (CONS (|dispatchFunction|
                           |SUP;solveLinearPolynomialEquation;LSupU;24|)
                       $))
             (QSETREFV $ 77
                 (CONS (|dispatchFunction|
                           |SUP;factorPolynomial;SupF;25|)
                       $))
             (QSETREFV $ 78
                 (CONS (|dispatchFunction|
                           |SUP;factorSquareFreePolynomial;SupF;26|)
                       $)))))
        (COND
          ((|testBitVector| |pv$| 3)
           (COND
             ((|HasCategory| |#1| '(|Approximate|))
              (QSETREFV $ 100
                  (CONS (|dispatchFunction| |SUP;exquo;2$U;27|) $)))
             ('T
              (QSETREFV $ 100
                  (CONS (|dispatchFunction| |SUP;exquo;2$U;28|) $))))))
        (COND
          ((|testBitVector| |pv$| 3)
           (PROGN
             (QSETREFV $ 124
                 (CONS (|dispatchFunction| |SUP;discriminant;$R;37|) $))
             (QSETREFV $ 126
                 (CONS (|dispatchFunction| |SUP;subResultantGcd;3$;38|)
                       $))
             (QSETREFV $ 128
                 (CONS (|dispatchFunction| |SUP;resultant;2$R;39|) $)))))
        (COND
          ((|testBitVector| |pv$| 23)
           (PROGN
             (QSETREFV $ 130
                 (CONS (|dispatchFunction| |SUP;content;$R;40|) $))
             (QSETREFV $ 133
                 (CONS (|dispatchFunction| |SUP;primitivePart;2$;41|)
                       $))
             (QSETREFV $ 135
                 (CONS (|dispatchFunction| |SUP;gcd;3$;42|) $)))))
        (COND
          ((|testBitVector| |pv$| 18)
           (PROGN
             (QSETREFV $ 137
                 (CONS (|dispatchFunction| |SUP;divide;2$R;43|) $))
             (QSETREFV $ 138
                 (CONS (|dispatchFunction| |SUP;/;$R$;44|) $)))))
        $)))) 

(MAKEPROP '|SparseUnivariatePolynomial| '|infovec|
    (LIST '#(NIL NIL NIL NIL NIL (|PolynomialRing| 6 11) (|local| |#1|)
             '|Term| '|Rep| '|kBound| '|upmp| (|NonNegativeInteger|)
             (0 . **) (|PositiveInteger|) (6 . **) (12 . ^) (18 . ^)
             (24 . |Zero|) (28 . |One|) (32 . |One|) (|Integer|)
             (36 . **) (|Boolean|) (42 . |zero?|)
             (47 . |characteristic|) (|RepeatedSquaring| $$)
             (51 . |expt|) (57 . *) (63 . |binomThmExpt|)
             (70 . |primeFrobenius|) |SUP;zero?;$B;5| (75 . =)
             |SUP;one?;$B;6| |SUP;ground?;$B;7|
             |SUP;multiplyExponents;$Nni$;8| (|Union| $ '"failed")
             (81 . |exquo|) |SUP;divideExponents;$NniU;9| (87 . |Zero|)
             (91 . |subtractIfCan|)
             (|Record| (|:| |quotient| $) (|:| |remainder| $))
             |SUP;karatsubaDivide;$NniR;10| |SUP;shiftRight;$Nni$;11|
             |SUP;shiftLeft;$Nni$;12| (97 . *) (103 . +)
             |SUP;pomopo!;$RNni2$;13| (|SparseUnivariatePolynomial| 6)
             |SUP;univariate;2$;14| (|SingletonAsOrderedSet|)
             |SUP;multivariate;$Saos$;15|
             (|SparseUnivariatePolynomial| $$) (109 . |Zero|)
             (113 . |leadingCoefficient|) (118 . |coerce|)
             (123 . |degree|) (128 . |monomial|) (134 . |reductum|)
             (|SparseUnivariatePolynomial| $)
             |SUP;univariate;$SaosSup;16| (139 . +) (145 . |zero?|)
             (150 . |leadingCoefficient|) (155 . |degree|)
             (160 . |monomial|) (166 . |reductum|)
             |SUP;multivariate;SupSaos$;17| (171 . +) (|Factored| 51)
             (|UnivariatePolynomialSquareFree| $$ 51)
             (177 . |squareFree|) (|Factored| 58)
             (182 . |squareFreePolynomial|) (|Factored| 74)
             (|SparseUnivariatePolynomial| 47) (|TwoFactorize| 6)
             (187 . |generalTwoFactor|) (192 . |factorPolynomial|)
             (197 . |factorSquareFreePolynomial|) (202 . |gcd|)
             (208 . |gcdPolynomial|) (|Factored| $$)
             (|DistinctDegreeFactorize| 6 $$) (214 . |factor|)
             (|Factored| $) (219 . |factor|) (|Union| 87 '"failed")
             (|List| 51)
             (|FiniteFieldSolveLinearPolynomialEquation| 6 $$ 51)
             (224 . |solveLinearPolynomialEquation|)
             (|Union| 91 '"failed") (|List| 58)
             (230 . |solveLinearPolynomialEquation|)
             (|PolynomialFactorizationByRecursionUnivariate| 6 $$)
             (236 . |solveLinearPolynomialEquationByRecursion|)
             (242 . |factorByRecursion|)
             (247 . |factorSquareFreeByRecursion|) (252 . =)
             (258 . |exquo|) |SUP;fmecg;$NniR2$;29| (264 . |exquo|)
             (270 . -) (275 . *) (281 . **) |SUP;pseudoRemainder;3$;30|
             (|OutputForm|) (287 . |coerce|) (292 . |coerce|)
             (297 . **) (303 . |coerce|) (308 . =) (314 . -) (319 . *)
             (325 . +) (|Mapping| 105 105 105) (|List| 105)
             (331 . |reduce|) |SUP;outputForm;$2Of;32|
             |SUP;coerce;$Of;33| |SUP;elt;$2R;34| |SUP;elt;3$;35|
             |SUP;monicDivide;2$R;36| (|PseudoRemainderSequence| 6 $$)
             (337 . |discriminant|) (342 . |discriminant|)
             (347 . |subResultantGcd|) (353 . |subResultantGcd|)
             (359 . |resultant|) (365 . |resultant|) (371 . |gcd|)
             (377 . |content|) (382 . |exquo|) (388 . |unitCanonical|)
             (393 . |primitivePart|) (398 . |gcdPolynomial|)
             (404 . |gcd|) (410 . |inv|) (415 . |divide|) (421 . /)
             (|InputForm|) (|Pattern| (|Float|)) (|Pattern| 20)
             (|PatternMatchResult| (|Float|) $)
             (|PatternMatchResult| 20 $) (|Union| 159 '"failed")
             (|Matrix| $) (|Fraction| 20)
             (|Record| (|:| |coef| 148) (|:| |generator| $)) (|List| $)
             (|Union| 148 '"failed")
             (|Record| (|:| |coef1| $) (|:| |coef2| $)
                 (|:| |generator| $))
             (|Record| (|:| |coef1| $) (|:| |coef2| $))
             (|Union| 151 '"failed") (|Fraction| $)
             (|Record| (|:| |primePart| $) (|:| |commonPart| $))
             (|Record| (|:| |unit| $) (|:| |canonical| $)
                 (|:| |associate| $))
             (|Record| (|:| |coef| 6) (|:| |quotient| $)
                 (|:| |remainder| $))
             (|Union| 153 '"failed")
             (|Record| (|:| |mat| 160) (|:| |vec| (|Vector| 20)))
             (|Vector| $) (|Matrix| 20) (|List| 163) (|List| 11)
             (|Symbol|) (|Union| 146 '"failed") (|Union| 20 '"failed")
             (|Mapping| 6 6) (|Vector| 6) (|List| 49)
             (|Record| (|:| |var| 49) (|:| |exponent| 11))
             (|Union| 169 '"failed") (|Union| 49 '"failed")
             (|Matrix| 6) (|Record| (|:| |mat| 172) (|:| |vec| 167))
             (|List| 6) (|List| 176) (|Equation| $)
             (|Union| 6 '"failed") (|Mapping| 11 11) (|String|)
             (|SingleInteger|))
          '#(~= 427 |zero?| 433 |vectorise| 438 |variables| 444
             |unmakeSUP| 449 |univariate| 454 |unitNormal| 465
             |unitCanonical| 470 |unit?| 475 |totalDegree| 480
             |subtractIfCan| 491 |subResultantGcd| 497
             |squareFreePolynomial| 503 |squareFreePart| 508
             |squareFree| 513 |solveLinearPolynomialEquation| 518
             |sizeLess?| 524 |shiftRight| 530 |shiftLeft| 536
             |separate| 542 |sample| 548 |retractIfCan| 552 |retract|
             572 |resultant| 592 |rem| 605 |reductum| 611
             |reducedSystem| 616 |recip| 638 |quo| 643
             |pseudoRemainder| 649 |pseudoQuotient| 655 |pseudoDivide|
             661 |principalIdeal| 667 |primitivePart| 672
             |primitiveMonomials| 683 |prime?| 688 |pomopo!| 693
             |patternMatch| 701 |outputForm| 715 |order| 721 |one?| 727
             |numberOfMonomials| 732 |nextItem| 737 |multivariate| 742
             |multiplyExponents| 754 |multiEuclidean| 760 |monomials|
             766 |monomial?| 771 |monomial| 776 |monicDivide| 796
             |minimumDegree| 809 |min| 826 |max| 832 |mapExponents| 838
             |map| 844 |makeSUP| 850 |mainVariable| 855
             |leadingMonomial| 860 |leadingCoefficient| 865 |lcm| 870
             |latex| 881 |karatsubaDivide| 886 |isTimes| 892 |isPlus|
             897 |isExpt| 902 |integrate| 907 |init| 912 |hash| 916
             |ground?| 921 |ground| 926 |gcdPolynomial| 931 |gcd| 937
             |fmecg| 948 |factorSquareFreePolynomial| 956
             |factorPolynomial| 961 |factor| 966 |extendedEuclidean|
             971 |exquo| 984 |expressIdealMember| 996 |eval| 1002
             |euclideanSize| 1056 |elt| 1061 |divideExponents| 1091
             |divide| 1097 |discriminant| 1103 |differentiate| 1114
             |degree| 1197 |convert| 1214 |content| 1229 |conditionP|
             1240 |composite| 1245 |coerce| 1257 |coefficients| 1287
             |coefficient| 1292 |charthRoot| 1312 |characteristic| 1317
             |binomThmExpt| 1321 |associates?| 1328 ^ 1334 |Zero| 1346
             |One| 1350 D 1354 >= 1430 > 1436 = 1442 <= 1448 < 1454 /
             1460 - 1466 + 1477 ** 1483 * 1495)
          'NIL
          (CONS (|makeByteWordVec2| 26
                    '(0 0 1 18 0 1 18 0 26 25 0 0 3 13 2 0 0 0 3 3 12
                      13 14 15 2 24 20 0 0 4 13 0 0 0 0 2 13 13 0 0 0 0
                      0 0 0 0 6 7 11 19 0 0 0 0 0 0 0 0 0 0 0 0 0 2 3 5
                      8 9 10 16 17 18 3))
                (CONS '#(|UnivariatePolynomialCategory&|
                         |PolynomialCategory&|
                         |PolynomialFactorizationExplicit&|
                         |EuclideanDomain&| |FiniteAbelianMonoidRing&|
                         |UniqueFactorizationDomain&| NIL
                         |AbelianMonoidRing&| |GcdDomain&|
                         |IntegralDomain&| |DifferentialExtension&|
                         |FullyLinearlyExplicitRingOver&| |Algebra&|
                         |Algebra&| |Algebra&|
                         |PartialDifferentialRing&| |DifferentialRing&|
                         NIL |Module&| NIL NIL |Module&| NIL NIL
                         |Module&| NIL |PartialDifferentialRing&| NIL
                         |Ring&| NIL NIL NIL NIL NIL NIL NIL NIL NIL
                         |AbelianGroup&| NIL NIL |AbelianMonoid&|
                         |Monoid&| NIL |SemiGroup&| |AbelianSemiGroup&|
                         NIL NIL |OrderedSet&| NIL |Evalable&|
                         |FullyRetractableTo&| |SetCategory&| NIL NIL
                         |RetractableTo&| |InnerEvalable&|
                         |InnerEvalable&| |InnerEvalable&|
                         |RetractableTo&| NIL |BasicType&| NIL NIL NIL
                         NIL NIL NIL NIL |RetractableTo&|
                         |RetractableTo&| NIL NIL)
                      (CONS '#((|UnivariatePolynomialCategory| 6)
                               (|PolynomialCategory| 6 11 49)
                               (|PolynomialFactorizationExplicit|)
                               (|EuclideanDomain|)
                               (|FiniteAbelianMonoidRing| 6 11)
                               (|UniqueFactorizationDomain|)
                               (|PrincipalIdealDomain|)
                               (|AbelianMonoidRing| 6 11) (|GcdDomain|)
                               (|IntegralDomain|)
                               (|DifferentialExtension| 6)
                               (|FullyLinearlyExplicitRingOver| 6)
                               (|Algebra| $$) (|Algebra| 146)
                               (|Algebra| 6)
                               (|PartialDifferentialRing| 49)
                               (|DifferentialRing|)
                               (|LinearlyExplicitRingOver| 6)
                               (|Module| $$) (|EntireRing|)
                               (|LinearlyExplicitRingOver| 20)
                               (|Module| 146) (|CharacteristicNonZero|)
                               (|CharacteristicZero|) (|Module| 6)
                               (|CommutativeRing|)
                               (|PartialDifferentialRing| 163)
                               (|BiModule| 6 6) (|Ring|)
                               (|BiModule| $$ $$) (|BiModule| 146 146)
                               (|LeftModule| 6) (|Rng|)
                               (|RightModule| 6) (|LeftModule| $$)
                               (|RightModule| $$) (|LeftModule| 146)
                               (|RightModule| 146) (|AbelianGroup|)
                               (|CancellationAbelianMonoid|)
                               (|SemiRing|) (|AbelianMonoid|)
                               (|Monoid|) (|SemiRng|) (|SemiGroup|)
                               (|AbelianSemiGroup|)
                               (|PatternMatchable| (|Float|))
                               (|PatternMatchable| 20) (|OrderedSet|)
                               (|StepThrough|) (|Evalable| $$)
                               (|FullyRetractableTo| 6) (|SetCategory|)
                               (|Eltable| $$ $$) (|Eltable| 6 6)
                               (|RetractableTo| 49)
                               (|InnerEvalable| 49 $$)
                               (|InnerEvalable| 49 6)
                               (|InnerEvalable| $$ $$)
                               (|RetractableTo| 6) (|unitsKnown|)
                               (|BasicType|) (|CoercibleTo| 105)
                               (|CommutativeStar|) (|noZeroDivisors|)
                               (|canonicalUnitNormal|)
                               (|ConvertibleTo| 140)
                               (|ConvertibleTo| 141)
                               (|ConvertibleTo| 139)
                               (|RetractableTo| 20)
                               (|RetractableTo| 146)
                               (|additiveValuation|)
                               (|Eltable| (|Fraction| $$)
                                   (|Fraction| $$)))
                            (|makeByteWordVec2| 180
                                '(2 0 0 0 11 12 2 0 0 0 13 14 2 0 0 0
                                  13 15 2 0 0 0 11 16 0 0 0 17 0 0 0 18
                                  0 6 0 19 2 6 0 0 20 21 1 6 22 0 23 0
                                  6 11 24 2 25 2 2 13 26 2 0 0 0 0 27 3
                                  0 0 0 0 11 28 1 6 0 0 29 2 6 22 0 0
                                  31 2 20 35 0 0 36 0 6 0 38 2 11 35 0
                                  0 39 2 6 0 0 0 44 2 6 0 0 0 45 0 51 0
                                  52 1 0 6 0 53 1 0 0 6 54 1 0 11 0 55
                                  2 51 0 2 11 56 1 0 0 0 57 2 51 0 0 0
                                  60 1 51 22 0 61 1 51 2 0 62 1 51 11 0
                                  63 2 0 0 6 11 64 1 51 0 0 65 2 0 0 0
                                  0 67 1 69 68 51 70 1 0 71 58 72 1 75
                                  73 74 76 1 0 71 58 77 1 0 71 58 78 2
                                  51 0 0 0 79 2 0 58 58 58 80 1 82 81 2
                                  83 1 0 84 0 85 2 88 86 87 51 89 2 0
                                  90 91 58 92 2 93 86 87 51 94 1 93 68
                                  51 95 1 93 68 51 96 2 0 22 0 0 97 2 6
                                  35 0 0 98 2 0 35 0 0 100 1 6 0 0 101
                                  2 0 0 6 0 102 2 6 0 0 11 103 1 6 105
                                  0 106 1 11 105 0 107 2 105 0 0 0 108
                                  1 20 105 0 109 2 105 22 0 0 110 1 105
                                  0 0 111 2 105 0 0 0 112 2 105 0 0 0
                                  113 2 115 105 114 0 116 1 122 6 2 123
                                  1 0 6 0 124 2 122 2 2 2 125 2 0 0 0 0
                                  126 2 122 6 2 2 127 2 0 6 0 0 128 2 6
                                  0 0 0 129 1 0 6 0 130 2 0 35 0 6 131
                                  1 0 0 0 132 1 0 0 0 133 2 6 58 58 58
                                  134 2 0 0 0 0 135 1 6 0 0 136 2 0 40
                                  0 0 137 2 0 0 0 6 138 2 0 22 0 0 1 1
                                  0 22 0 30 2 0 167 0 11 1 1 0 168 0 1
                                  1 0 0 47 1 1 0 47 0 48 2 0 58 0 49 59
                                  1 3 155 0 1 1 3 0 0 132 1 3 22 0 1 1
                                  0 11 0 1 2 0 11 0 168 1 2 0 35 0 0 1
                                  2 3 0 0 0 126 1 1 71 58 72 1 23 0 0 1
                                  1 23 84 0 1 2 1 90 91 58 92 2 18 22 0
                                  0 1 2 0 0 0 11 42 2 0 0 0 11 43 2 23
                                  154 0 0 1 0 0 0 1 1 17 164 0 1 1 16
                                  165 0 1 1 0 171 0 1 1 0 177 0 1 1 17
                                  146 0 1 1 16 20 0 1 1 0 49 0 1 1 0 6
                                  0 1 2 2 6 0 0 128 3 2 0 0 0 49 1 2 18
                                  0 0 0 1 1 0 0 0 57 2 12 158 145 159 1
                                  1 12 160 145 1 1 0 172 145 1 2 0 173
                                  145 159 1 1 0 35 0 1 2 18 0 0 0 1 2 0
                                  0 0 0 104 2 3 0 0 0 1 2 3 156 0 0 1 1
                                  18 147 148 1 2 23 0 0 49 1 1 23 0 0
                                  133 1 0 148 0 1 1 1 22 0 1 4 0 0 0 6
                                  11 0 46 3 6 142 0 140 142 1 3 7 143 0
                                  141 143 1 2 0 105 0 105 117 2 3 11 0
                                  0 1 1 0 22 0 32 1 0 11 0 1 1 19 35 0
                                  1 2 0 0 58 49 66 2 0 0 47 49 50 2 0 0
                                  0 11 34 2 18 149 148 0 1 1 0 148 0 1
                                  1 0 22 0 1 3 0 0 0 168 162 1 3 0 0 0
                                  49 11 1 2 0 0 6 11 64 2 0 40 0 0 121
                                  3 0 40 0 0 49 1 2 0 162 0 168 1 2 0
                                  11 0 49 1 1 0 11 0 1 2 11 0 0 0 1 2
                                  11 0 0 0 1 2 0 0 178 0 1 2 0 0 166 0
                                  1 1 0 47 0 1 1 0 171 0 1 1 0 0 0 1 1
                                  0 6 0 53 2 23 0 0 0 1 1 23 0 148 1 1
                                  0 179 0 1 2 0 40 0 11 41 1 0 149 0 1
                                  1 0 149 0 1 1 0 170 0 1 1 13 0 0 1 0
                                  19 0 1 1 0 180 0 1 1 0 22 0 33 1 0 6
                                  0 1 2 23 58 58 58 80 2 23 0 0 0 135 1
                                  23 0 148 1 4 0 0 0 11 6 0 99 1 1 71
                                  58 78 1 1 71 58 77 1 1 84 0 85 2 18
                                  150 0 0 1 3 18 152 0 0 0 1 2 3 35 0 0
                                  100 2 3 35 0 6 131 2 18 149 148 0 1 3
                                  0 0 0 49 0 1 3 0 0 0 168 148 1 3 0 0
                                  0 168 174 1 3 0 0 0 148 148 1 3 0 0 0
                                  49 6 1 3 0 0 0 0 0 1 2 0 0 0 175 1 2
                                  0 0 0 176 1 1 18 11 0 1 2 18 6 153 6
                                  1 2 3 153 0 153 1 2 3 153 153 153 1 2
                                  0 0 0 0 120 2 0 6 0 6 119 2 0 35 0 11
                                  37 2 18 40 0 0 137 1 2 6 0 124 2 2 0
                                  0 49 1 3 20 0 0 163 11 1 3 20 0 0 161
                                  162 1 2 20 0 0 161 1 2 20 0 0 163 1 3
                                  0 0 0 166 0 1 2 0 0 0 166 1 3 0 0 0
                                  166 11 1 1 0 0 0 1 2 0 0 0 11 1 3 0 0
                                  0 168 162 1 3 0 0 0 49 11 1 2 0 0 0
                                  49 1 2 0 0 0 168 1 2 0 11 0 49 1 2 0
                                  162 0 168 1 1 0 11 0 55 1 10 139 0 1
                                  1 8 140 0 1 1 9 141 0 1 2 23 0 0 49 1
                                  1 23 6 0 130 1 27 144 145 1 2 3 157
                                  153 0 1 2 3 35 0 0 1 1 21 0 146 1 1 3
                                  0 0 1 1 0 0 49 1 1 0 0 6 54 1 0 0 20
                                  1 1 0 105 0 118 1 0 174 0 1 3 0 0 0
                                  168 162 1 3 0 0 0 49 11 1 2 0 6 0 11
                                  1 1 28 35 0 1 0 0 11 1 3 2 0 0 0 11
                                  28 2 3 22 0 0 1 2 0 0 0 11 16 2 0 0 0
                                  13 15 0 0 0 17 0 0 0 18 3 20 0 0 161
                                  162 1 2 20 0 0 161 1 3 20 0 0 163 11
                                  1 2 20 0 0 163 1 3 0 0 0 166 11 1 2 0
                                  0 0 166 1 1 0 0 0 1 2 0 0 0 11 1 3 0
                                  0 0 49 11 1 3 0 0 0 168 162 1 2 0 0 0
                                  168 1 2 0 0 0 49 1 2 11 22 0 0 1 2 11
                                  22 0 0 1 2 0 22 0 0 97 2 11 22 0 0 1
                                  2 11 22 0 0 1 2 18 0 0 6 138 2 0 0 0
                                  0 1 1 0 0 0 1 2 0 0 0 0 67 2 0 0 0 11
                                  12 2 0 0 0 13 14 2 13 0 146 0 1 2 13
                                  0 0 146 1 2 0 0 0 6 1 2 0 0 6 0 102 2
                                  0 0 0 0 27 2 0 0 20 0 1 2 0 0 11 0 1
                                  2 0 0 13 0 1)))))
          '|lookupComplete|)) 
