
(/VERSIONCHECK 2) 

(DEFUN |POLYCAT-;eval;SLS;1| (|p| |l| $)
  (PROG (#0=#:G1853 #1=#:G1847 #2=#:G1854 #3=#:G1855 |lvar| #4=#:G1856
            |e| #5=#:G1857)
    (RETURN
      (SEQ (COND
             ((NULL |l|) |p|)
             ('T
              (SEQ (SEQ (EXIT (SEQ (LETT |e| NIL
                                    . #6=(|POLYCAT-;eval;SLS;1|))
                                   (LETT #0# |l| . #6#) G190
                                   (COND
                                     ((OR (ATOM #0#)
                                       (PROGN
                                         (LETT |e| (CAR #0#) . #6#)
                                         NIL))
                                      #7=(GO G191)))
                                   (SEQ
                                    (EXIT
                                     (COND
                                       ((QEQCAR
                                         (SPADCALL
                                          (SPADCALL |e| (QREFELT $ 11))
                                          (QREFELT $ 13))
                                         1)
                                        (PROGN
                                          (LETT #1#
                                           (|error|
                                            "cannot find a variable to evaluate") . #6#)
                                          (GO #1#))))))
                                   (LETT #0# (CDR #0#) . #6#)
                                   #8=(GO G190) G191 (EXIT NIL)))
                        #1# (EXIT #1#))
                   (LETT |lvar|
                         (PROGN
                           (LETT #2# NIL . #6#)
                           (SEQ (LETT |e| NIL . #6#)
                                (LETT #3# |l| . #6#) G190
                                (COND
                                  ((OR (ATOM #3#)
                                    (PROGN
                                      (LETT |e| (CAR #3#) . #6#)
                                      NIL))
                                   #7#))
                                (SEQ (EXIT
                                      (LETT #2#
                                       (CONS
                                        (SPADCALL
                                         (SPADCALL |e| (QREFELT $ 11))
                                         (QREFELT $ 14))
                                        #2#) . #6#)))
                                (LETT #3# (CDR #3#) . #6#) #8# G191
                                (EXIT (NREVERSE0 #2#)))) . #6#)
                   (EXIT (SPADCALL |p| |lvar|
                             (PROGN
                               (LETT #4# NIL . #6#)
                               (SEQ (LETT |e| NIL . #6#)
                                    (LETT #5# |l| . #6#) G190
                                    (COND
                                      ((OR (ATOM #5#)
                                        (PROGN
                                          (LETT |e| (CAR #5#) . #6#)
                                          NIL))
                                       #7#))
                                    (SEQ
                                     (EXIT
                                      (LETT #4#
                                       (CONS
                                        (SPADCALL |e| (QREFELT $ 15))
                                        #4#) . #6#)))
                                    (LETT #5# (CDR #5#) . #6#) #8# G191
                                    (EXIT (NREVERSE0 #4#))))
                             (QREFELT $ 18)))))))))) 

(DEFUN |POLYCAT-;monomials;SL;2| (|p| $)
  (PROG (|ml|)
    (RETURN
      (SEQ (LETT |ml| NIL . #0=(|POLYCAT-;monomials;SL;2|))
           (SEQ G190
                (COND
                  ((NULL (COND
                           ((SPADCALL |p| (|spadConstant| $ 21)
                                (QREFELT $ 24))
                            'NIL)
                           ('T 'T)))
                   (GO G191)))
                (SEQ (LETT |ml|
                           (CONS (SPADCALL |p| (QREFELT $ 25)) |ml|) . #0#)
                     (EXIT (LETT |p|
                                 (SPADCALL |p| (QREFELT $ 26)) . #0#)))
                NIL (GO G190) G191 (EXIT NIL))
           (EXIT (REVERSE |ml|)))))) 

(DEFUN |POLYCAT-;isPlus;SU;3| (|p| $)
  (PROG (|l|)
    (RETURN
      (COND
        ((NULL (CDR (LETT |l| (SPADCALL |p| (QREFELT $ 28))
                          |POLYCAT-;isPlus;SU;3|)))
         (CONS 1 "failed"))
        ('T (CONS 0 |l|)))))) 

(DEFUN |POLYCAT-;isTimes;SU;4| (|p| $)
  (PROG (|lv| #0=#:G1879 |v| #1=#:G1880 |l| |r|)
    (RETURN
      (SEQ (COND
             ((OR (NULL (LETT |lv| (SPADCALL |p| (QREFELT $ 31))
                              . #2=(|POLYCAT-;isTimes;SU;4|)))
                  (NULL (SPADCALL |p| (QREFELT $ 32))))
              (CONS 1 "failed"))
             ('T
              (SEQ (LETT |l|
                         (PROGN
                           (LETT #0# NIL . #2#)
                           (SEQ (LETT |v| NIL . #2#)
                                (LETT #1# |lv| . #2#) G190
                                (COND
                                  ((OR (ATOM #1#)
                                    (PROGN
                                      (LETT |v| (CAR #1#) . #2#)
                                      NIL))
                                   (GO G191)))
                                (SEQ (EXIT
                                      (LETT #0#
                                       (CONS
                                        (SPADCALL (|spadConstant| $ 33)
                                         |v|
                                         (SPADCALL |p| |v|
                                          (QREFELT $ 36))
                                         (QREFELT $ 37))
                                        #0#) . #2#)))
                                (LETT #1# (CDR #1#) . #2#) (GO G190)
                                G191 (EXIT (NREVERSE0 #0#)))) . #2#)
                   (LETT |r| (SPADCALL |p| (QREFELT $ 38)) . #2#)
                   (EXIT (COND
                           ((SPADCALL |r| (|spadConstant| $ 34)
                                      (QREFELT $ 39))
                            (COND
                              ((NULL (CDR |lv|)) (CONS 1 "failed"))
                              ('T (CONS 0 |l|))))
                           ('T
                            (CONS 0
                                  (CONS (SPADCALL |r| (QREFELT $ 40))
                                        |l|)))))))))))) 

(DEFUN |POLYCAT-;isExpt;SU;5| (|p| $)
  (PROG (|u| |d|)
    (RETURN
      (SEQ (LETT |u| (SPADCALL |p| (QREFELT $ 42))
                 . #0=(|POLYCAT-;isExpt;SU;5|))
           (EXIT (COND
                   ((OR (QEQCAR |u| 1)
                        (NULL (SPADCALL |p|
                                  (SPADCALL (|spadConstant| $ 33)
                                      (QCDR |u|)
                                      (LETT |d|
                                       (SPADCALL |p| (QCDR |u|)
                                        (QREFELT $ 36)) . #0#)
                                      (QREFELT $ 37))
                                  (QREFELT $ 24))))
                    (CONS 1 "failed"))
                   ('T (CONS 0 (CONS (QCDR |u|) |d|))))))))) 

(DEFUN |POLYCAT-;coefficient;SVarSetNniS;6| (|p| |v| |n| $)
  (SPADCALL (SPADCALL |p| |v| (QREFELT $ 47)) |n| (QREFELT $ 49))) 

(DEFUN |POLYCAT-;coefficient;SLLS;7| (|p| |lv| |ln| $)
  (COND
    ((NULL |lv|)
     (COND
       ((NULL |ln|) |p|)
       ('T (|error| "mismatched lists in coefficient"))))
    ((NULL |ln|) (|error| "mismatched lists in coefficient"))
    ('T
     (SPADCALL
         (SPADCALL (SPADCALL |p| (|SPADfirst| |lv|) (QREFELT $ 47))
             (|SPADfirst| |ln|) (QREFELT $ 49))
         (CDR |lv|) (CDR |ln|) (QREFELT $ 52))))) 

(DEFUN |POLYCAT-;monomial;SLLS;8| (|p| |lv| |ln| $)
  (COND
    ((NULL |lv|)
     (COND
       ((NULL |ln|) |p|)
       ('T (|error| "mismatched lists in monomial"))))
    ((NULL |ln|) (|error| "mismatched lists in monomial"))
    ('T
     (SPADCALL
         (SPADCALL |p| (|SPADfirst| |lv|) (|SPADfirst| |ln|)
             (QREFELT $ 37))
         (CDR |lv|) (CDR |ln|) (QREFELT $ 54))))) 

(DEFUN |POLYCAT-;retract;SVarSet;9| (|p| $)
  (PROG (#0=#:G1905 |q|)
    (RETURN
      (SEQ (LETT |q|
                 (PROG2 (LETT #0# (SPADCALL |p| (QREFELT $ 42))
                              . #1=(|POLYCAT-;retract;SVarSet;9|))
                        (QCDR #0#)
                   (|check-union| (QEQCAR #0# 0) (QREFELT $ 9) #0#)) . #1#)
           (EXIT (COND
                   ((SPADCALL (SPADCALL |q| (QREFELT $ 56)) |p|
                        (QREFELT $ 24))
                    |q|)
                   ('T (|error| "Polynomial is not a single variable")))))))) 

(DEFUN |POLYCAT-;retractIfCan;SU;10| (|p| $)
  (PROG (|q| #0=#:G1913)
    (RETURN
      (SEQ (EXIT (SEQ (SEQ (LETT |q| (SPADCALL |p| (QREFELT $ 42))
                                 . #1=(|POLYCAT-;retractIfCan;SU;10|))
                           (EXIT (COND
                                   ((QEQCAR |q| 0)
                                    (COND
                                      ((SPADCALL
                                        (SPADCALL (QCDR |q|)
                                         (QREFELT $ 56))
                                        |p| (QREFELT $ 24))
                                       (PROGN
                                         (LETT #0# |q| . #1#)
                                         (GO #0#))))))))
                      (EXIT (CONS 1 "failed"))))
           #0# (EXIT #0#))))) 

(DEFUN |POLYCAT-;mkPrim| (|p| $)
  (SPADCALL (|spadConstant| $ 34) (SPADCALL |p| (QREFELT $ 59))
      (QREFELT $ 60))) 

(DEFUN |POLYCAT-;primitiveMonomials;SL;12| (|p| $)
  (PROG (#0=#:G1918 |q| #1=#:G1919)
    (RETURN
      (SEQ (PROGN
             (LETT #0# NIL . #2=(|POLYCAT-;primitiveMonomials;SL;12|))
             (SEQ (LETT |q| NIL . #2#)
                  (LETT #1# (SPADCALL |p| (QREFELT $ 28)) . #2#) G190
                  (COND
                    ((OR (ATOM #1#)
                         (PROGN (LETT |q| (CAR #1#) . #2#) NIL))
                     (GO G191)))
                  (SEQ (EXIT (LETT #0#
                                   (CONS (|POLYCAT-;mkPrim| |q| $) #0#) . #2#)))
                  (LETT #1# (CDR #1#) . #2#) (GO G190) G191
                  (EXIT (NREVERSE0 #0#)))))))) 

(DEFUN |POLYCAT-;totalDegree;SNni;13| (|p| $)
  (PROG (#0=#:G1921 |d| |u|)
    (RETURN
      (SEQ (COND
             ((SPADCALL |p| (QREFELT $ 62)) 0)
             ('T
              (SEQ (LETT |u|
                         (SPADCALL |p|
                             (PROG2 (LETT #0#
                                     (SPADCALL |p| (QREFELT $ 42))
                                     . #1=(|POLYCAT-;totalDegree;SNni;13|))
                                    (QCDR #0#)
                               (|check-union| (QEQCAR #0# 0)
                                   (QREFELT $ 9) #0#))
                             (QREFELT $ 47)) . #1#)
                   (LETT |d| 0 . #1#)
                   (SEQ G190
                        (COND
                          ((NULL (COND
                                   ((SPADCALL |u| (|spadConstant| $ 63)
                                     (QREFELT $ 64))
                                    'NIL)
                                   ('T 'T)))
                           (GO G191)))
                        (SEQ (LETT |d|
                                   (MAX |d|
                                    (+ (SPADCALL |u| (QREFELT $ 65))
                                     (SPADCALL
                                      (SPADCALL |u| (QREFELT $ 66))
                                      (QREFELT $ 67)))) . #1#)
                             (EXIT (LETT |u|
                                    (SPADCALL |u| (QREFELT $ 68)) . #1#)))
                        NIL (GO G190) G191 (EXIT NIL))
                   (EXIT |d|)))))))) 

(DEFUN |POLYCAT-;totalDegree;SLNni;14| (|p| |lv| $)
  (PROG (#0=#:G1929 |v| |w| |d| |u|)
    (RETURN
      (SEQ (COND
             ((SPADCALL |p| (QREFELT $ 62)) 0)
             ('T
              (SEQ (LETT |u|
                         (SPADCALL |p|
                             (LETT |v|
                                   (PROG2
                                    (LETT #0#
                                     (SPADCALL |p| (QREFELT $ 42))
                                     . #1=(|POLYCAT-;totalDegree;SLNni;14|))
                                    (QCDR #0#)
                                     (|check-union| (QEQCAR #0# 0)
                                      (QREFELT $ 9) #0#)) . #1#)
                             (QREFELT $ 47)) . #1#)
                   (LETT |d| 0 . #1#) (LETT |w| 0 . #1#)
                   (COND
                     ((SPADCALL |v| |lv| (QREFELT $ 70))
                      (LETT |w| 1 . #1#)))
                   (SEQ G190
                        (COND
                          ((NULL (COND
                                   ((SPADCALL |u| (|spadConstant| $ 63)
                                     (QREFELT $ 64))
                                    'NIL)
                                   ('T 'T)))
                           (GO G191)))
                        (SEQ (LETT |d|
                                   (MAX |d|
                                    (+
                                     (* |w|
                                      (SPADCALL |u| (QREFELT $ 65)))
                                     (SPADCALL
                                      (SPADCALL |u| (QREFELT $ 66))
                                      |lv| (QREFELT $ 71)))) . #1#)
                             (EXIT (LETT |u|
                                    (SPADCALL |u| (QREFELT $ 68)) . #1#)))
                        NIL (GO G190) G191 (EXIT NIL))
                   (EXIT |d|)))))))) 

(DEFUN |POLYCAT-;resultant;2SVarSetS;15| (|p1| |p2| |mvar| $)
  (SPADCALL (SPADCALL |p1| |mvar| (QREFELT $ 47))
      (SPADCALL |p2| |mvar| (QREFELT $ 47)) (QREFELT $ 73))) 

(DEFUN |POLYCAT-;discriminant;SVarSetS;16| (|p| |var| $)
  (SPADCALL (SPADCALL |p| |var| (QREFELT $ 47)) (QREFELT $ 75))) 

(DEFUN |POLYCAT-;allMonoms| (|l| $)
  (PROG (#0=#:G1941 |p| #1=#:G1942)
    (RETURN
      (SEQ (SPADCALL
               (SPADCALL
                   (PROGN
                     (LETT #0# NIL . #2=(|POLYCAT-;allMonoms|))
                     (SEQ (LETT |p| NIL . #2#) (LETT #1# |l| . #2#)
                          G190
                          (COND
                            ((OR (ATOM #1#)
                                 (PROGN
                                   (LETT |p| (CAR #1#) . #2#)
                                   NIL))
                             (GO G191)))
                          (SEQ (EXIT (LETT #0#
                                      (CONS
                                       (SPADCALL |p| (QREFELT $ 77))
                                       #0#) . #2#)))
                          (LETT #1# (CDR #1#) . #2#) (GO G190) G191
                          (EXIT (NREVERSE0 #0#))))
                   (QREFELT $ 79))
               (QREFELT $ 80)))))) 

(DEFUN |POLYCAT-;P2R| (|p| |b| |n| $)
  (PROG (|w| |bj| #0=#:G1947 |i| #1=#:G1946)
    (RETURN
      (SEQ (LETT |w|
                 (SPADCALL |n| (|spadConstant| $ 22) (QREFELT $ 82))
                 . #2=(|POLYCAT-;P2R|))
           (SEQ (LETT |bj| NIL . #2#) (LETT #0# |b| . #2#)
                (LETT |i| (SPADCALL |w| (QREFELT $ 84)) . #2#)
                (LETT #1# (QVSIZE |w|) . #2#) G190
                (COND
                  ((OR (> |i| #1#) (ATOM #0#)
                       (PROGN (LETT |bj| (CAR #0#) . #2#) NIL))
                   (GO G191)))
                (SEQ (EXIT (SPADCALL |w| |i|
                               (SPADCALL |p| |bj| (QREFELT $ 85))
                               (QREFELT $ 86))))
                (LETT |i|
                      (PROG1 (+ |i| 1) (LETT #0# (CDR #0#) . #2#)) . #2#)
                (GO G190) G191 (EXIT NIL))
           (EXIT |w|))))) 

(DEFUN |POLYCAT-;eq2R| (|l| |b| $)
  (PROG (#0=#:G1951 |bj| #1=#:G1952 #2=#:G1953 |p| #3=#:G1954)
    (RETURN
      (SEQ (SPADCALL
               (PROGN
                 (LETT #0# NIL . #4=(|POLYCAT-;eq2R|))
                 (SEQ (LETT |bj| NIL . #4#) (LETT #1# |b| . #4#) G190
                      (COND
                        ((OR (ATOM #1#)
                             (PROGN (LETT |bj| (CAR #1#) . #4#) NIL))
                         #5=(GO G191)))
                      (SEQ (EXIT (LETT #0#
                                       (CONS
                                        (PROGN
                                          (LETT #2# NIL . #4#)
                                          (SEQ (LETT |p| NIL . #4#)
                                           (LETT #3# |l| . #4#) G190
                                           (COND
                                             ((OR (ATOM #3#)
                                               (PROGN
                                                 (LETT |p|
                                                  (CAR #3#) . #4#)
                                                 NIL))
                                              #5#))
                                           (SEQ
                                            (EXIT
                                             (LETT #2#
                                              (CONS
                                               (SPADCALL |p| |bj|
                                                (QREFELT $ 85))
                                               #2#) . #4#)))
                                           (LETT #3# (CDR #3#) . #4#)
                                           #6=(GO G190) G191
                                           (EXIT (NREVERSE0 #2#))))
                                        #0#) . #4#)))
                      (LETT #1# (CDR #1#) . #4#) #6# G191
                      (EXIT (NREVERSE0 #0#))))
               (QREFELT $ 89)))))) 

(DEFUN |POLYCAT-;reducedSystem;MM;20| (|m| $)
  (PROG (#0=#:G1964 |r| #1=#:G1965 |b| #2=#:G1966 |bj| #3=#:G1967 |d|
            |mm| |l|)
    (RETURN
      (SEQ (LETT |l| (SPADCALL |m| (QREFELT $ 92))
                 . #4=(|POLYCAT-;reducedSystem;MM;20|))
           (LETT |b|
                 (SPADCALL
                     (SPADCALL
                         (PROGN
                           (LETT #0# NIL . #4#)
                           (SEQ (LETT |r| NIL . #4#)
                                (LETT #1# |l| . #4#) G190
                                (COND
                                  ((OR (ATOM #1#)
                                    (PROGN
                                      (LETT |r| (CAR #1#) . #4#)
                                      NIL))
                                   #5=(GO G191)))
                                (SEQ (EXIT
                                      (LETT #0#
                                       (CONS
                                        (|POLYCAT-;allMonoms| |r| $)
                                        #0#) . #4#)))
                                (LETT #1# (CDR #1#) . #4#) #6=(GO G190)
                                G191 (EXIT (NREVERSE0 #0#))))
                         (QREFELT $ 79))
                     (QREFELT $ 80)) . #4#)
           (LETT |d|
                 (PROGN
                   (LETT #2# NIL . #4#)
                   (SEQ (LETT |bj| NIL . #4#) (LETT #3# |b| . #4#) G190
                        (COND
                          ((OR (ATOM #3#)
                               (PROGN (LETT |bj| (CAR #3#) . #4#) NIL))
                           #5#))
                        (SEQ (EXIT (LETT #2#
                                    (CONS
                                     (SPADCALL |bj| (QREFELT $ 59))
                                     #2#) . #4#)))
                        (LETT #3# (CDR #3#) . #4#) #6# G191
                        (EXIT (NREVERSE0 #2#)))) . #4#)
           (LETT |mm| (|POLYCAT-;eq2R| (|SPADfirst| |l|) |d| $) . #4#)
           (LETT |l| (CDR |l|) . #4#)
           (SEQ G190
                (COND ((NULL (COND ((NULL |l|) 'NIL) ('T 'T))) #5#))
                (SEQ (LETT |mm|
                           (SPADCALL |mm|
                               (|POLYCAT-;eq2R| (|SPADfirst| |l|) |d|
                                   $)
                               (QREFELT $ 93)) . #4#)
                     (EXIT (LETT |l| (CDR |l|) . #4#)))
                NIL #6# G191 (EXIT NIL))
           (EXIT |mm|))))) 

(DEFUN |POLYCAT-;reducedSystem;MVR;21| (|m| |v| $)
  (PROG (#0=#:G1979 |s| #1=#:G1980 |b| #2=#:G1981 |bj| #3=#:G1982 |d|
            |n| |mm| |w| |l| |r|)
    (RETURN
      (SEQ (LETT |l| (SPADCALL |m| (QREFELT $ 92))
                 . #4=(|POLYCAT-;reducedSystem;MVR;21|))
           (LETT |r| (SPADCALL |v| (QREFELT $ 97)) . #4#)
           (LETT |b|
                 (SPADCALL
                     (SPADCALL (|POLYCAT-;allMonoms| |r| $)
                         (SPADCALL
                             (PROGN
                               (LETT #0# NIL . #4#)
                               (SEQ (LETT |s| NIL . #4#)
                                    (LETT #1# |l| . #4#) G190
                                    (COND
                                      ((OR (ATOM #1#)
                                        (PROGN
                                          (LETT |s| (CAR #1#) . #4#)
                                          NIL))
                                       #5=(GO G191)))
                                    (SEQ
                                     (EXIT
                                      (LETT #0#
                                       (CONS
                                        (|POLYCAT-;allMonoms| |s| $)
                                        #0#) . #4#)))
                                    (LETT #1# (CDR #1#) . #4#)
                                    #6=(GO G190) G191
                                    (EXIT (NREVERSE0 #0#))))
                             (QREFELT $ 79))
                         (QREFELT $ 98))
                     (QREFELT $ 80)) . #4#)
           (LETT |d|
                 (PROGN
                   (LETT #2# NIL . #4#)
                   (SEQ (LETT |bj| NIL . #4#) (LETT #3# |b| . #4#) G190
                        (COND
                          ((OR (ATOM #3#)
                               (PROGN (LETT |bj| (CAR #3#) . #4#) NIL))
                           #5#))
                        (SEQ (EXIT (LETT #2#
                                    (CONS
                                     (SPADCALL |bj| (QREFELT $ 59))
                                     #2#) . #4#)))
                        (LETT #3# (CDR #3#) . #4#) #6# G191
                        (EXIT (NREVERSE0 #2#)))) . #4#)
           (LETT |n| (LENGTH |d|) . #4#)
           (LETT |mm| (|POLYCAT-;eq2R| (|SPADfirst| |l|) |d| $) . #4#)
           (LETT |w|
                 (|POLYCAT-;P2R| (|SPADfirst| |r|) |d| |n| $) . #4#)
           (LETT |l| (CDR |l|) . #4#) (LETT |r| (CDR |r|) . #4#)
           (SEQ G190
                (COND ((NULL (COND ((NULL |l|) 'NIL) ('T 'T))) #5#))
                (SEQ (LETT |mm|
                           (SPADCALL |mm|
                               (|POLYCAT-;eq2R| (|SPADfirst| |l|) |d|
                                   $)
                               (QREFELT $ 93)) . #4#)
                     (LETT |w|
                           (SPADCALL |w|
                               (|POLYCAT-;P2R| (|SPADfirst| |r|) |d|
                                   |n| $)
                               (QREFELT $ 99)) . #4#)
                     (LETT |l| (CDR |l|) . #4#)
                     (EXIT (LETT |r| (CDR |r|) . #4#)))
                NIL #6# G191 (EXIT NIL))
           (EXIT (CONS |mm| |w|)))))) 

(DEFUN |POLYCAT-;gcdPolynomial;3Sup;22| (|pp| |qq| $)
  (SPADCALL |pp| |qq| (QREFELT $ 104))) 

(DEFUN |POLYCAT-;solveLinearPolynomialEquation;LSupU;23| (|lpp| |pp| $)
  (SPADCALL |lpp| |pp| (QREFELT $ 109))) 

(DEFUN |POLYCAT-;factorPolynomial;SupF;24| (|pp| $)
  (SPADCALL |pp| (QREFELT $ 114))) 

(DEFUN |POLYCAT-;factorSquareFreePolynomial;SupF;25| (|pp| $)
  (SPADCALL |pp| (QREFELT $ 117))) 

(DEFUN |POLYCAT-;factor;SF;26| (|p| $)
  (PROG (|v| |ansR| #0=#:G2024 |w| #1=#:G2025 |up| |ansSUP| #2=#:G2026
             |ww| #3=#:G2027)
    (RETURN
      (SEQ (LETT |v| (SPADCALL |p| (QREFELT $ 42))
                 . #4=(|POLYCAT-;factor;SF;26|))
           (EXIT (COND
                   ((QEQCAR |v| 1)
                    (SEQ (LETT |ansR|
                               (SPADCALL (SPADCALL |p| (QREFELT $ 38))
                                   (QREFELT $ 120)) . #4#)
                         (EXIT (SPADCALL
                                   (SPADCALL
                                    (SPADCALL |ansR| (QREFELT $ 122))
                                    (QREFELT $ 40))
                                   (PROGN
                                     (LETT #0# NIL . #4#)
                                     (SEQ (LETT |w| NIL . #4#)
                                      (LETT #1#
                                       (SPADCALL |ansR|
                                        (QREFELT $ 126)) . #4#)
                                      G190
                                      (COND
                                        ((OR (ATOM #1#)
                                          (PROGN
                                            (LETT |w| (CAR #1#) . #4#)
                                            NIL))
                                         #5=(GO G191)))
                                      (SEQ
                                       (EXIT
                                        (LETT #0#
                                         (CONS
                                          (VECTOR (QVELT |w| 0)
                                           (SPADCALL (QVELT |w| 1)
                                            (QREFELT $ 40))
                                           (QVELT |w| 2))
                                          #0#) . #4#)))
                                      (LETT #1# (CDR #1#) . #4#)
                                      #6=(GO G190) G191
                                      (EXIT (NREVERSE0 #0#))))
                                   (QREFELT $ 130)))))
                   ('T
                    (SEQ (LETT |up|
                               (SPADCALL |p| (QCDR |v|) (QREFELT $ 47)) . #4#)
                         (LETT |ansSUP|
                               (SPADCALL |up| (QREFELT $ 114)) . #4#)
                         (EXIT (SPADCALL
                                   (SPADCALL
                                    (SPADCALL |ansSUP| (QREFELT $ 131))
                                    (QCDR |v|) (QREFELT $ 132))
                                   (PROGN
                                     (LETT #2# NIL . #4#)
                                     (SEQ (LETT |ww| NIL . #4#)
                                      (LETT #3#
                                       (SPADCALL |ansSUP|
                                        (QREFELT $ 135)) . #4#)
                                      G190
                                      (COND
                                        ((OR (ATOM #3#)
                                          (PROGN
                                            (LETT |ww| (CAR #3#) . #4#)
                                            NIL))
                                         #5#))
                                      (SEQ
                                       (EXIT
                                        (LETT #2#
                                         (CONS
                                          (VECTOR (QVELT |ww| 0)
                                           (SPADCALL (QVELT |ww| 1)
                                            (QCDR |v|) (QREFELT $ 132))
                                           (QVELT |ww| 2))
                                          #2#) . #4#)))
                                      (LETT #3# (CDR #3#) . #4#) #6#
                                      G191 (EXIT (NREVERSE0 #2#))))
                                   (QREFELT $ 130))))))))))) 

(DEFUN |POLYCAT-;conditionP;MU;27| (|mat| $)
  (PROG (|ll| #0=#:G2062 |z| #1=#:G2063 |ch| |l| #2=#:G2064 #3=#:G2065
              #4=#:G2034 #5=#:G2032 #6=#:G2033 #7=#:G2066 |vars| |degs|
              #8=#:G2067 |d| #9=#:G2068 |nd| #10=#:G2061 #11=#:G2041
              |deg1| |redmons| #12=#:G2069 |v| #13=#:G2071 |u|
              #14=#:G2070 |llR| |monslist| |ans| #15=#:G2072
              #16=#:G2073 |mons| #17=#:G2074 |m| #18=#:G2075 |i|
              #19=#:G2057 #20=#:G2055 #21=#:G2056)
    (RETURN
      (SEQ (EXIT (SEQ (LETT |ll|
                            (SPADCALL (SPADCALL |mat| (QREFELT $ 137))
                                (QREFELT $ 92))
                            . #22=(|POLYCAT-;conditionP;MU;27|))
                      (LETT |llR|
                            (PROGN
                              (LETT #0# NIL . #22#)
                              (SEQ (LETT |z| NIL . #22#)
                                   (LETT #1# (|SPADfirst| |ll|) . #22#)
                                   G190
                                   (COND
                                     ((OR (ATOM #1#)
                                       (PROGN
                                         (LETT |z| (CAR #1#) . #22#)
                                         NIL))
                                      #23=(GO G191)))
                                   (SEQ
                                    (EXIT
                                     (LETT #0# (CONS NIL #0#) . #22#)))
                                   (LETT #1# (CDR #1#) . #22#)
                                   #24=(GO G190) G191
                                   (EXIT (NREVERSE0 #0#)))) . #22#)
                      (LETT |monslist| NIL . #22#)
                      (LETT |ch| (SPADCALL (QREFELT $ 138)) . #22#)
                      (SEQ (LETT |l| NIL . #22#) (LETT #2# |ll| . #22#)
                           G190
                           (COND
                             ((OR (ATOM #2#)
                                  (PROGN
                                    (LETT |l| (CAR #2#) . #22#)
                                    NIL))
                              #23#))
                           (SEQ (LETT |mons|
                                      (PROGN
                                        (LETT #6# NIL . #22#)
                                        (SEQ (LETT |u| NIL . #22#)
                                         (LETT #3# |l| . #22#) G190
                                         (COND
                                           ((OR (ATOM #3#)
                                             (PROGN
                                               (LETT |u|
                                                (CAR #3#) . #22#)
                                               NIL))
                                            #23#))
                                         (SEQ
                                          (EXIT
                                           (PROGN
                                             (LETT #4#
                                              (SPADCALL |u|
                                               (QREFELT $ 77)) . #22#)
                                             (COND
                                               (#6#
                                                (LETT #5#
                                                 (SPADCALL #5# #4#
                                                  (QREFELT $ 139)) . #22#))
                                               ('T
                                                (PROGN
                                                  (LETT #5# #4# . #22#)
                                                  (LETT #6# 'T . #22#)))))))
                                         (LETT #3# (CDR #3#) . #22#)
                                         #24# G191 (EXIT NIL))
                                        (COND
                                          (#6# #5#)
                                          ('T
                                           (|IdentityError|
                                            '|setUnion|)))) . #22#)
                                (LETT |redmons| NIL . #22#)
                                (SEQ (LETT |m| NIL . #22#)
                                     (LETT #7# |mons| . #22#) G190
                                     (COND
                                       ((OR (ATOM #7#)
                                         (PROGN
                                           (LETT |m| (CAR #7#) . #22#)
                                           NIL))
                                        #23#))
                                     (SEQ
                                      (LETT |vars|
                                       (SPADCALL |m| (QREFELT $ 31)) . #22#)
                                      (LETT |degs|
                                       (SPADCALL |m| |vars|
                                        (QREFELT $ 140)) . #22#)
                                      (LETT |deg1|
                                       (PROGN
                                         (LETT #8# NIL . #22#)
                                         (SEQ (LETT |d| NIL . #22#)
                                          (LETT #9# |degs| . #22#) G190
                                          (COND
                                            ((OR (ATOM #9#)
                                              (PROGN
                                                (LETT |d|
                                                 (CAR #9#) . #22#)
                                                NIL))
                                             #23#))
                                          (SEQ
                                           (EXIT
                                            (LETT #8#
                                             (CONS
                                              (SEQ
                                               (LETT |nd|
                                                (SPADCALL |d| |ch|
                                                 (QREFELT $ 142)) . #22#)
                                               (EXIT
                                                (COND
                                                  ((QEQCAR |nd| 1)
                                                   (PROGN
                                                     (LETT #10#
                                                      (CONS 1 "failed") . #22#)
                                                     (GO #10#)))
                                                  ('T
                                                   (PROG1
                                                    (LETT #11#
                                                     (QCDR |nd|) . #22#)
                                                     (|check-subtype|
                                                      (>= #11# 0)
                                                      '(|NonNegativeInteger|)
                                                      #11#))))))
                                              #8#) . #22#)))
                                          (LETT #9# (CDR #9#) . #22#)
                                          #24# G191
                                          (EXIT (NREVERSE0 #8#)))) . #22#)
                                      (LETT |redmons|
                                       (CONS
                                        (SPADCALL (|spadConstant| $ 33)
                                         |vars| |deg1| (QREFELT $ 54))
                                        |redmons|) . #22#)
                                      (EXIT
                                       (LETT |llR|
                                        (PROGN
                                          (LETT #12# NIL . #22#)
                                          (SEQ (LETT |v| NIL . #22#)
                                           (LETT #13# |llR| . #22#)
                                           (LETT |u| NIL . #22#)
                                           (LETT #14# |l| . #22#) G190
                                           (COND
                                             ((OR (ATOM #14#)
                                               (PROGN
                                                 (LETT |u|
                                                  (CAR #14#) . #22#)
                                                 NIL)
                                               (ATOM #13#)
                                               (PROGN
                                                 (LETT |v|
                                                  (CAR #13#) . #22#)
                                                 NIL))
                                              #23#))
                                           (SEQ
                                            (EXIT
                                             (LETT #12#
                                              (CONS
                                               (CONS
                                                (SPADCALL
                                                 (SPADCALL |u| |vars|
                                                  |degs|
                                                  (QREFELT $ 52))
                                                 (QREFELT $ 143))
                                                |v|)
                                               #12#) . #22#)))
                                           (LETT #14#
                                            (PROG1 (CDR #14#)
                                              (LETT #13#
                                               (CDR #13#) . #22#)) . #22#)
                                           #24# G191
                                           (EXIT (NREVERSE0 #12#)))) . #22#)))
                                     (LETT #7# (CDR #7#) . #22#) #24#
                                     G191 (EXIT NIL))
                                (EXIT (LETT |monslist|
                                       (CONS |redmons| |monslist|) . #22#)))
                           (LETT #2# (CDR #2#) . #22#) #24# G191
                           (EXIT NIL))
                      (LETT |ans|
                            (SPADCALL
                                (SPADCALL
                                    (SPADCALL |llR| (QREFELT $ 89))
                                    (QREFELT $ 144))
                                (QREFELT $ 146)) . #22#)
                      (EXIT (COND
                              ((QEQCAR |ans| 1) (CONS 1 "failed"))
                              ('T
                               (SEQ (LETT |i| 0 . #22#)
                                    (EXIT
                                     (CONS 0
                                      (PRIMVEC2ARR
                                       (PROGN
                                         (LETT #15#
                                          (GETREFV (SIZE |monslist|)) . #22#)
                                         (SEQ (LETT #16# 0 . #22#)
                                          (LETT |mons| NIL . #22#)
                                          (LETT #17# |monslist| . #22#)
                                          G190
                                          (COND
                                            ((OR (ATOM #17#)
                                              (PROGN
                                                (LETT |mons|
                                                 (CAR #17#) . #22#)
                                                NIL))
                                             #23#))
                                          (SEQ
                                           (EXIT
                                            (SETELT #15# #16#
                                             (PROGN
                                               (LETT #21# NIL . #22#)
                                               (SEQ
                                                (LETT |m| NIL . #22#)
                                                (LETT #18#
                                                 |mons| . #22#)
                                                G190
                                                (COND
                                                  ((OR (ATOM #18#)
                                                    (PROGN
                                                      (LETT |m|
                                                       (CAR #18#) . #22#)
                                                      NIL))
                                                   #23#))
                                                (SEQ
                                                 (EXIT
                                                  (PROGN
                                                    (LETT #19#
                                                     (SPADCALL |m|
                                                      (SPADCALL
                                                       (SPADCALL
                                                        (QCDR |ans|)
                                                        (LETT |i|
                                                         (+ |i| 1) . #22#)
                                                        (QREFELT $ 147))
                                                       (QREFELT $ 40))
                                                      (QREFELT $ 148)) . #22#)
                                                    (COND
                                                      (#21#
                                                       (LETT #20#
                                                        (SPADCALL #20#
                                                         #19#
                                                         (QREFELT $
                                                          149)) . #22#))
                                                      ('T
                                                       (PROGN
                                                         (LETT #20#
                                                          #19# . #22#)
                                                         (LETT #21#
                                                          'T . #22#)))))))
                                                (LETT #18#
                                                 (CDR #18#) . #22#)
                                                #24# G191 (EXIT NIL))
                                               (COND
                                                 (#21# #20#)
                                                 ('T
                                                  (|spadConstant| $ 21)))))))
                                          (LETT #17#
                                           (PROG1 (CDR #17#)
                                             (LETT #16#
                                              (QSADD1 #16#) . #22#)) . #22#)
                                          #24# G191 (EXIT NIL))
                                         #15#))))))))))
           #10# (EXIT #10#))))) 

(DEFUN |POLYCAT-;charthRoot;SU;28| (|p| $)
  (PROG (|vars| |ans| |ch|)
    (RETURN
      (SEQ (LETT |vars| (SPADCALL |p| (QREFELT $ 31))
                 . #0=(|POLYCAT-;charthRoot;SU;28|))
           (EXIT (COND
                   ((NULL |vars|)
                    (SEQ (LETT |ans|
                               (SPADCALL (SPADCALL |p| (QREFELT $ 143))
                                   (QREFELT $ 151)) . #0#)
                         (EXIT (COND
                                 ((QEQCAR |ans| 1) (CONS 1 "failed"))
                                 ('T
                                  (CONS 0
                                        (SPADCALL (QCDR |ans|)
                                         (QREFELT $ 40))))))))
                   ('T
                    (SEQ (LETT |ch| (SPADCALL (QREFELT $ 138)) . #0#)
                         (EXIT (|POLYCAT-;charthRootlv| |p| |vars| |ch|
                                   $)))))))))) 

(DEFUN |POLYCAT-;charthRootlv| (|p| |vars| |ch| $)
  (PROG (|v| |dd| |cp| |d| #0=#:G2096 |ans| |ansx| #1=#:G2103)
    (RETURN
      (SEQ (EXIT (COND
                   ((NULL |vars|)
                    (SEQ (LETT |ans|
                               (SPADCALL (SPADCALL |p| (QREFELT $ 143))
                                   (QREFELT $ 151))
                               . #2=(|POLYCAT-;charthRootlv|))
                         (EXIT (COND
                                 ((QEQCAR |ans| 1) (CONS 1 "failed"))
                                 ('T
                                  (CONS 0
                                        (SPADCALL (QCDR |ans|)
                                         (QREFELT $ 40))))))))
                   ('T
                    (SEQ (LETT |v| (|SPADfirst| |vars|) . #2#)
                         (LETT |vars| (CDR |vars|) . #2#)
                         (LETT |d|
                               (SPADCALL |p| |v| (QREFELT $ 36)) . #2#)
                         (LETT |ans| (|spadConstant| $ 21) . #2#)
                         (SEQ G190 (COND ((NULL (< 0 |d|)) (GO G191)))
                              (SEQ (LETT |dd|
                                    (SPADCALL |d| |ch| (QREFELT $ 142)) . #2#)
                                   (EXIT
                                    (COND
                                      ((QEQCAR |dd| 1)
                                       (PROGN
                                         (LETT #1#
                                          (CONS 1 "failed") . #2#)
                                         (GO #1#)))
                                      ('T
                                       (SEQ
                                        (LETT |cp|
                                         (SPADCALL |p| |v| |d|
                                          (QREFELT $ 154)) . #2#)
                                        (LETT |p|
                                         (SPADCALL |p|
                                          (SPADCALL |cp| |v| |d|
                                           (QREFELT $ 37))
                                          (QREFELT $ 155)) . #2#)
                                        (LETT |ansx|
                                         (|POLYCAT-;charthRootlv| |cp|
                                          |vars| |ch| $) . #2#)
                                        (EXIT
                                         (COND
                                           ((QEQCAR |ansx| 1)
                                            (PROGN
                                              (LETT #1#
                                               (CONS 1 "failed") . #2#)
                                              (GO #1#)))
                                           ('T
                                            (SEQ
                                             (LETT |d|
                                              (SPADCALL |p| |v|
                                               (QREFELT $ 36)) . #2#)
                                             (EXIT
                                              (LETT |ans|
                                               (SPADCALL |ans|
                                                (SPADCALL (QCDR |ansx|)
                                                 |v|
                                                 (PROG1
                                                  (LETT #0#
                                                   (QCDR |dd|) . #2#)
                                                   (|check-subtype|
                                                    (>= #0# 0)
                                                    '(|NonNegativeInteger|)
                                                    #0#))
                                                 (QREFELT $ 37))
                                                (QREFELT $ 149)) . #2#)))))))))))
                              NIL (GO G190) G191 (EXIT NIL))
                         (LETT |ansx|
                               (|POLYCAT-;charthRootlv| |p| |vars| |ch|
                                   $) . #2#)
                         (EXIT (COND
                                 ((QEQCAR |ansx| 1)
                                  (PROGN
                                    (LETT #1# (CONS 1 "failed") . #2#)
                                    (GO #1#)))
                                 ('T
                                  (PROGN
                                    (LETT #1#
                                     (CONS 0
                                      (SPADCALL |ans| (QCDR |ansx|)
                                       (QREFELT $ 149))) . #2#)
                                    (GO #1#)))))))))
           #1# (EXIT #1#))))) 

(DEFUN |POLYCAT-;monicDivide;2SVarSetR;30| (|p1| |p2| |mvar| $)
  (PROG (|result|)
    (RETURN
      (SEQ (LETT |result|
                 (SPADCALL (SPADCALL |p1| |mvar| (QREFELT $ 47))
                     (SPADCALL |p2| |mvar| (QREFELT $ 47))
                     (QREFELT $ 157))
                 |POLYCAT-;monicDivide;2SVarSetR;30|)
           (EXIT (CONS (SPADCALL (QCAR |result|) |mvar|
                           (QREFELT $ 132))
                       (SPADCALL (QCDR |result|) |mvar|
                           (QREFELT $ 132)))))))) 

(DEFUN |POLYCAT-;squareFree;SF;31| (|p| $)
  (SPADCALL |p| (QREFELT $ 160))) 

(DEFUN |POLYCAT-;squareFree;SF;32| (|p| $)
  (SPADCALL |p| (QREFELT $ 163))) 

(DEFUN |POLYCAT-;squareFree;SF;33| (|p| $)
  (SPADCALL |p| (QREFELT $ 163))) 

(DEFUN |POLYCAT-;squareFreePart;2S;34| (|p| $)
  (PROG (|s| |f| #0=#:G2119 #1=#:G2117 #2=#:G2115 #3=#:G2116)
    (RETURN
      (SEQ (SPADCALL
               (SPADCALL
                   (LETT |s| (SPADCALL |p| (QREFELT $ 164))
                         . #4=(|POLYCAT-;squareFreePart;2S;34|))
                   (QREFELT $ 165))
               (PROGN
                 (LETT #3# NIL . #4#)
                 (SEQ (LETT |f| NIL . #4#)
                      (LETT #0# (SPADCALL |s| (QREFELT $ 168)) . #4#)
                      G190
                      (COND
                        ((OR (ATOM #0#)
                             (PROGN (LETT |f| (CAR #0#) . #4#) NIL))
                         (GO G191)))
                      (SEQ (EXIT (PROGN
                                   (LETT #1# (QCAR |f|) . #4#)
                                   (COND
                                     (#3#
                                      (LETT #2#
                                       (SPADCALL #2# #1#
                                        (QREFELT $ 148)) . #4#))
                                     ('T
                                      (PROGN
                                        (LETT #2# #1# . #4#)
                                        (LETT #3# 'T . #4#)))))))
                      (LETT #0# (CDR #0#) . #4#) (GO G190) G191
                      (EXIT NIL))
                 (COND (#3# #2#) ('T (|spadConstant| $ 33))))
               (QREFELT $ 148)))))) 

(DEFUN |POLYCAT-;content;SVarSetS;35| (|p| |v| $)
  (SPADCALL (SPADCALL |p| |v| (QREFELT $ 47)) (QREFELT $ 170))) 

(DEFUN |POLYCAT-;primitivePart;2S;36| (|p| $)
  (PROG (#0=#:G2122)
    (RETURN
      (COND
        ((SPADCALL |p| (QREFELT $ 172)) |p|)
        ('T
         (QVELT (SPADCALL
                    (PROG2 (LETT #0#
                                 (SPADCALL |p|
                                     (SPADCALL |p| (QREFELT $ 173))
                                     (QREFELT $ 174))
                                 |POLYCAT-;primitivePart;2S;36|)
                           (QCDR #0#)
                      (|check-union| (QEQCAR #0# 0) (QREFELT $ 6) #0#))
                    (QREFELT $ 176))
                1)))))) 

(DEFUN |POLYCAT-;primitivePart;SVarSetS;37| (|p| |v| $)
  (PROG (#0=#:G2129)
    (RETURN
      (COND
        ((SPADCALL |p| (QREFELT $ 172)) |p|)
        ('T
         (QVELT (SPADCALL
                    (PROG2 (LETT #0#
                                 (SPADCALL |p|
                                     (SPADCALL |p| |v| (QREFELT $ 178))
                                     (QREFELT $ 179))
                                 |POLYCAT-;primitivePart;SVarSetS;37|)
                           (QCDR #0#)
                      (|check-union| (QEQCAR #0# 0) (QREFELT $ 6) #0#))
                    (QREFELT $ 176))
                1)))))) 

(DEFUN |POLYCAT-;<;2SB;38| (|p| |q| $)
  (PROG (|dp| |dq|)
    (RETURN
      (SEQ (LETT |dp| (SPADCALL |p| (QREFELT $ 59))
                 . #0=(|POLYCAT-;<;2SB;38|))
           (LETT |dq| (SPADCALL |q| (QREFELT $ 59)) . #0#)
           (EXIT (COND
                   ((SPADCALL |dp| |dq| (QREFELT $ 181))
                    (SPADCALL (|spadConstant| $ 22)
                        (SPADCALL |q| (QREFELT $ 38)) (QREFELT $ 182)))
                   ((SPADCALL |dq| |dp| (QREFELT $ 181))
                    (SPADCALL (SPADCALL |p| (QREFELT $ 38))
                        (|spadConstant| $ 22) (QREFELT $ 182)))
                   ('T
                    (SPADCALL
                        (SPADCALL (SPADCALL |p| |q| (QREFELT $ 155))
                            (QREFELT $ 38))
                        (|spadConstant| $ 22) (QREFELT $ 182))))))))) 

(DEFUN |POLYCAT-;patternMatch;SP2Pmr;39| (|p| |pat| |l| $)
  (SPADCALL |p| |pat| |l| (QREFELT $ 187))) 

(DEFUN |POLYCAT-;patternMatch;SP2Pmr;40| (|p| |pat| |l| $)
  (SPADCALL |p| |pat| |l| (QREFELT $ 193))) 

(DEFUN |POLYCAT-;convert;SP;41| (|x| $)
  (SPADCALL (ELT $ 196) (ELT $ 197) |x| (QREFELT $ 201))) 

(DEFUN |POLYCAT-;convert;SP;42| (|x| $)
  (SPADCALL (ELT $ 203) (ELT $ 204) |x| (QREFELT $ 208))) 

(DEFUN |POLYCAT-;convert;SIf;43| (|p| $)
  (SPADCALL (ELT $ 211) (ELT $ 212) |p| (QREFELT $ 216))) 

(DEFUN |PolynomialCategory&| (|#1| |#2| |#3| |#4|)
  (PROG (DV$1 DV$2 DV$3 DV$4 |dv$| $ |pv$|)
    (RETURN
      (PROGN
        (LETT DV$1 (|devaluate| |#1|) . #0=(|PolynomialCategory&|))
        (LETT DV$2 (|devaluate| |#2|) . #0#)
        (LETT DV$3 (|devaluate| |#3|) . #0#)
        (LETT DV$4 (|devaluate| |#4|) . #0#)
        (LETT |dv$|
              (LIST '|PolynomialCategory&| DV$1 DV$2 DV$3 DV$4) . #0#)
        (LETT $ (GETREFV 226) . #0#)
        (QSETREFV $ 0 |dv$|)
        (QSETREFV $ 3
            (LETT |pv$|
                  (|buildPredVector| 0 0
                      (LIST (|HasCategory| |#2|
                                '(|PolynomialFactorizationExplicit|))
                            (|HasCategory| |#2|
                                '(|canonicalUnitNormal|))
                            (|HasCategory| |#2| '(|GcdDomain|))
                            (|HasCategory| |#2| '(|CommutativeRing|))
                            (|HasCategory| |#4|
                                '(|PatternMatchable| (|Float|)))
                            (|HasCategory| |#2|
                                '(|PatternMatchable| (|Float|)))
                            (|HasCategory| |#4|
                                '(|PatternMatchable| (|Integer|)))
                            (|HasCategory| |#2|
                                '(|PatternMatchable| (|Integer|)))
                            (|HasCategory| |#4|
                                '(|ConvertibleTo|
                                     (|Pattern| (|Float|))))
                            (|HasCategory| |#2|
                                '(|ConvertibleTo|
                                     (|Pattern| (|Float|))))
                            (|HasCategory| |#4|
                                '(|ConvertibleTo|
                                     (|Pattern| (|Integer|))))
                            (|HasCategory| |#2|
                                '(|ConvertibleTo|
                                     (|Pattern| (|Integer|))))
                            (|HasCategory| |#4|
                                '(|ConvertibleTo| (|InputForm|)))
                            (|HasCategory| |#2|
                                '(|ConvertibleTo| (|InputForm|)))
                            (|HasCategory| |#2| '(|OrderedSet|)))) . #0#))
        (|stuffDomainSlots| $)
        (QSETREFV $ 6 |#1|)
        (QSETREFV $ 7 |#2|)
        (QSETREFV $ 8 |#3|)
        (QSETREFV $ 9 |#4|)
        (COND
          ((|testBitVector| |pv$| 4)
           (PROGN
             (QSETREFV $ 74
                 (CONS (|dispatchFunction|
                           |POLYCAT-;resultant;2SVarSetS;15|)
                       $))
             (QSETREFV $ 76
                 (CONS (|dispatchFunction|
                           |POLYCAT-;discriminant;SVarSetS;16|)
                       $)))))
        (COND
          ((|HasCategory| |#2| '(|IntegralDomain|))
           (PROGN
             (QSETREFV $ 95
                 (CONS (|dispatchFunction|
                           |POLYCAT-;reducedSystem;MM;20|)
                       $))
             (QSETREFV $ 102
                 (CONS (|dispatchFunction|
                           |POLYCAT-;reducedSystem;MVR;21|)
                       $)))))
        (COND
          ((|testBitVector| |pv$| 1)
           (PROGN
             (QSETREFV $ 105
                 (CONS (|dispatchFunction|
                           |POLYCAT-;gcdPolynomial;3Sup;22|)
                       $))
             (QSETREFV $ 112
                 (CONS (|dispatchFunction|
                           |POLYCAT-;solveLinearPolynomialEquation;LSupU;23|)
                       $))
             (QSETREFV $ 116
                 (CONS (|dispatchFunction|
                           |POLYCAT-;factorPolynomial;SupF;24|)
                       $))
             (QSETREFV $ 118
                 (CONS (|dispatchFunction|
                           |POLYCAT-;factorSquareFreePolynomial;SupF;25|)
                       $))
             (QSETREFV $ 136
                 (CONS (|dispatchFunction| |POLYCAT-;factor;SF;26|) $))
             (COND
               ((|HasCategory| |#2| '(|CharacteristicNonZero|))
                (PROGN
                  (QSETREFV $ 150
                      (CONS (|dispatchFunction|
                                |POLYCAT-;conditionP;MU;27|)
                            $))))))))
        (COND
          ((|HasCategory| |#2| '(|CharacteristicNonZero|))
           (PROGN
             (QSETREFV $ 152
                 (CONS (|dispatchFunction| |POLYCAT-;charthRoot;SU;28|)
                       $)))))
        (COND
          ((|testBitVector| |pv$| 3)
           (PROGN
             (COND
               ((|HasCategory| |#2| '(|EuclideanDomain|))
                (COND
                  ((|HasCategory| |#2| '(|CharacteristicZero|))
                   (QSETREFV $ 161
                       (CONS (|dispatchFunction|
                                 |POLYCAT-;squareFree;SF;31|)
                             $)))
                  ('T
                   (QSETREFV $ 161
                       (CONS (|dispatchFunction|
                                 |POLYCAT-;squareFree;SF;32|)
                             $)))))
               ('T
                (QSETREFV $ 161
                    (CONS (|dispatchFunction|
                              |POLYCAT-;squareFree;SF;33|)
                          $))))
             (QSETREFV $ 169
                 (CONS (|dispatchFunction|
                           |POLYCAT-;squareFreePart;2S;34|)
                       $))
             (QSETREFV $ 171
                 (CONS (|dispatchFunction|
                           |POLYCAT-;content;SVarSetS;35|)
                       $))
             (QSETREFV $ 177
                 (CONS (|dispatchFunction|
                           |POLYCAT-;primitivePart;2S;36|)
                       $))
             (QSETREFV $ 180
                 (CONS (|dispatchFunction|
                           |POLYCAT-;primitivePart;SVarSetS;37|)
                       $)))))
        (COND
          ((|testBitVector| |pv$| 15)
           (PROGN
             (QSETREFV $ 183
                 (CONS (|dispatchFunction| |POLYCAT-;<;2SB;38|) $))
             (COND
               ((|testBitVector| |pv$| 8)
                (COND
                  ((|testBitVector| |pv$| 7)
                   (QSETREFV $ 189
                       (CONS (|dispatchFunction|
                                 |POLYCAT-;patternMatch;SP2Pmr;39|)
                             $))))))
             (COND
               ((|testBitVector| |pv$| 6)
                (COND
                  ((|testBitVector| |pv$| 5)
                   (QSETREFV $ 195
                       (CONS (|dispatchFunction|
                                 |POLYCAT-;patternMatch;SP2Pmr;40|)
                             $)))))))))
        (COND
          ((|testBitVector| |pv$| 12)
           (COND
             ((|testBitVector| |pv$| 11)
              (QSETREFV $ 202
                  (CONS (|dispatchFunction| |POLYCAT-;convert;SP;41|)
                        $))))))
        (COND
          ((|testBitVector| |pv$| 10)
           (COND
             ((|testBitVector| |pv$| 9)
              (QSETREFV $ 209
                  (CONS (|dispatchFunction| |POLYCAT-;convert;SP;42|)
                        $))))))
        (COND
          ((|testBitVector| |pv$| 14)
           (COND
             ((|testBitVector| |pv$| 13)
              (QSETREFV $ 217
                  (CONS (|dispatchFunction| |POLYCAT-;convert;SIf;43|)
                        $))))))
        $)))) 

(MAKEPROP '|PolynomialCategory&| '|infovec|
    (LIST '#(NIL NIL NIL NIL NIL NIL (|local| |#1|) (|local| |#2|)
             (|local| |#3|) (|local| |#4|) (|Equation| 6) (0 . |lhs|)
             (|Union| 9 '"failed") (5 . |retractIfCan|)
             (10 . |retract|) (15 . |rhs|) (|List| 9) (|List| $)
             (20 . |eval|) (|List| 221) |POLYCAT-;eval;SLS;1|
             (27 . |Zero|) (31 . |Zero|) (|Boolean|) (35 . =)
             (41 . |leadingMonomial|) (46 . |reductum|)
             |POLYCAT-;monomials;SL;2| (51 . |monomials|)
             (|Union| 17 '"failed") |POLYCAT-;isPlus;SU;3|
             (56 . |variables|) (61 . |monomial?|) (66 . |One|)
             (70 . |One|) (|NonNegativeInteger|) (74 . |degree|)
             (80 . |monomial|) (87 . |leadingCoefficient|) (92 . =)
             (98 . |coerce|) |POLYCAT-;isTimes;SU;4|
             (103 . |mainVariable|)
             (|Record| (|:| |var| 9) (|:| |exponent| 35))
             (|Union| 43 '"failed") |POLYCAT-;isExpt;SU;5|
             (|SparseUnivariatePolynomial| $) (108 . |univariate|)
             (|SparseUnivariatePolynomial| 6) (114 . |coefficient|)
             |POLYCAT-;coefficient;SVarSetNniS;6| (|List| 35)
             (120 . |coefficient|) |POLYCAT-;coefficient;SLLS;7|
             (127 . |monomial|) |POLYCAT-;monomial;SLLS;8|
             (134 . |coerce|) |POLYCAT-;retract;SVarSet;9|
             |POLYCAT-;retractIfCan;SU;10| (139 . |degree|)
             (144 . |monomial|) |POLYCAT-;primitiveMonomials;SL;12|
             (150 . |ground?|) (155 . |Zero|) (159 . =)
             (165 . |degree|) (170 . |leadingCoefficient|)
             (175 . |totalDegree|) (180 . |reductum|)
             |POLYCAT-;totalDegree;SNni;13| (185 . |member?|)
             (191 . |totalDegree|) |POLYCAT-;totalDegree;SLNni;14|
             (197 . |resultant|) (203 . |resultant|)
             (210 . |discriminant|) (215 . |discriminant|)
             (221 . |primitiveMonomials|) (|List| 6) (226 . |concat|)
             (231 . |removeDuplicates!|) (|Vector| 7) (236 . |new|)
             (|Integer|) (242 . |minIndex|) (247 . |coefficient|)
             (253 . |qsetelt!|) (|List| 220) (|Matrix| 7)
             (260 . |matrix|) (|List| 78) (|Matrix| 6)
             (265 . |listOfLists|) (270 . |vertConcat|) (|Matrix| $)
             (276 . |reducedSystem|) (|Vector| 6) (281 . |entries|)
             (286 . |concat|) (292 . |concat|)
             (|Record| (|:| |mat| 88) (|:| |vec| 81)) (|Vector| $)
             (298 . |reducedSystem|)
             (|GeneralPolynomialGcdPackage| 8 9 7 6)
             (304 . |gcdPolynomial|) (310 . |gcdPolynomial|)
             (|Union| 107 '"failed") (|List| 48)
             (|PolynomialFactorizationByRecursion| 7 8 9 6)
             (316 . |solveLinearPolynomialEquationByRecursion|)
             (|Union| 111 '"failed") (|List| 46)
             (322 . |solveLinearPolynomialEquation|) (|Factored| 48)
             (328 . |factorByRecursion|) (|Factored| 46)
             (333 . |factorPolynomial|)
             (338 . |factorSquareFreeByRecursion|)
             (343 . |factorSquareFreePolynomial|) (|Factored| $)
             (348 . |factor|) (|Factored| 7) (353 . |unit|)
             (|Union| '"nil" '"sqfr" '"irred" '"prime")
             (|Record| (|:| |flg| 123) (|:| |fctr| 7) (|:| |xpnt| 83))
             (|List| 124) (358 . |factorList|)
             (|Record| (|:| |flg| 123) (|:| |fctr| 6) (|:| |xpnt| 83))
             (|List| 127) (|Factored| 6) (363 . |makeFR|)
             (369 . |unit|) (374 . |multivariate|)
             (|Record| (|:| |flg| 123) (|:| |fctr| 48) (|:| |xpnt| 83))
             (|List| 133) (380 . |factorList|) (385 . |factor|)
             (390 . |transpose|) (395 . |characteristic|)
             (399 . |setUnion|) (405 . |degree|) (|Union| $ '"failed")
             (411 . |exquo|) (417 . |ground|) (422 . |transpose|)
             (|Union| 101 '"failed") (427 . |conditionP|) (432 . |elt|)
             (438 . *) (444 . +) (450 . |conditionP|)
             (455 . |charthRoot|) (460 . |charthRoot|) (465 . |Zero|)
             (469 . |coefficient|) (476 . -)
             (|Record| (|:| |quotient| $) (|:| |remainder| $))
             (482 . |monicDivide|) |POLYCAT-;monicDivide;2SVarSetR;30|
             (|MultivariateSquareFree| 8 9 7 6) (488 . |squareFree|)
             (493 . |squareFree|) (|PolynomialSquareFree| 9 8 7 6)
             (498 . |squareFree|) (503 . |squareFree|) (508 . |unit|)
             (|Record| (|:| |factor| 6) (|:| |exponent| 83))
             (|List| 166) (513 . |factors|) (518 . |squareFreePart|)
             (523 . |content|) (528 . |content|) (534 . |zero?|)
             (539 . |content|) (544 . |exquo|)
             (|Record| (|:| |unit| $) (|:| |canonical| $)
                 (|:| |associate| $))
             (550 . |unitNormal|) (555 . |primitivePart|)
             (560 . |content|) (566 . |exquo|) (572 . |primitivePart|)
             (578 . <) (584 . <) (590 . <) (|PatternMatchResult| 83 6)
             (|Pattern| 83)
             (|PatternMatchPolynomialCategory| 83 8 9 7 6)
             (596 . |patternMatch|) (|PatternMatchResult| 83 $)
             (603 . |patternMatch|) (|PatternMatchResult| (|Float|) 6)
             (|Pattern| (|Float|))
             (|PatternMatchPolynomialCategory| (|Float|) 8 9 7 6)
             (610 . |patternMatch|) (|PatternMatchResult| (|Float|) $)
             (617 . |patternMatch|) (624 . |convert|) (629 . |convert|)
             (|Mapping| 185 9) (|Mapping| 185 7)
             (|PolynomialCategoryLifting| 8 9 7 6 185) (634 . |map|)
             (641 . |convert|) (646 . |convert|) (651 . |convert|)
             (|Mapping| 191 9) (|Mapping| 191 7)
             (|PolynomialCategoryLifting| 8 9 7 6 191) (656 . |map|)
             (663 . |convert|) (|InputForm|) (668 . |convert|)
             (673 . |convert|) (|Mapping| 210 9) (|Mapping| 210 7)
             (|PolynomialCategoryLifting| 8 9 7 6 210) (678 . |map|)
             (685 . |convert|)
             (|Record| (|:| |mat| 219) (|:| |vec| (|Vector| 83)))
             (|Matrix| 83) (|List| 7) (|Equation| $)
             (|Union| 83 '"failed") (|Union| 224 '"failed")
             (|Fraction| 83) (|Union| 7 '"failed"))
          '#(|totalDegree| 690 |squareFreePart| 701 |squareFree| 706
             |solveLinearPolynomialEquation| 711 |retractIfCan| 717
             |retract| 722 |resultant| 727 |reducedSystem| 734
             |primitivePart| 745 |primitiveMonomials| 756
             |patternMatch| 761 |monomials| 775 |monomial| 780
             |monicDivide| 787 |isTimes| 794 |isPlus| 799 |isExpt| 804
             |gcdPolynomial| 809 |factorSquareFreePolynomial| 815
             |factorPolynomial| 820 |factor| 825 |eval| 830
             |discriminant| 836 |convert| 842 |content| 857
             |conditionP| 863 |coefficient| 868 |charthRoot| 882 < 887)
          'NIL
          (CONS (|makeByteWordVec2| 1 'NIL)
                (CONS '#()
                      (CONS '#()
                            (|makeByteWordVec2| 217
                                '(1 10 6 0 11 1 6 12 0 13 1 6 9 0 14 1
                                  10 6 0 15 3 6 0 0 16 17 18 0 6 0 21 0
                                  7 0 22 2 6 23 0 0 24 1 6 0 0 25 1 6 0
                                  0 26 1 6 17 0 28 1 6 16 0 31 1 6 23 0
                                  32 0 6 0 33 0 7 0 34 2 6 35 0 9 36 3
                                  6 0 0 9 35 37 1 6 7 0 38 2 7 23 0 0
                                  39 1 6 0 7 40 1 6 12 0 42 2 6 46 0 9
                                  47 2 48 6 0 35 49 3 6 0 0 16 51 52 3
                                  6 0 0 16 51 54 1 6 0 9 56 1 6 8 0 59
                                  2 6 0 7 8 60 1 6 23 0 62 0 48 0 63 2
                                  48 23 0 0 64 1 48 35 0 65 1 48 6 0 66
                                  1 6 35 0 67 1 48 0 0 68 2 16 23 9 0
                                  70 2 6 35 0 16 71 2 48 6 0 0 73 3 0 0
                                  0 0 9 74 1 48 6 0 75 2 0 0 0 9 76 1 6
                                  17 0 77 1 78 0 17 79 1 78 0 0 80 2 81
                                  0 35 7 82 1 81 83 0 84 2 6 7 0 8 85 3
                                  81 7 0 83 7 86 1 88 0 87 89 1 91 90 0
                                  92 2 88 0 0 0 93 1 0 88 94 95 1 96 78
                                  0 97 2 78 0 0 0 98 2 81 0 0 0 99 2 0
                                  100 94 101 102 2 103 48 48 48 104 2 0
                                  46 46 46 105 2 108 106 107 48 109 2 0
                                  110 111 46 112 1 108 113 48 114 1 0
                                  115 46 116 1 108 113 48 117 1 0 115
                                  46 118 1 7 119 0 120 1 121 7 0 122 1
                                  121 125 0 126 2 129 0 6 128 130 1 113
                                  48 0 131 2 6 0 46 9 132 1 113 134 0
                                  135 1 0 119 0 136 1 91 0 0 137 0 6 35
                                  138 2 78 0 0 0 139 2 6 51 0 16 140 2
                                  83 141 0 0 142 1 6 7 0 143 1 88 0 0
                                  144 1 7 145 94 146 2 81 7 0 83 147 2
                                  6 0 0 0 148 2 6 0 0 0 149 1 0 145 94
                                  150 1 7 141 0 151 1 0 141 0 152 0 8 0
                                  153 3 6 0 0 9 35 154 2 6 0 0 0 155 2
                                  48 156 0 0 157 1 159 129 6 160 1 0
                                  119 0 161 1 162 129 6 163 1 6 119 0
                                  164 1 129 6 0 165 1 129 167 0 168 1 0
                                  0 0 169 1 48 6 0 170 2 0 0 0 9 171 1
                                  6 23 0 172 1 6 7 0 173 2 6 141 0 7
                                  174 1 6 175 0 176 1 0 0 0 177 2 6 0 0
                                  9 178 2 6 141 0 0 179 2 0 0 0 9 180 2
                                  8 23 0 0 181 2 7 23 0 0 182 2 0 23 0
                                  0 183 3 186 184 6 185 184 187 3 0 188
                                  0 185 188 189 3 192 190 6 191 190 193
                                  3 0 194 0 191 194 195 1 9 185 0 196 1
                                  7 185 0 197 3 200 185 198 199 6 201 1
                                  0 185 0 202 1 9 191 0 203 1 7 191 0
                                  204 3 207 191 205 206 6 208 1 0 191 0
                                  209 1 9 210 0 211 1 7 210 0 212 3 215
                                  210 213 214 6 216 1 0 210 0 217 2 0
                                  35 0 16 72 1 0 35 0 69 1 0 0 0 169 1
                                  0 119 0 161 2 0 110 111 46 112 1 0 12
                                  0 58 1 0 9 0 57 3 0 0 0 0 9 74 1 0 88
                                  94 95 2 0 100 94 101 102 2 0 0 0 9
                                  180 1 0 0 0 177 1 0 17 0 61 3 0 188 0
                                  185 188 189 3 0 194 0 191 194 195 1 0
                                  17 0 27 3 0 0 0 16 51 55 3 0 156 0 0
                                  9 158 1 0 29 0 41 1 0 29 0 30 1 0 44
                                  0 45 2 0 46 46 46 105 1 0 115 46 118
                                  1 0 115 46 116 1 0 119 0 136 2 0 0 0
                                  19 20 2 0 0 0 9 76 1 0 210 0 217 1 0
                                  185 0 202 1 0 191 0 209 2 0 0 0 9 171
                                  1 0 145 94 150 3 0 0 0 16 51 53 3 0 0
                                  0 9 35 50 1 0 141 0 152 2 0 23 0 0
                                  183)))))
          '|lookupComplete|)) 
