
(/VERSIONCHECK 2) 

(DEFUN |PSETPK;removeAssociates| (|lp| $)
  (PROG (#0=#:G1925 |p| #1=#:G1926)
    (RETURN
      (SEQ (SPADCALL
               (PROGN
                 (LETT #0# NIL . #2=(|PSETPK;removeAssociates|))
                 (SEQ (LETT |p| NIL . #2#) (LETT #1# |lp| . #2#) G190
                      (COND
                        ((OR (ATOM #1#)
                             (PROGN (LETT |p| (CAR #1#) . #2#) NIL))
                         (GO G191)))
                      (SEQ (EXIT (LETT #0#
                                       (CONS
                                        (SPADCALL |p| (QREFELT $ 10))
                                        #0#) . #2#)))
                      (LETT #1# (CDR #1#) . #2#) (GO G190) G191
                      (EXIT (NREVERSE0 #0#))))
               (QREFELT $ 12)))))) 

(DEFUN |PSETPK;selectPolynomials;MLR;2| (|pred?| |ps| $)
  (PROG (|p| |gps| |bps|)
    (RETURN
      (SEQ (LETT |gps| NIL . #0=(|PSETPK;selectPolynomials;MLR;2|))
           (LETT |bps| NIL . #0#)
           (SEQ G190
                (COND
                  ((NULL (COND ((NULL |ps|) 'NIL) ('T 'T))) (GO G191)))
                (SEQ (LETT |p| (|SPADfirst| |ps|) . #0#)
                     (LETT |ps| (CDR |ps|) . #0#)
                     (EXIT (COND
                             ((SPADCALL |p| |pred?|)
                              (LETT |gps| (CONS |p| |gps|) . #0#))
                             ('T (LETT |bps| (CONS |p| |bps|) . #0#)))))
                NIL (GO G190) G191 (EXIT NIL))
           (LETT |gps|
                 (SPADCALL (ELT $ 14) |gps| (QREFELT $ 16)) . #0#)
           (LETT |bps|
                 (SPADCALL (ELT $ 14) |bps| (QREFELT $ 16)) . #0#)
           (EXIT (CONS |gps| |bps|)))))) 

(DEFUN |PSETPK;selectOrPolynomials;LLR;3| (|lpred?| |ps| $)
  (PROG (|p| |clpred?| |gps| |bps|)
    (RETURN
      (SEQ (LETT |gps| NIL . #0=(|PSETPK;selectOrPolynomials;LLR;3|))
           (LETT |bps| NIL . #0#)
           (SEQ G190
                (COND
                  ((NULL (COND ((NULL |ps|) 'NIL) ('T 'T)))
                   #1=(GO G191)))
                (SEQ (LETT |p| (|SPADfirst| |ps|) . #0#)
                     (LETT |ps| (CDR |ps|) . #0#)
                     (LETT |clpred?| |lpred?| . #0#)
                     (SEQ G190
                          (COND
                            ((NULL (COND
                                     ((OR (NULL |clpred?|)
                                       (SPADCALL |p|
                                        (|SPADfirst| |clpred?|)))
                                      'NIL)
                                     ('T 'T)))
                             #1#))
                          (SEQ (EXIT (LETT |clpred?|
                                      (CDR |clpred?|) . #0#)))
                          NIL #2=(GO G190) G191 (EXIT NIL))
                     (EXIT (COND
                             ((NULL |clpred?|)
                              (LETT |bps| (CONS |p| |bps|) . #0#))
                             ('T (LETT |gps| (CONS |p| |gps|) . #0#)))))
                NIL #2# G191 (EXIT NIL))
           (LETT |gps|
                 (SPADCALL (ELT $ 14) |gps| (QREFELT $ 16)) . #0#)
           (LETT |bps|
                 (SPADCALL (ELT $ 14) |bps| (QREFELT $ 16)) . #0#)
           (EXIT (CONS |gps| |bps|)))))) 

(DEFUN |PSETPK;selectAndPolynomials;LLR;4| (|lpred?| |ps| $)
  (PROG (|p| |clpred?| |gps| |bps|)
    (RETURN
      (SEQ (LETT |gps| NIL . #0=(|PSETPK;selectAndPolynomials;LLR;4|))
           (LETT |bps| NIL . #0#)
           (SEQ G190
                (COND
                  ((NULL (COND ((NULL |ps|) 'NIL) ('T 'T)))
                   #1=(GO G191)))
                (SEQ (LETT |p| (|SPADfirst| |ps|) . #0#)
                     (LETT |ps| (CDR |ps|) . #0#)
                     (LETT |clpred?| |lpred?| . #0#)
                     (SEQ G190
                          (COND
                            ((NULL (COND
                                     ((NULL |clpred?|) 'NIL)
                                     ('T
                                      (SPADCALL |p|
                                       (|SPADfirst| |clpred?|)))))
                             #1#))
                          (SEQ (EXIT (LETT |clpred?|
                                      (CDR |clpred?|) . #0#)))
                          NIL #2=(GO G190) G191 (EXIT NIL))
                     (EXIT (COND
                             ((NULL |clpred?|)
                              (LETT |gps| (CONS |p| |gps|) . #0#))
                             ('T (LETT |bps| (CONS |p| |bps|) . #0#)))))
                NIL #2# G191 (EXIT NIL))
           (LETT |gps|
                 (SPADCALL (ELT $ 14) |gps| (QREFELT $ 16)) . #0#)
           (LETT |bps|
                 (SPADCALL (ELT $ 14) |bps| (QREFELT $ 16)) . #0#)
           (EXIT (CONS |gps| |bps|)))))) 

(DEFUN |PSETPK;linear?;PB;5| (|p| $)
  (COND
    ((SPADCALL |p| (QREFELT $ 23)) 'NIL)
    ('T (EQL (SPADCALL |p| (QREFELT $ 25)) 1)))) 

(DEFUN |PSETPK;linearPolynomials;LR;6| (|ps| $)
  (SPADCALL (ELT $ 27) |ps| (QREFELT $ 19))) 

(DEFUN |PSETPK;univariate?;PB;7| (|p| $)
  (PROG (|tp|)
    (RETURN
      (SEQ (COND
             ((OR (SPADCALL |p| (QREFELT $ 23))
                  (NULL (SPADCALL (SPADCALL |p| (QREFELT $ 29))
                            (QREFELT $ 23))))
              'NIL)
             ('T
              (SEQ (LETT |tp| (SPADCALL |p| (QREFELT $ 30))
                         |PSETPK;univariate?;PB;7|)
                   (EXIT (COND
                           ((SPADCALL |tp| (QREFELT $ 23)) 'T)
                           ((NULL (SPADCALL
                                      (SPADCALL |p| (QREFELT $ 31))
                                      (SPADCALL |tp| (QREFELT $ 31))
                                      (QREFELT $ 32)))
                            'NIL)
                           ('T (SPADCALL |tp| (QREFELT $ 33)))))))))))) 

(DEFUN |PSETPK;univariatePolynomials;LR;8| (|ps| $)
  (SPADCALL (ELT $ 33) |ps| (QREFELT $ 19))) 

(DEFUN |PSETPK;bivariate?;PB;9| (|p| $)
  (PROG (|vp| |vtp| |vip|)
    (RETURN
      (SEQ (COND
             ((SPADCALL |p| (QREFELT $ 23)) 'NIL)
             ((SPADCALL (SPADCALL |p| (QREFELT $ 30)) (QREFELT $ 23))
              (SPADCALL (SPADCALL |p| (QREFELT $ 29)) (QREFELT $ 33)))
             ('T
              (SEQ (LETT |vp| (SPADCALL |p| (QREFELT $ 31))
                         . #0=(|PSETPK;bivariate?;PB;9|))
                   (LETT |vtp|
                         (SPADCALL (SPADCALL |p| (QREFELT $ 30))
                             (QREFELT $ 31)) . #0#)
                   (COND
                     ((SPADCALL (SPADCALL |p| (QREFELT $ 29))
                          (QREFELT $ 23))
                      (COND
                        ((SPADCALL |vp| |vtp| (QREFELT $ 32))
                         (EXIT (SPADCALL (SPADCALL |p| (QREFELT $ 30))
                                   (QREFELT $ 35)))))))
                   (COND
                     ((SPADCALL (SPADCALL |p| (QREFELT $ 29))
                          (QREFELT $ 23))
                      (COND
                        ((SPADCALL |vtp| |vp| (QREFELT $ 36))
                         (EXIT (SPADCALL (SPADCALL |p| (QREFELT $ 30))
                                   (QREFELT $ 33)))))))
                   (COND
                     ((NULL (SPADCALL (SPADCALL |p| (QREFELT $ 29))
                                (QREFELT $ 33)))
                      (EXIT 'NIL)))
                   (LETT |vip|
                         (SPADCALL (SPADCALL |p| (QREFELT $ 29))
                             (QREFELT $ 31)) . #0#)
                   (EXIT (COND
                           ((SPADCALL |vtp| |vip| (QREFELT $ 36)) 'NIL)
                           ((SPADCALL |vip| |vtp| (QREFELT $ 32))
                            (SPADCALL (SPADCALL |p| (QREFELT $ 30))
                                (QREFELT $ 33)))
                           ((SPADCALL |vtp| |vp| (QREFELT $ 36)) 'NIL)
                           ('T
                            (COND
                              ((ZEROP (SPADCALL
                                       (SPADCALL |p| (QREFELT $ 30))
                                       |vip| (QREFELT $ 37)))
                               (SPADCALL (SPADCALL |p| (QREFELT $ 30))
                                   (QREFELT $ 33)))
                              ('T
                               (SPADCALL (SPADCALL |p| (QREFELT $ 30))
                                   (QREFELT $ 35)))))))))))))) 

(DEFUN |PSETPK;bivariatePolynomials;LR;10| (|ps| $)
  (SPADCALL (ELT $ 35) |ps| (QREFELT $ 19))) 

(DEFUN |PSETPK;quasiMonicPolynomials;LR;11| (|ps| $)
  (SPADCALL (ELT $ 39) |ps| (QREFELT $ 19))) 

(DEFUN |PSETPK;removeRoughlyRedundantFactorsInPols;2LBL;12|
       (|lp| |lf| |opt| $)
  (PROG (|f| |copylf| |test| #0=#:G1979 |p| |stop| |newlp|)
    (RETURN
      (SEQ (COND
             ((NULL |lp|) |lp|)
             ('T
              (SEQ (LETT |newlp| NIL
                         . #1=(|PSETPK;removeRoughlyRedundantFactorsInPols;2LBL;12|))
                   (LETT |stop| 'NIL . #1#)
                   (LETT |lp|
                         (SPADCALL (ELT $ 41) |lp| (QREFELT $ 42)) . #1#)
                   (LETT |lf|
                         (SPADCALL (ELT $ 14) |lf| (QREFELT $ 16)) . #1#)
                   (SEQ G190
                        (COND
                          ((NULL (COND
                                   ((OR (NULL |lp|) |stop|) 'NIL)
                                   ('T 'T)))
                           #2=(GO G191)))
                        (SEQ (LETT |p| (|SPADfirst| |lp|) . #1#)
                             (LETT |lp| (CDR |lp|) . #1#)
                             (LETT |copylf| |lf| . #1#)
                             (SEQ G190
                                  (COND
                                    ((NULL
                                      (COND
                                        ((OR (NULL |copylf|)
                                          (SPADCALL |p| (QREFELT $ 23))
                                          (SPADCALL
                                           (SPADCALL |p|
                                            (QREFELT $ 31))
                                           (SPADCALL
                                            (|SPADfirst| |copylf|)
                                            (QREFELT $ 31))
                                           (QREFELT $ 36)))
                                         'NIL)
                                        ('T 'T)))
                                     #2#))
                                  (SEQ (LETT |f|
                                        (|SPADfirst| |copylf|) . #1#)
                                       (LETT |copylf|
                                        (CDR |copylf|) . #1#)
                                       (EXIT
                                        (SEQ G190
                                         (COND
                                           ((NULL
                                             (QEQCAR
                                              (LETT |test|
                                               (SPADCALL |p| |f|
                                                (QREFELT $ 44)) . #1#)
                                              0))
                                            #2#))
                                         (SEQ
                                          (EXIT
                                           (LETT |p|
                                            (PROG2
                                             (LETT #0# |test| . #1#)
                                             (QCDR #0#)
                                              (|check-union|
                                               (QEQCAR #0# 0)
                                               (QREFELT $ 9) #0#)) . #1#)))
                                         NIL #3=(GO G190) G191
                                         (EXIT NIL))))
                                  NIL #3# G191 (EXIT NIL))
                             (LETT |stop|
                                   (COND
                                     (|opt|
                                      (SPADCALL |p| (QREFELT $ 23)))
                                     ('T 'NIL)) . #1#)
                             (EXIT (LETT |newlp|
                                    (CONS (SPADCALL |p| (QREFELT $ 45))
                                     |newlp|) . #1#)))
                        NIL #3# G191 (EXIT NIL))
                   (EXIT (COND
                           (|stop| (LIST (|spadConstant| $ 46)))
                           ('T |newlp|)))))))))) 

(DEFUN |PSETPK;removeRoughlyRedundantFactorsInPol;PLP;13| (|p| |lf| $)
  (PROG (|lp|)
    (RETURN
      (SEQ (COND
             ((SPADCALL |p| (QREFELT $ 41)) |p|)
             ('T
              (SEQ (LETT |lp| (LIST |p|)
                         |PSETPK;removeRoughlyRedundantFactorsInPol;PLP;13|)
                   (EXIT (|SPADfirst|
                             (SPADCALL |lp| |lf| 'T (QREFELT $ 47))))))))))) 

(DEFUN |PSETPK;removeRoughlyRedundantFactorsInPols;3L;14| (|lp| |lf| $)
  (SPADCALL |lp| |lf| 'NIL (QREFELT $ 47))) 

(DEFUN |PSETPK;possiblyNewVariety?;LLB;15| (|newlp| |llp| $)
  (SEQ (SEQ G190
            (COND
              ((NULL (COND
                       ((OR (NULL |llp|)
                            (SPADCALL |newlp| (|SPADfirst| |llp|)
                                (QREFELT $ 50)))
                        'NIL)
                       ('T 'T)))
               (GO G191)))
            (SEQ (EXIT (LETT |llp| (CDR |llp|)
                             |PSETPK;possiblyNewVariety?;LLB;15|)))
            NIL (GO G190) G191 (EXIT NIL))
       (EXIT (NULL |llp|)))) 

(DEFUN |PSETPK;certainlySubVariety?;2LB;16| (|lp| |lq| $)
  (PROG (|gs|)
    (RETURN
      (SEQ (LETT |gs| (SPADCALL |lp| (QREFELT $ 54))
                 . #0=(|PSETPK;certainlySubVariety?;2LB;16|))
           (SEQ G190
                (COND
                  ((NULL (COND
                           ((NULL |lq|) 'NIL)
                           ('T
                            (SPADCALL
                                (QVELT (SPADCALL (|SPADfirst| |lq|)
                                        |gs| (QREFELT $ 56))
                                       1)
                                (QREFELT $ 41)))))
                   (GO G191)))
                (SEQ (EXIT (LETT |lq| (CDR |lq|) . #0#))) NIL (GO G190)
                G191 (EXIT NIL))
           (EXIT (NULL |lq|)))))) 

(DEFUN |PSETPK;probablyZeroDim?;LB;17| (|lp| $)
  (PROG (|m| |lv| |n|)
    (RETURN
      (SEQ (LETT |m| (LENGTH |lp|)
                 . #0=(|PSETPK;probablyZeroDim?;LB;17|))
           (LETT |lv|
                 (SPADCALL (|SPADfirst| |lp|) (QREFELT $ 58)) . #0#)
           (SEQ G190
                (COND
                  ((NULL (COND
                           ((NULL (LETT |lp| (CDR |lp|) . #0#)) 'NIL)
                           ('T 'T)))
                   (GO G191)))
                (SEQ (EXIT (LETT |lv|
                                 (SPADCALL
                                     (SPADCALL (|SPADfirst| |lp|)
                                      (QREFELT $ 58))
                                     |lv| (QREFELT $ 59)) . #0#)))
                NIL (GO G190) G191 (EXIT NIL))
           (LETT |n| (LENGTH (SPADCALL |lv| (QREFELT $ 60))) . #0#)
           (EXIT (COND ((< |m| |n|) 'NIL) ('T 'T))))))) 

(DEFUN |PSETPK;interReduce;2L;18| (|lp| $)
  (PROG (|p| |r| #0=#:G2023 |ps| |rs|)
    (RETURN
      (SEQ (EXIT (SEQ (LETT |ps| |lp|
                            . #1=(|PSETPK;interReduce;2L;18|))
                      (LETT |rs| NIL . #1#)
                      (EXIT (SEQ G190 NIL
                                 (SEQ (EXIT
                                       (COND
                                         ((NULL |ps|)
                                          (PROGN
                                            (LETT #0# |rs| . #1#)
                                            (GO #0#)))
                                         ('T
                                          (SEQ
                                           (LETT |ps|
                                            (SPADCALL (ELT $ 62) |ps|
                                             (QREFELT $ 16)) . #1#)
                                           (LETT |p|
                                            (|SPADfirst| |ps|) . #1#)
                                           (LETT |ps| (CDR |ps|) . #1#)
                                           (LETT |r|
                                            (QVELT
                                             (SPADCALL |p|
                                              (SPADCALL |ps|
                                               (QREFELT $ 54))
                                              (QREFELT $ 56))
                                             1) . #1#)
                                           (EXIT
                                            (COND
                                              ((SPADCALL |r|
                                                (QREFELT $ 41))
                                               "leave")
                                              ((SPADCALL |r|
                                                (QREFELT $ 23))
                                               (PROGN
                                                 (LETT #0# NIL . #1#)
                                                 (GO #0#)))
                                              ((SPADCALL |r| |p|
                                                (QREFELT $ 63))
                                               (LETT |rs|
                                                (CONS |r| |rs|) . #1#))
                                              ('T
                                               (SEQ
                                                (LETT |ps|
                                                 (SPADCALL |ps|
                                                  (CONS |r| |rs|)
                                                  (QREFELT $ 64)) . #1#)
                                                (EXIT
                                                 (LETT |rs| NIL . #1#)))))))))))
                                 NIL (GO G190) G191 (EXIT NIL)))))
           #0# (EXIT #0#))))) 

(DEFUN |PSETPK;roughRed?| (|p| |q| $)
  (COND
    ((SPADCALL |p| (QREFELT $ 23)) 'NIL)
    ((SPADCALL |q| (QREFELT $ 23)) 'T)
    ('T
     (SPADCALL (SPADCALL |q| (QREFELT $ 31))
         (SPADCALL |p| (QREFELT $ 31)) (QREFELT $ 36))))) 

(DEFUN |PSETPK;roughBasicSet;LU;20| (|lp| $)
  (SPADCALL |lp| (CONS (|function| |PSETPK;roughRed?|) $)
      (QREFELT $ 69))) 

(DEFUN |PSETPK;autoRemainder| (|ts| $)
  (PROG (|p| |newlp| |lp|)
    (RETURN
      (SEQ (COND
             ((SPADCALL |ts| (QREFELT $ 73))
              (SPADCALL |ts| (QREFELT $ 74)))
             ('T
              (SEQ (LETT |lp|
                         (SPADCALL (ELT $ 14)
                             (REVERSE (SPADCALL |ts| (QREFELT $ 74)))
                             (QREFELT $ 16))
                         . #0=(|PSETPK;autoRemainder|))
                   (LETT |newlp|
                         (LIST (SPADCALL (|SPADfirst| |lp|)
                                   (QREFELT $ 10))) . #0#)
                   (LETT |lp| (CDR |lp|) . #0#)
                   (SEQ G190
                        (COND
                          ((NULL (COND ((NULL |lp|) 'NIL) ('T 'T)))
                           (GO G191)))
                        (SEQ (LETT |p|
                                   (QVELT
                                    (SPADCALL (|SPADfirst| |lp|)
                                     (SPADCALL |newlp| (QREFELT $ 54))
                                     (QREFELT $ 56))
                                    1) . #0#)
                             (EXIT (COND
                                     ((SPADCALL |p| (QREFELT $ 41))
                                      (LETT |lp| (CDR |lp|) . #0#))
                                     ((SPADCALL |p| (QREFELT $ 23))
                                      (SEQ
                                       (LETT |newlp|
                                        (LIST (|spadConstant| $ 46)) . #0#)
                                       (EXIT (LETT |lp| NIL . #0#))))
                                     ('T
                                      (SEQ
                                       (LETT |newlp|
                                        (CONS |p| |newlp|) . #0#)
                                       (EXIT
                                        (LETT |lp| (CDR |lp|) . #0#)))))))
                        NIL (GO G190) G191 (EXIT NIL))
                   (EXIT |newlp|)))))))) 

(DEFUN |PSETPK;crushedSet;2L;22| (|lp| $)
  (PROG (|bs| |rs| |rec| |contradiction| #0=#:G2052 |finished|)
    (RETURN
      (SEQ (LETT |rec| (SPADCALL |lp| (QREFELT $ 72))
                 . #1=(|PSETPK;crushedSet;2L;22|))
           (LETT |contradiction| (QEQCAR |rec| 1) . #1#)
           (LETT |finished| 'NIL . #1#)
           (SEQ G190
                (COND
                  ((NULL (COND
                           ((OR |finished| |contradiction|) 'NIL)
                           ('T 'T)))
                   (GO G191)))
                (SEQ (LETT |bs|
                           (QCAR (PROG2 (LETT #0# |rec| . #1#)
                                        (QCDR #0#)
                                   (|check-union| (QEQCAR #0# 0)
                                    (|Record|
                                     (|:| |bas|
                                      (|GeneralTriangularSet|
                                       (QREFELT $ 6) (QREFELT $ 7)
                                       (QREFELT $ 8) (QREFELT $ 9)))
                                     (|:| |top| (|List| (QREFELT $ 9))))
                                    #0#))) . #1#)
                     (LETT |rs|
                           (QCDR (PROG2 (LETT #0# |rec| . #1#)
                                        (QCDR #0#)
                                   (|check-union| (QEQCAR #0# 0)
                                    (|Record|
                                     (|:| |bas|
                                      (|GeneralTriangularSet|
                                       (QREFELT $ 6) (QREFELT $ 7)
                                       (QREFELT $ 8) (QREFELT $ 9)))
                                     (|:| |top| (|List| (QREFELT $ 9))))
                                    #0#))) . #1#)
                     (LETT |rs|
                           (SPADCALL |rs| |bs| (QREFELT $ 75)) . #1#)
                     (LETT |contradiction|
                           (COND
                             ((NULL |rs|) 'NIL)
                             ('T
                              (SPADCALL (|SPADfirst| |rs|)
                                  (|spadConstant| $ 46) (QREFELT $ 76)))) . #1#)
                     (EXIT (COND
                             ((NULL |contradiction|)
                              (SEQ (LETT |rs|
                                    (SPADCALL |rs|
                                     (|PSETPK;autoRemainder| |bs| $)
                                     (QREFELT $ 64)) . #1#)
                                   (LETT |rec|
                                    (SPADCALL |rs| (QREFELT $ 72)) . #1#)
                                   (LETT |contradiction|
                                    (QEQCAR |rec| 1) . #1#)
                                   (EXIT
                                    (COND
                                      ((NULL |contradiction|)
                                       (LETT |finished|
                                        (COND
                                          ((SPADCALL
                                            (QCAR
                                             (PROG2
                                              (LETT #0# |rec| . #1#)
                                              (QCDR #0#)
                                               (|check-union|
                                                (QEQCAR #0# 0)
                                                (|Record|
                                                 (|:| |bas|
                                                  (|GeneralTriangularSet|
                                                   (QREFELT $ 6)
                                                   (QREFELT $ 7)
                                                   (QREFELT $ 8)
                                                   (QREFELT $ 9)))
                                                 (|:| |top|
                                                  (|List|
                                                   (QREFELT $ 9))))
                                                #0#)))
                                            |bs| (QREFELT $ 77))
                                           'NIL)
                                          ('T 'T)) . #1#)))))))))
                NIL (GO G190) G191 (EXIT NIL))
           (EXIT (COND
                   (|contradiction| (LIST (|spadConstant| $ 46)))
                   ('T |rs|))))))) 

(DEFUN |PSETPK;rewriteSetByReducingWithParticularGenerators;LMMML;23|
       (|ps| |pred?| |redOp?| |redOp| $)
  (PROG (|rec| #0=#:G2063 |ar| #1=#:G2066 |bs2| |bs1| |stop| #2=#:G2067
               |contradiction| |rs|)
    (RETURN
      (SEQ (LETT |rs| (SPADCALL (ELT $ 41) |ps| (QREFELT $ 42))
                 . #3=(|PSETPK;rewriteSetByReducingWithParticularGenerators;LMMML;23|))
           (EXIT (COND
                   ((SPADCALL (ELT $ 23) |rs| (QREFELT $ 79))
                    (LIST (|spadConstant| $ 46)))
                   ('T
                    (SEQ (LETT |contradiction| 'NIL . #3#)
                         (LETT |bs1| (SPADCALL (QREFELT $ 80)) . #3#)
                         (LETT |stop| 'NIL . #3#)
                         (SEQ G190
                              (COND
                                ((NULL (COND
                                         ((OR |contradiction| |stop|)
                                          'NIL)
                                         ('T 'T)))
                                 (GO G191)))
                              (SEQ (LETT |rec|
                                    (SPADCALL |rs| |pred?| |redOp?|
                                     (QREFELT $ 81)) . #3#)
                                   (LETT |bs2|
                                    (QCAR
                                     (PROG2 (LETT #0# |rec| . #3#)
                                      (QCDR #0#)
                                       (|check-union| (QEQCAR #0# 0)
                                        (|Record|
                                         (|:| |bas|
                                          (|GeneralTriangularSet|
                                           (QREFELT $ 6) (QREFELT $ 7)
                                           (QREFELT $ 8) (QREFELT $ 9)))
                                         (|:| |top|
                                          (|List| (QREFELT $ 9))))
                                        #0#))) . #3#)
                                   (LETT |rs|
                                    (QCDR
                                     (PROG2 (LETT #0# |rec| . #3#)
                                      (QCDR #0#)
                                       (|check-union| (QEQCAR #0# 0)
                                        (|Record|
                                         (|:| |bas|
                                          (|GeneralTriangularSet|
                                           (QREFELT $ 6) (QREFELT $ 7)
                                           (QREFELT $ 8) (QREFELT $ 9)))
                                         (|:| |top|
                                          (|List| (QREFELT $ 9))))
                                        #0#))) . #3#)
                                   (LETT |ar| (CONS 0 |bs2|) . #3#)
                                   (COND
                                     ((QEQCAR |ar| 0)
                                      (SEQ
                                       (LETT |bs2|
                                        (PROG2 (LETT #1# |ar| . #3#)
                                         (QCDR #1#)
                                          (|check-union| (QEQCAR #1# 0)
                                           (|GeneralTriangularSet|
                                            (QREFELT $ 6) (QREFELT $ 7)
                                            (QREFELT $ 8)
                                            (QREFELT $ 9))
                                           #1#)) . #3#)
                                       (COND
                                         ((SPADCALL |bs2| |bs1|
                                           (QREFELT $ 77))
                                          (SEQ
                                           (LETT |rs|
                                            (SPADCALL |rs| |bs2|
                                             |redOp| |redOp?|
                                             (QREFELT $ 83)) . #3#)
                                           (EXIT
                                            (LETT |bs1| |bs2| . #3#))))
                                         ('T (LETT |stop| 'T . #3#)))
                                       (EXIT
                                        (LETT |rs|
                                         (SPADCALL
                                          (SPADCALL |bs2|
                                           (QREFELT $ 74))
                                          |rs| (QREFELT $ 64)) . #3#))))
                                     ('T
                                      (LETT |rs|
                                       (SPADCALL
                                        (PROG2 (LETT #2# |ar| . #3#)
                                         (QCDR #2#)
                                          (|check-union| (QEQCAR #2# 1)
                                           (|List| (QREFELT $ 9)) #2#))
                                        |rs| (QREFELT $ 64)) . #3#)))
                                   (EXIT
                                    (COND
                                      ((SPADCALL (ELT $ 23) |rs|
                                        (QREFELT $ 79))
                                       (SEQ
                                        (LETT |contradiction| 'T . #3#)
                                        (EXIT
                                         (LETT |rs|
                                          (LIST (|spadConstant| $ 46)) . #3#)))))))
                              NIL (GO G190) G191 (EXIT NIL))
                         (EXIT |rs|))))))))) 

(DEFUN |PSETPK;removeRedundantFactors;2LML;24| (|lp| |lq| |remOp| $)
  (SEQ (LETT |lq| (SPADCALL |lq| |lp| 'NIL (QREFELT $ 47))
             . #0=(|PSETPK;removeRedundantFactors;2LML;24|))
       (LETT |lq| (SPADCALL |lq| |remOp|) . #0#)
       (EXIT (SPADCALL (ELT $ 14) (SPADCALL |lp| |lq| (QREFELT $ 64))
                       (QREFELT $ 16))))) 

(DEFUN |PSETPK;removeRedundantFactors;3L;25| (|lp| |lq| $)
  (SEQ (LETT |lq| (SPADCALL |lq| |lp| 'NIL (QREFELT $ 47))
             . #0=(|PSETPK;removeRedundantFactors;3L;25|))
       (LETT |lq| (SPADCALL |lq| (QREFELT $ 87)) . #0#)
       (EXIT (SPADCALL (ELT $ 14) (SPADCALL |lp| |lq| (QREFELT $ 64))
                 (QREFELT $ 16))))) 

(DEFUN |PSETPK;irreducibleFactors;2L;26| (|lp| $)
  (PROG (|p| |fp| |lrrz| #0=#:G2093 |rrz| #1=#:G2094 |lf| |newlp|)
    (RETURN
      (SEQ (LETT |newlp| NIL . #2=(|PSETPK;irreducibleFactors;2L;26|))
           (SEQ G190
                (COND
                  ((NULL (COND ((NULL |lp|) 'NIL) ('T 'T)))
                   #3=(GO G191)))
                (SEQ (LETT |p| (|SPADfirst| |lp|) . #2#)
                     (LETT |lp| (CDR |lp|) . #2#)
                     (LETT |fp| (SPADCALL |p| (QREFELT $ 91)) . #2#)
                     (LETT |lrrz| (SPADCALL |fp| (QREFELT $ 94)) . #2#)
                     (LETT |lf|
                           (SPADCALL (ELT $ 23)
                               (PROGN
                                 (LETT #0# NIL . #2#)
                                 (SEQ (LETT |rrz| NIL . #2#)
                                      (LETT #1# |lrrz| . #2#) G190
                                      (COND
                                        ((OR (ATOM #1#)
                                          (PROGN
                                            (LETT |rrz|
                                             (CAR #1#) . #2#)
                                            NIL))
                                         #3#))
                                      (SEQ
                                       (EXIT
                                        (LETT #0#
                                         (CONS (QCAR |rrz|) #0#) . #2#)))
                                      (LETT #1# (CDR #1#) . #2#)
                                      #4=(GO G190) G191
                                      (EXIT (NREVERSE0 #0#))))
                               (QREFELT $ 42)) . #2#)
                     (EXIT (LETT |newlp|
                                 (SPADCALL |lf| |newlp| (QREFELT $ 64)) . #2#)))
                NIL #4# G191 (EXIT NIL))
           (EXIT (SPADCALL |newlp| (QREFELT $ 12))))))) 

(DEFUN |PSETPK;lazyIrreducibleFactors;2L;27| (|lp| $)
  (PROG (|p| |fp| |lrrz| #0=#:G2102 |rrz| #1=#:G2103 |lf| |newlp|)
    (RETURN
      (SEQ (LETT |lp| (SPADCALL |lp| (QREFELT $ 87))
                 . #2=(|PSETPK;lazyIrreducibleFactors;2L;27|))
           (LETT |newlp| NIL . #2#)
           (SEQ G190
                (COND
                  ((NULL (COND ((NULL |lp|) 'NIL) ('T 'T)))
                   #3=(GO G191)))
                (SEQ (LETT |p| (|SPADfirst| |lp|) . #2#)
                     (LETT |lp| (CDR |lp|) . #2#)
                     (LETT |fp| (SPADCALL |p| (QREFELT $ 91)) . #2#)
                     (LETT |lrrz| (SPADCALL |fp| (QREFELT $ 94)) . #2#)
                     (LETT |lf|
                           (SPADCALL (ELT $ 23)
                               (PROGN
                                 (LETT #0# NIL . #2#)
                                 (SEQ (LETT |rrz| NIL . #2#)
                                      (LETT #1# |lrrz| . #2#) G190
                                      (COND
                                        ((OR (ATOM #1#)
                                          (PROGN
                                            (LETT |rrz|
                                             (CAR #1#) . #2#)
                                            NIL))
                                         #3#))
                                      (SEQ
                                       (EXIT
                                        (LETT #0#
                                         (CONS (QCAR |rrz|) #0#) . #2#)))
                                      (LETT #1# (CDR #1#) . #2#)
                                      #4=(GO G190) G191
                                      (EXIT (NREVERSE0 #0#))))
                               (QREFELT $ 42)) . #2#)
                     (EXIT (LETT |newlp|
                                 (SPADCALL |lf| |newlp| (QREFELT $ 64)) . #2#)))
                NIL #4# G191 (EXIT NIL))
           (EXIT |newlp|))))) 

(DEFUN |PSETPK;removeIrreducibleRedundantFactors;3L;28| (|lp| |lq| $)
  (SEQ (LETT |lq| (SPADCALL |lq| |lp| 'NIL (QREFELT $ 47))
             . #0=(|PSETPK;removeIrreducibleRedundantFactors;3L;28|))
       (LETT |lq| (SPADCALL |lq| (QREFELT $ 95)) . #0#)
       (EXIT (SPADCALL (ELT $ 14) (SPADCALL |lp| |lq| (QREFELT $ 64))
                 (QREFELT $ 16))))) 

(DEFUN |PSETPK;squareFreeFactors;PL;29| (|p| $)
  (PROG (|sfp| #0=#:G2110 |foo| #1=#:G2111 |lsf|)
    (RETURN
      (SEQ (LETT |sfp| (SPADCALL |p| (QREFELT $ 99))
                 . #2=(|PSETPK;squareFreeFactors;PL;29|))
           (LETT |lsf|
                 (PROGN
                   (LETT #0# NIL . #2#)
                   (SEQ (LETT |foo| NIL . #2#)
                        (LETT #1#
                              (SPADCALL |sfp| (QREFELT $ 94)) . #2#)
                        G190
                        (COND
                          ((OR (ATOM #1#)
                               (PROGN
                                 (LETT |foo| (CAR #1#) . #2#)
                                 NIL))
                           (GO G191)))
                        (SEQ (EXIT (LETT #0#
                                    (CONS (QCAR |foo|) #0#) . #2#)))
                        (LETT #1# (CDR #1#) . #2#) (GO G190) G191
                        (EXIT (NREVERSE0 #0#)))) . #2#)
           (EXIT |lsf|))))) 

(DEFUN |PSETPK;univariatePolynomialsGcds;LBL;30| (|ps| |opt| $)
  (PROG (|v| |p| |pInV| |g| |stop| |lg|)
    (RETURN
      (SEQ (LETT |lg| NIL
                 . #0=(|PSETPK;univariatePolynomialsGcds;LBL;30|))
           (LETT |stop| 'NIL . #0#)
           (LETT |ps| (SPADCALL (ELT $ 14) |ps| (QREFELT $ 16)) . #0#)
           (SEQ G190
                (COND
                  ((NULL (COND ((OR (NULL |ps|) |stop|) 'NIL) ('T 'T)))
                   #1=(GO G191)))
                (SEQ (SEQ G190
                          (COND
                            ((NULL (COND
                                     ((OR (NULL |ps|)
                                       (SPADCALL
                                        (LETT |p|
                                         (|SPADfirst| |ps|) . #0#)
                                        (QREFELT $ 33)))
                                      'NIL)
                                     ('T 'T)))
                             #1#))
                          (SEQ (EXIT (LETT |ps| (CDR |ps|) . #0#))) NIL
                          #2=(GO G190) G191 (EXIT NIL))
                     (EXIT (COND
                             ((NULL (NULL |ps|))
                              (SEQ (LETT |v|
                                    (SPADCALL |p| (QREFELT $ 31)) . #0#)
                                   (LETT |pInV| (LIST |p|) . #0#)
                                   (SEQ G190
                                    (COND
                                      ((NULL
                                        (COND
                                          ((NULL |ps|) 'NIL)
                                          ('T
                                           (SPADCALL
                                            (SPADCALL
                                             (LETT |p|
                                              (|SPADfirst| |ps|) . #0#)
                                             (QREFELT $ 31))
                                            |v| (QREFELT $ 32)))))
                                       #1#))
                                    (SEQ
                                     (COND
                                       ((SPADCALL |p| (QREFELT $ 33))
                                        (LETT |pInV|
                                         (CONS |p| |pInV|) . #0#)))
                                     (EXIT
                                      (LETT |ps| (CDR |ps|) . #0#)))
                                    NIL #2# G191 (EXIT NIL))
                                   (LETT |g|
                                    (SPADCALL |pInV| (QREFELT $ 102)) . #0#)
                                   (LETT |stop|
                                    (COND
                                      (|opt|
                                       (SPADCALL |g| (QREFELT $ 23)))
                                      ('T 'NIL)) . #0#)
                                   (EXIT
                                    (LETT |lg| (CONS |g| |lg|) . #0#)))))))
                NIL #2# G191 (EXIT NIL))
           (EXIT (COND
                   (|stop| (LIST (|spadConstant| $ 46)))
                   ('T |lg|))))))) 

(DEFUN |PSETPK;univariatePolynomialsGcds;2L;31| (|ps| $)
  (SPADCALL |ps| 'NIL (QREFELT $ 103))) 

(DEFUN |PSETPK;removeSquaresIfCan;2L;32| (|lp| $)
  (PROG (#0=#:G2129 |p| #1=#:G2130)
    (RETURN
      (SEQ (COND
             ((NULL |lp|) |lp|)
             ('T
              (SPADCALL
                  (PROGN
                    (LETT #0# NIL
                          . #2=(|PSETPK;removeSquaresIfCan;2L;32|))
                    (SEQ (LETT |p| NIL . #2#) (LETT #1# |lp| . #2#)
                         G190
                         (COND
                           ((OR (ATOM #1#)
                                (PROGN (LETT |p| (CAR #1#) . #2#) NIL))
                            (GO G191)))
                         (SEQ (EXIT (LETT #0#
                                     (CONS
                                      (SPADCALL |p| (QREFELT $ 105))
                                      #0#) . #2#)))
                         (LETT #1# (CDR #1#) . #2#) (GO G190) G191
                         (EXIT (NREVERSE0 #0#))))
                  (QREFELT $ 12)))))))) 

(DEFUN |PSETPK;rewriteIdealWithQuasiMonicGenerators;LMML;33|
       (|ps| |redOp?| |redOp| $)
  (PROG (|ups|)
    (RETURN
      (SEQ (LETT |ups|
                 (SPADCALL (SPADCALL |ps| 'T (QREFELT $ 103))
                     (QREFELT $ 106))
                 . #0=(|PSETPK;rewriteIdealWithQuasiMonicGenerators;LMML;33|))
           (LETT |ps|
                 (SPADCALL (SPADCALL |ups| |ps| (QREFELT $ 64))
                     (QREFELT $ 12)) . #0#)
           (EXIT (SPADCALL |ps| (ELT $ 39) |redOp?| |redOp|
                     (QREFELT $ 84))))))) 

(DEFUN |PSETPK;removeRoughlyRedundantFactorsInContents;3L;34|
       (|ps| |lf| $)
  (PROG (|p| |cp| #0=#:G2151 #1=#:G2152 |f| |copylf| |test| #2=#:G2134
             |newcp| |newp| |newps|)
    (RETURN
      (SEQ (COND
             ((NULL |ps|) |ps|)
             ('T
              (SEQ (LETT |newps| NIL
                         . #3=(|PSETPK;removeRoughlyRedundantFactorsInContents;3L;34|))
                   (SEQ G190
                        (COND
                          ((NULL (COND ((NULL |ps|) 'NIL) ('T 'T)))
                           #4=(GO G191)))
                        (SEQ (LETT |p| (|SPADfirst| |ps|) . #3#)
                             (LETT |ps| (CDR |ps|) . #3#)
                             (LETT |cp|
                                   (SPADCALL |p| (QREFELT $ 108)) . #3#)
                             (LETT |newcp|
                                   (SPADCALL |cp| (QREFELT $ 105)) . #3#)
                             (LETT |newp|
                                   (PROG2
                                    (LETT #2#
                                     (SPADCALL |p| |cp| (QREFELT $ 44)) . #3#)
                                    (QCDR #2#)
                                     (|check-union| (QEQCAR #2# 0)
                                      (QREFELT $ 9) #2#)) . #3#)
                             (COND
                               ((NULL (SPADCALL |newcp| (QREFELT $ 23)))
                                (SEQ (LETT |copylf|
                                      (PROGN
                                        (LETT #0# NIL . #3#)
                                        (SEQ (LETT |f| NIL . #3#)
                                         (LETT #1# |lf| . #3#) G190
                                         (COND
                                           ((OR (ATOM #1#)
                                             (PROGN
                                               (LETT |f|
                                                (CAR #1#) . #3#)
                                               NIL))
                                            #4#))
                                         (SEQ
                                          (EXIT
                                           (COND
                                             ((COND
                                                ((SPADCALL
                                                  (SPADCALL |newcp|
                                                   (QREFELT $ 31))
                                                  (SPADCALL |f|
                                                   (QREFELT $ 31))
                                                  (QREFELT $ 36))
                                                 'NIL)
                                                ('T 'T))
                                              (LETT #0#
                                               (CONS |f| #0#) . #3#)))))
                                         (LETT #1# (CDR #1#) . #3#)
                                         #5=(GO G190) G191
                                         (EXIT (NREVERSE0 #0#)))) . #3#)
                                     (EXIT
                                      (SEQ G190
                                       (COND
                                         ((NULL
                                           (COND
                                             ((OR (NULL |copylf|)
                                               (SPADCALL |newcp|
                                                (QREFELT $ 23)))
                                              'NIL)
                                             ('T 'T)))
                                          #4#))
                                       (SEQ
                                        (LETT |f|
                                         (|SPADfirst| |copylf|) . #3#)
                                        (LETT |copylf|
                                         (CDR |copylf|) . #3#)
                                        (LETT |test|
                                         (SPADCALL |newcp| |f|
                                          (QREFELT $ 44)) . #3#)
                                        (EXIT
                                         (COND
                                           ((QEQCAR |test| 0)
                                            (LETT |newcp|
                                             (PROG2
                                              (LETT #2# |test| . #3#)
                                              (QCDR #2#)
                                               (|check-union|
                                                (QEQCAR #2# 0)
                                                (QREFELT $ 9) #2#)) . #3#)))))
                                       NIL #5# G191 (EXIT NIL))))))
                             (COND
                               ((SPADCALL |newcp| (QREFELT $ 23))
                                (LETT |newp|
                                      (SPADCALL |newp| (QREFELT $ 45)) . #3#))
                               ('T
                                (LETT |newp|
                                      (SPADCALL
                                       (SPADCALL |newp| |newcp|
                                        (QREFELT $ 109))
                                       (QREFELT $ 45)) . #3#)))
                             (EXIT (LETT |newps|
                                    (CONS |newp| |newps|) . #3#)))
                        NIL #5# G191 (EXIT NIL))
                   (EXIT |newps|)))))))) 

(DEFUN |PSETPK;removeRedundantFactorsInContents;3L;35| (|ps| |lf| $)
  (PROG (|p| |cp| |f| |copylf| |g| #0=#:G2155 |newcp| |newp| |newps|)
    (RETURN
      (SEQ (COND
             ((NULL |ps|) |ps|)
             ('T
              (SEQ (LETT |newps| NIL
                         . #1=(|PSETPK;removeRedundantFactorsInContents;3L;35|))
                   (SEQ G190
                        (COND
                          ((NULL (COND ((NULL |ps|) 'NIL) ('T 'T)))
                           #2=(GO G191)))
                        (SEQ (LETT |p| (|SPADfirst| |ps|) . #1#)
                             (LETT |ps| (CDR |ps|) . #1#)
                             (LETT |cp|
                                   (SPADCALL |p| (QREFELT $ 108)) . #1#)
                             (LETT |newcp|
                                   (SPADCALL |cp| (QREFELT $ 105)) . #1#)
                             (LETT |newp|
                                   (PROG2
                                    (LETT #0#
                                     (SPADCALL |p| |cp| (QREFELT $ 44)) . #1#)
                                    (QCDR #0#)
                                     (|check-union| (QEQCAR #0# 0)
                                      (QREFELT $ 9) #0#)) . #1#)
                             (COND
                               ((NULL (SPADCALL |newcp| (QREFELT $ 23)))
                                (SEQ (LETT |copylf| |lf| . #1#)
                                     (EXIT
                                      (SEQ G190
                                       (COND
                                         ((NULL
                                           (COND
                                             ((OR (NULL |copylf|)
                                               (SPADCALL |newcp|
                                                (QREFELT $ 23)))
                                              'NIL)
                                             ('T 'T)))
                                          #2#))
                                       (SEQ
                                        (LETT |f|
                                         (|SPADfirst| |copylf|) . #1#)
                                        (LETT |copylf|
                                         (CDR |copylf|) . #1#)
                                        (LETT |g|
                                         (SPADCALL |newcp| |f|
                                          (QREFELT $ 111)) . #1#)
                                        (EXIT
                                         (COND
                                           ((NULL
                                             (SPADCALL |g|
                                              (QREFELT $ 23)))
                                            (LETT |newcp|
                                             (PROG2
                                              (LETT #0#
                                               (SPADCALL |newcp| |g|
                                                (QREFELT $ 44)) . #1#)
                                              (QCDR #0#)
                                               (|check-union|
                                                (QEQCAR #0# 0)
                                                (QREFELT $ 9) #0#)) . #1#)))))
                                       NIL #3=(GO G190) G191
                                       (EXIT NIL))))))
                             (COND
                               ((SPADCALL |newcp| (QREFELT $ 23))
                                (LETT |newp|
                                      (SPADCALL |newp| (QREFELT $ 45)) . #1#))
                               ('T
                                (LETT |newp|
                                      (SPADCALL
                                       (SPADCALL |newp| |newcp|
                                        (QREFELT $ 109))
                                       (QREFELT $ 45)) . #1#)))
                             (EXIT (LETT |newps|
                                    (CONS |newp| |newps|) . #1#)))
                        NIL #3# G191 (EXIT NIL))
                   (EXIT |newps|)))))))) 

(DEFUN |PSETPK;removeRedundantFactorsInPols;3L;36| (|ps| |lf| $)
  (PROG (|p| |cp| |f| |copylf| |newcp| |g| #0=#:G2171 |newp| |newps|)
    (RETURN
      (SEQ (COND
             ((NULL |ps|) |ps|)
             ('T
              (SEQ (LETT |newps| NIL
                         . #1=(|PSETPK;removeRedundantFactorsInPols;3L;36|))
                   (SEQ G190
                        (COND
                          ((NULL (COND ((NULL |ps|) 'NIL) ('T 'T)))
                           #2=(GO G191)))
                        (SEQ (LETT |p| (|SPADfirst| |ps|) . #1#)
                             (LETT |ps| (CDR |ps|) . #1#)
                             (LETT |cp|
                                   (SPADCALL |p| (QREFELT $ 108)) . #1#)
                             (LETT |newcp|
                                   (SPADCALL |cp| (QREFELT $ 105)) . #1#)
                             (LETT |newp|
                                   (PROG2
                                    (LETT #0#
                                     (SPADCALL |p| |cp| (QREFELT $ 44)) . #1#)
                                    (QCDR #0#)
                                     (|check-union| (QEQCAR #0# 0)
                                      (QREFELT $ 9) #0#)) . #1#)
                             (LETT |newp|
                                   (SPADCALL |newp| (QREFELT $ 105)) . #1#)
                             (LETT |copylf| |lf| . #1#)
                             (SEQ G190
                                  (COND
                                    ((NULL
                                      (COND
                                        ((NULL |copylf|) 'NIL)
                                        ('T 'T)))
                                     #2#))
                                  (SEQ (LETT |f|
                                        (|SPADfirst| |copylf|) . #1#)
                                       (LETT |copylf|
                                        (CDR |copylf|) . #1#)
                                       (COND
                                         ((NULL
                                           (SPADCALL |newcp|
                                            (QREFELT $ 23)))
                                          (SEQ
                                           (LETT |g|
                                            (SPADCALL |newcp| |f|
                                             (QREFELT $ 111)) . #1#)
                                           (EXIT
                                            (COND
                                              ((NULL
                                                (SPADCALL |g|
                                                 (QREFELT $ 23)))
                                               (LETT |newcp|
                                                (PROG2
                                                 (LETT #0#
                                                  (SPADCALL |newcp| |g|
                                                   (QREFELT $ 44)) . #1#)
                                                 (QCDR #0#)
                                                  (|check-union|
                                                   (QEQCAR #0# 0)
                                                   (QREFELT $ 9) #0#)) . #1#)))))))
                                       (EXIT
                                        (COND
                                          ((NULL
                                            (SPADCALL |newp|
                                             (QREFELT $ 23)))
                                           (SEQ
                                            (LETT |g|
                                             (SPADCALL |newp| |f|
                                              (QREFELT $ 111)) . #1#)
                                            (EXIT
                                             (COND
                                               ((NULL
                                                 (SPADCALL |g|
                                                  (QREFELT $ 23)))
                                                (LETT |newp|
                                                 (PROG2
                                                  (LETT #0#
                                                   (SPADCALL |newp| |g|
                                                    (QREFELT $ 44)) . #1#)
                                                  (QCDR #0#)
                                                   (|check-union|
                                                    (QEQCAR #0# 0)
                                                    (QREFELT $ 9) #0#)) . #1#)))))))))
                                  NIL #3=(GO G190) G191 (EXIT NIL))
                             (COND
                               ((SPADCALL |newcp| (QREFELT $ 23))
                                (LETT |newp|
                                      (SPADCALL |newp| (QREFELT $ 45)) . #1#))
                               ('T
                                (LETT |newp|
                                      (SPADCALL
                                       (SPADCALL |newp| |newcp|
                                        (QREFELT $ 109))
                                       (QREFELT $ 45)) . #1#)))
                             (EXIT (LETT |newps|
                                    (CONS |newp| |newps|) . #1#)))
                        NIL #3# G191 (EXIT NIL))
                   (EXIT |newps|)))))))) 

(DEFUN |PSETPK;removeRedundantFactors;2PL;37| (|a| |b| $)
  (PROG (|#G87| |#G88| #0=#:G2189)
    (RETURN
      (SEQ (EXIT (SEQ (LETT |a|
                            (SPADCALL (SPADCALL |a| (QREFELT $ 105))
                                (QREFELT $ 10))
                            . #1=(|PSETPK;removeRedundantFactors;2PL;37|))
                      (LETT |b|
                            (SPADCALL (SPADCALL |b| (QREFELT $ 105))
                                (QREFELT $ 10)) . #1#)
                      (COND
                        ((NULL (SPADCALL |a| |b| (QREFELT $ 14)))
                         (PROGN
                           (LETT |#G87| |b| . #1#)
                           (LETT |#G88| |a| . #1#)
                           (LETT |a| |#G87| . #1#)
                           (LETT |b| |#G88| . #1#))))
                      (EXIT (COND
                              ((SPADCALL |a| (QREFELT $ 23))
                               (COND
                                 ((SPADCALL |b| (QREFELT $ 23))
                                  (PROGN
                                    (LETT #0# NIL . #1#)
                                    (GO #0#)))
                                 ('T
                                  (PROGN
                                    (LETT #0# (LIST |b|) . #1#)
                                    (GO #0#)))))
                              ((SPADCALL |b| (QREFELT $ 23))
                               (PROGN
                                 (LETT #0# (LIST |a|) . #1#)
                                 (GO #0#)))
                              ('T
                               (PROGN
                                 (LETT #0#
                                       (SPADCALL |a| |b|
                                        (QREFELT $ 114)) . #1#)
                                 (GO #0#)))))))
           #0# (EXIT #0#))))) 

(DEFUN |PSETPK;unprotectedRemoveRedundantFactors;2PL;38| (|a| |b| $)
  (PROG (|c| |d| |g| #0=#:G2191 #1=#:G2196)
    (RETURN
      (SEQ (EXIT (SEQ (LETT |c| (SPADCALL |b| |a| (QREFELT $ 44))
                            . #2=(|PSETPK;unprotectedRemoveRedundantFactors;2PL;38|))
                      (EXIT (COND
                              ((QEQCAR |c| 0)
                               (SEQ (LETT |d|
                                     (PROG2 (LETT #0# |c| . #2#)
                                      (QCDR #0#)
                                       (|check-union| (QEQCAR #0# 0)
                                        (QREFELT $ 9) #0#)) . #2#)
                                    (EXIT
                                     (COND
                                       ((SPADCALL |d| (QREFELT $ 23))
                                        (PROGN
                                          (LETT #1# (LIST |a|) . #2#)
                                          (GO #1#)))
                                       ('T
                                        (PROGN
                                          (LETT #1#
                                           (LIST |a| |d|) . #2#)
                                          (GO #1#)))))))
                              ('T
                               (SEQ (LETT |g|
                                     (SPADCALL |a| |b| (QREFELT $ 111)) . #2#)
                                    (EXIT
                                     (COND
                                       ((SPADCALL |g| (QREFELT $ 23))
                                        (PROGN
                                          (LETT #1#
                                           (LIST |a| |b|) . #2#)
                                          (GO #1#)))
                                       ('T
                                        (PROGN
                                          (LETT #1#
                                           (LIST |g|
                                            (PROG2
                                             (LETT #0#
                                              (SPADCALL |a| |g|
                                               (QREFELT $ 44)) . #2#)
                                             (QCDR #0#)
                                              (|check-union|
                                               (QEQCAR #0# 0)
                                               (QREFELT $ 9) #0#))
                                            (PROG2
                                             (LETT #0#
                                              (SPADCALL |b| |g|
                                               (QREFELT $ 44)) . #2#)
                                             (QCDR #0#)
                                              (|check-union|
                                               (QEQCAR #0# 0)
                                               (QREFELT $ 9) #0#))) . #2#)
                                          (GO #1#)))))))))))
           #1# (EXIT #1#))))) 

(PUT '|PSETPK;removeSquaresIfCan;2L;39| '|SPADreplace|
     '(XLAM (|lp|) |lp|)) 

(DEFUN |PSETPK;removeSquaresIfCan;2L;39| (|lp| $) |lp|) 

(DEFUN |PSETPK;rewriteIdealWithQuasiMonicGenerators;LMML;40|
       (|ps| |redOp?| |redOp| $)
  (SPADCALL |ps| (ELT $ 39) |redOp?| |redOp| (QREFELT $ 84))) 

(DEFUN |PSETPK;removeRedundantFactors;2PL;41| (|a| |b| $)
  (PROG (|#G97| |#G98| #0=#:G2203)
    (RETURN
      (SEQ (EXIT (SEQ (LETT |a| (SPADCALL |a| (QREFELT $ 10))
                            . #1=(|PSETPK;removeRedundantFactors;2PL;41|))
                      (LETT |b| (SPADCALL |b| (QREFELT $ 10)) . #1#)
                      (COND
                        ((NULL (SPADCALL |a| |b| (QREFELT $ 14)))
                         (PROGN
                           (LETT |#G97| |b| . #1#)
                           (LETT |#G98| |a| . #1#)
                           (LETT |a| |#G97| . #1#)
                           (LETT |b| |#G98| . #1#))))
                      (EXIT (COND
                              ((SPADCALL |a| (QREFELT $ 23))
                               (COND
                                 ((SPADCALL |b| (QREFELT $ 23))
                                  (PROGN
                                    (LETT #0# NIL . #1#)
                                    (GO #0#)))
                                 ('T
                                  (PROGN
                                    (LETT #0# (LIST |b|) . #1#)
                                    (GO #0#)))))
                              ((SPADCALL |b| (QREFELT $ 23))
                               (PROGN
                                 (LETT #0# (LIST |a|) . #1#)
                                 (GO #0#)))
                              ('T
                               (PROGN
                                 (LETT #0#
                                       (SPADCALL |a| |b|
                                        (QREFELT $ 114)) . #1#)
                                 (GO #0#)))))))
           #0# (EXIT #0#))))) 

(DEFUN |PSETPK;unprotectedRemoveRedundantFactors;2PL;42| (|a| |b| $)
  (PROG (|c| #0=#:G2205 |#G101| |#G102| |d| #1=#:G2211)
    (RETURN
      (SEQ (EXIT (SEQ (LETT |c| (SPADCALL |b| |a| (QREFELT $ 44))
                            . #2=(|PSETPK;unprotectedRemoveRedundantFactors;2PL;42|))
                      (EXIT (COND
                              ((QEQCAR |c| 0)
                               (SEQ (LETT |d|
                                     (PROG2 (LETT #0# |c| . #2#)
                                      (QCDR #0#)
                                       (|check-union| (QEQCAR #0# 0)
                                        (QREFELT $ 9) #0#)) . #2#)
                                    (EXIT
                                     (COND
                                       ((SPADCALL |d| (QREFELT $ 23))
                                        (PROGN
                                          (LETT #1# (LIST |a|) . #2#)
                                          (GO #1#)))
                                       ('T
                                        (SEQ
                                         (COND
                                           ((SPADCALL |d| |a|
                                             (QREFELT $ 14))
                                            (PROGN
                                              (LETT |#G101| |d| . #2#)
                                              (LETT |#G102| |a| . #2#)
                                              (LETT |a| |#G101| . #2#)
                                              (LETT |d| |#G102| . #2#))))
                                         (EXIT
                                          (PROGN
                                            (LETT #1#
                                             (SPADCALL |a| |d|
                                              (QREFELT $ 114)) . #2#)
                                            (GO #1#)))))))))
                              ('T
                               (PROGN
                                 (LETT #1# (LIST |a| |b|) . #2#)
                                 (GO #1#)))))))
           #1# (EXIT #1#))))) 

(DEFUN |PSETPK;removeRedundantFactors;2L;43| (|lp| $)
  (PROG (#0=#:G2221 #1=#:G2222 #2=#:G2223 #3=#:G2224 |p| |base| |top|)
    (RETURN
      (SEQ (LETT |lp| (SPADCALL (ELT $ 23) |lp| (QREFELT $ 42))
                 . #4=(|PSETPK;removeRedundantFactors;2L;43|))
           (LETT |lp|
                 (SPADCALL
                     (PROGN
                       (LETT #0# NIL . #4#)
                       (SEQ (LETT |p| NIL . #4#) (LETT #1# |lp| . #4#)
                            G190
                            (COND
                              ((OR (ATOM #1#)
                                   (PROGN
                                     (LETT |p| (CAR #1#) . #4#)
                                     NIL))
                               #5=(GO G191)))
                            (SEQ (EXIT (LETT #0#
                                        (CONS
                                         (SPADCALL |p| (QREFELT $ 10))
                                         #0#) . #4#)))
                            (LETT #1# (CDR #1#) . #4#) #6=(GO G190)
                            G191 (EXIT (NREVERSE0 #0#))))
                     (QREFELT $ 12)) . #4#)
           (LETT |lp| (SPADCALL |lp| (QREFELT $ 106)) . #4#)
           (LETT |lp|
                 (SPADCALL
                     (PROGN
                       (LETT #2# NIL . #4#)
                       (SEQ (LETT |p| NIL . #4#) (LETT #3# |lp| . #4#)
                            G190
                            (COND
                              ((OR (ATOM #3#)
                                   (PROGN
                                     (LETT |p| (CAR #3#) . #4#)
                                     NIL))
                               #5#))
                            (SEQ (EXIT (LETT #2#
                                        (CONS
                                         (SPADCALL |p| (QREFELT $ 45))
                                         #2#) . #4#)))
                            (LETT #3# (CDR #3#) . #4#) #6# G191
                            (EXIT (NREVERSE0 #2#))))
                     (QREFELT $ 12)) . #4#)
           (EXIT (COND
                   ((OR (NULL |lp|) (SPADCALL |lp| 1 (QREFELT $ 116)))
                    |lp|)
                   ('T
                    (SEQ (LETT |lp|
                               (SPADCALL (ELT $ 14) |lp|
                                   (QREFELT $ 16)) . #4#)
                         (LETT |p| (|SPADfirst| |lp|) . #4#)
                         (LETT |lp| (CDR |lp|) . #4#)
                         (LETT |base|
                               (SPADCALL |p| (|SPADfirst| |lp|)
                                   (QREFELT $ 114)) . #4#)
                         (LETT |top| (CDR |lp|) . #4#)
                         (SEQ G190
                              (COND
                                ((NULL (COND
                                         ((NULL |top|) 'NIL)
                                         ('T 'T)))
                                 #5#))
                              (SEQ (LETT |p| (|SPADfirst| |top|) . #4#)
                                   (LETT |base|
                                    (SPADCALL |base| |p|
                                     (QREFELT $ 117)) . #4#)
                                   (EXIT
                                    (LETT |top| (CDR |top|) . #4#)))
                              NIL #6# G191 (EXIT NIL))
                         (EXIT |base|))))))))) 

(DEFUN |PSETPK;removeRedundantFactors;LPL;44| (|lp| |a| $)
  (PROG (|b| |#G108| |#G109| |#G110| |#G111| |c| |toSee| |d| |rrf| |e|
             |toSave|)
    (RETURN
      (SEQ (LETT |lp| (SPADCALL (ELT $ 23) |lp| (QREFELT $ 42))
                 . #0=(|PSETPK;removeRedundantFactors;LPL;44|))
           (LETT |lp| (SPADCALL (ELT $ 14) |lp| (QREFELT $ 16)) . #0#)
           (EXIT (COND
                   ((SPADCALL |a| (QREFELT $ 23)) |lp|)
                   ((NULL |lp|) (LIST |a|))
                   ('T
                    (SEQ (LETT |toSee| |lp| . #0#)
                         (LETT |toSave| NIL . #0#)
                         (SEQ G190
                              (COND
                                ((NULL (COND
                                         ((NULL |toSee|) 'NIL)
                                         ('T 'T)))
                                 (GO G191)))
                              (SEQ (LETT |b|
                                    (|SPADfirst| |toSee|) . #0#)
                                   (LETT |toSee| (CDR |toSee|) . #0#)
                                   (COND
                                     ((SPADCALL |b| |a| (QREFELT $ 14))
                                      (PROGN
                                        (LETT |#G108| |b| . #0#)
                                        (LETT |#G109| |a| . #0#)
                                        (LETT |c| |#G108| . #0#)
                                        (LETT |d| |#G109| . #0#)))
                                     ('T
                                      (PROGN
                                        (LETT |#G110| |a| . #0#)
                                        (LETT |#G111| |b| . #0#)
                                        (LETT |c| |#G110| . #0#)
                                        (LETT |d| |#G111| . #0#))))
                                   (LETT |rrf|
                                    (SPADCALL |c| |d| (QREFELT $ 114)) . #0#)
                                   (EXIT
                                    (COND
                                      ((NULL |rrf|)
                                       (|error|
                                        "in removeRedundantFactors : (LP,P) -> LP from PSETPK"))
                                      ('T
                                       (SEQ
                                        (LETT |c|
                                         (|SPADfirst| |rrf|) . #0#)
                                        (LETT |rrf| (CDR |rrf|) . #0#)
                                        (COND
                                          ((NULL |rrf|)
                                           (COND
                                             ((SPADCALL |c| |b|
                                               (QREFELT $ 63))
                                              (SEQ
                                               (LETT |toSave|
                                                (SPADCALL |toSave|
                                                 |toSee|
                                                 (QREFELT $ 64)) . #0#)
                                               (LETT |a| |b| . #0#)
                                               (EXIT
                                                (LETT |toSee|
                                                 NIL . #0#))))
                                             ('T
                                              (SEQ (LETT |a| |c| . #0#)
                                               (LETT |toSee|
                                                (SPADCALL |toSave|
                                                 |toSee|
                                                 (QREFELT $ 64)) . #0#)
                                               (EXIT
                                                (LETT |toSave|
                                                 NIL . #0#))))))
                                          ('T
                                           (SEQ
                                            (LETT |d|
                                             (|SPADfirst| |rrf|) . #0#)
                                            (LETT |rrf|
                                             (CDR |rrf|) . #0#)
                                            (EXIT
                                             (COND
                                               ((NULL |rrf|)
                                                (COND
                                                  ((SPADCALL |c| |b|
                                                    (QREFELT $ 63))
                                                   (SEQ
                                                    (LETT |toSave|
                                                     (SPADCALL |toSave|
                                                      (LIST |b|)
                                                      (QREFELT $ 64)) . #0#)
                                                    (EXIT
                                                     (LETT |a|
                                                      |d| . #0#))))
                                                  ((SPADCALL |d| |b|
                                                    (QREFELT $ 63))
                                                   (SEQ
                                                    (LETT |toSave|
                                                     (SPADCALL |toSave|
                                                      (LIST |b|)
                                                      (QREFELT $ 64)) . #0#)
                                                    (EXIT
                                                     (LETT |a|
                                                      |c| . #0#))))
                                                  ('T
                                                   (SEQ
                                                    (LETT |toSave|
                                                     (SPADCALL |toSave|
                                                      |c|
                                                      (QREFELT $ 117)) . #0#)
                                                    (EXIT
                                                     (LETT |a|
                                                      |d| . #0#))))))
                                               ('T
                                                (SEQ
                                                 (LETT |e|
                                                  (|SPADfirst| |rrf|) . #0#)
                                                 (COND
                                                   ((NULL
                                                     (NULL (CDR |rrf|)))
                                                    (EXIT
                                                     (|error|
                                                      "in removeRedundantFactors:(LP,P)->LP from PSETPK"))))
                                                 (LETT |toSave|
                                                  (SPADCALL |toSave|
                                                   |c| (QREFELT $ 117)) . #0#)
                                                 (LETT |toSave|
                                                  (SPADCALL |toSave|
                                                   |d| (QREFELT $ 117)) . #0#)
                                                 (EXIT
                                                  (LETT |a| |e| . #0#)))))))))
                                        (EXIT
                                         (COND
                                           ((NULL |toSee|)
                                            (LETT |toSave|
                                             (SPADCALL (ELT $ 14)
                                              (CONS |a| |toSave|)
                                              (QREFELT $ 16)) . #0#)))))))))
                              NIL (GO G190) G191 (EXIT NIL))
                         (EXIT |toSave|))))))))) 

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

(DEFUN |PolynomialSetUtilitiesPackage;| (|#1| |#2| |#3| |#4|)
  (PROG (DV$1 DV$2 DV$3 DV$4 |dv$| $ |pv$|)
    (RETURN
      (PROGN
        (LETT DV$1 (|devaluate| |#1|)
              . #0=(|PolynomialSetUtilitiesPackage|))
        (LETT DV$2 (|devaluate| |#2|) . #0#)
        (LETT DV$3 (|devaluate| |#3|) . #0#)
        (LETT DV$4 (|devaluate| |#4|) . #0#)
        (LETT |dv$|
              (LIST '|PolynomialSetUtilitiesPackage| DV$1 DV$2 DV$3
                    DV$4) . #0#)
        (LETT $ (GETREFV 118) . #0#)
        (QSETREFV $ 0 |dv$|)
        (QSETREFV $ 3
            (LETT |pv$|
                  (|buildPredVector| 0 0
                      (LIST (AND (|HasCategory| |#1|
                                     '(|CharacteristicZero|))
                                 (|HasCategory| |#1|
                                     '(|EuclideanDomain|)))
                            (|HasCategory| |#1| '(|GcdDomain|)))) . #0#))
        (|haddProp| |$ConstructorCache|
            '|PolynomialSetUtilitiesPackage| (LIST DV$1 DV$2 DV$3 DV$4)
            (CONS 1 $))
        (|stuffDomainSlots| $)
        (QSETREFV $ 6 |#1|)
        (QSETREFV $ 7 |#2|)
        (QSETREFV $ 8 |#3|)
        (QSETREFV $ 9 |#4|)
        (COND
          ((|HasCategory| |#1| '(|EuclideanDomain|))
           (COND
             ((|HasCategory| |#1| '(|CharacteristicZero|))
              (PROGN
                (QSETREFV $ 95
                    (CONS (|dispatchFunction|
                              |PSETPK;irreducibleFactors;2L;26|)
                          $))
                (QSETREFV $ 96
                    (CONS (|dispatchFunction|
                              |PSETPK;lazyIrreducibleFactors;2L;27|)
                          $))
                (QSETREFV $ 97
                    (CONS (|dispatchFunction|
                              |PSETPK;removeIrreducibleRedundantFactors;3L;28|)
                          $)))))))
        (COND
          ((|testBitVector| |pv$| 2)
           (PROGN
             (QSETREFV $ 100
                 (CONS (|dispatchFunction|
                           |PSETPK;squareFreeFactors;PL;29|)
                       $))
             (QSETREFV $ 103
                 (CONS (|dispatchFunction|
                           |PSETPK;univariatePolynomialsGcds;LBL;30|)
                       $))
             (QSETREFV $ 104
                 (CONS (|dispatchFunction|
                           |PSETPK;univariatePolynomialsGcds;2L;31|)
                       $))
             (QSETREFV $ 106
                 (CONS (|dispatchFunction|
                           |PSETPK;removeSquaresIfCan;2L;32|)
                       $))
             (QSETREFV $ 107
                 (CONS (|dispatchFunction|
                           |PSETPK;rewriteIdealWithQuasiMonicGenerators;LMML;33|)
                       $))
             (QSETREFV $ 110
                 (CONS (|dispatchFunction|
                           |PSETPK;removeRoughlyRedundantFactorsInContents;3L;34|)
                       $))
             (QSETREFV $ 112
                 (CONS (|dispatchFunction|
                           |PSETPK;removeRedundantFactorsInContents;3L;35|)
                       $))
             (QSETREFV $ 113
                 (CONS (|dispatchFunction|
                           |PSETPK;removeRedundantFactorsInPols;3L;36|)
                       $))
             (QSETREFV $ 115
                 (CONS (|dispatchFunction|
                           |PSETPK;removeRedundantFactors;2PL;37|)
                       $))
             (QSETREFV $ 114
                 (CONS (|dispatchFunction|
                           |PSETPK;unprotectedRemoveRedundantFactors;2PL;38|)
                       $))))
          ('T
           (PROGN
             (QSETREFV $ 106
                 (CONS (|dispatchFunction|
                           |PSETPK;removeSquaresIfCan;2L;39|)
                       $))
             (QSETREFV $ 107
                 (CONS (|dispatchFunction|
                           |PSETPK;rewriteIdealWithQuasiMonicGenerators;LMML;40|)
                       $))
             (QSETREFV $ 115
                 (CONS (|dispatchFunction|
                           |PSETPK;removeRedundantFactors;2PL;41|)
                       $))
             (QSETREFV $ 114
                 (CONS (|dispatchFunction|
                           |PSETPK;unprotectedRemoveRedundantFactors;2PL;42|)
                       $)))))
        $)))) 

(MAKEPROP '|PolynomialSetUtilitiesPackage| '|infovec|
    (LIST '#(NIL NIL NIL NIL NIL NIL (|local| |#1|) (|local| |#2|)
             (|local| |#3|) (|local| |#4|)
             (0 . |primPartElseUnitCanonical|) (|List| 9)
             (5 . |removeDuplicates|) (|Boolean|) (10 . |infRittWu?|)
             (|Mapping| 13 9 9) (16 . |sort|)
             (|Record| (|:| |goodPols| 11) (|:| |badPols| 11))
             (|Mapping| 13 9) |PSETPK;selectPolynomials;MLR;2|
             (|List| 18) |PSETPK;selectOrPolynomials;LLR;3|
             |PSETPK;selectAndPolynomials;LLR;4| (22 . |ground?|)
             (|NonNegativeInteger|) (27 . |mdeg|) (32 . |One|)
             |PSETPK;linear?;PB;5| |PSETPK;linearPolynomials;LR;6|
             (36 . |init|) (41 . |tail|) (46 . |mvar|) (51 . =)
             |PSETPK;univariate?;PB;7|
             |PSETPK;univariatePolynomials;LR;8|
             |PSETPK;bivariate?;PB;9| (57 . <) (63 . |degree|)
             |PSETPK;bivariatePolynomials;LR;10| (69 . |quasiMonic?|)
             |PSETPK;quasiMonicPolynomials;LR;11| (74 . |zero?|)
             (79 . |remove|) (|Union| $ '"failed") (85 . |exquo|)
             (91 . |unitCanonical|) (96 . |One|)
             |PSETPK;removeRoughlyRedundantFactorsInPols;2LBL;12|
             |PSETPK;removeRoughlyRedundantFactorsInPol;PLP;13|
             |PSETPK;removeRoughlyRedundantFactorsInPols;3L;14|
             |PSETPK;certainlySubVariety?;2LB;16| (|List| 11)
             |PSETPK;possiblyNewVariety?;LLB;15|
             (|GeneralPolynomialSet| 6 7 8 9) (100 . |construct|)
             (|Record| (|:| |rnum| 6) (|:| |polnum| 9) (|:| |den| 6))
             (105 . |remainder|) (|List| 8) (111 . |variables|)
             (116 . |concat|) (122 . |removeDuplicates|)
             |PSETPK;probablyZeroDim?;LB;17| (127 . |supRittWu?|)
             (133 . |associates?|) (139 . |concat|)
             |PSETPK;interReduce;2L;18|
             (|Record| (|:| |bas| $) (|:| |top| 11))
             (|Union| 66 '"failed") (|GeneralTriangularSet| 6 7 8 9)
             (145 . |basicSet|)
             (|Record| (|:| |bas| 68) (|:| |top| 11))
             (|Union| 70 '"failed") |PSETPK;roughBasicSet;LU;20|
             (151 . |empty?|) (156 . |members|)
             (161 . |rewriteIdealWithRemainder|) (167 . =)
             (173 . |infRittWu?|) |PSETPK;crushedSet;2L;22|
             (179 . |any?|) (185 . |empty|) (189 . |basicSet|)
             (|Mapping| 9 9 9) (196 . |rewriteSetWithReduction|)
             |PSETPK;rewriteSetByReducingWithParticularGenerators;LMMML;23|
             (|Mapping| 11 11) |PSETPK;removeRedundantFactors;2LML;24|
             |PSETPK;removeRedundantFactors;2L;43|
             |PSETPK;removeRedundantFactors;3L;25| (|Factored| 9)
             (|MultivariateFactorize| 8 7 6 9) (204 . |factor|)
             (|Record| (|:| |factor| 9) (|:| |exponent| (|Integer|)))
             (|List| 92) (209 . |factors|) (214 . |irreducibleFactors|)
             (219 . |lazyIrreducibleFactors|)
             (224 . |removeIrreducibleRedundantFactors|) (|Factored| $)
             (230 . |squareFree|) (235 . |squareFreeFactors|)
             (|List| $) (240 . |gcd|)
             (245 . |univariatePolynomialsGcds|)
             (251 . |univariatePolynomialsGcds|)
             (256 . |squareFreePart|) (261 . |removeSquaresIfCan|)
             (266 . |rewriteIdealWithQuasiMonicGenerators|)
             (273 . |mainContent|) (278 . *)
             (284 . |removeRoughlyRedundantFactorsInContents|)
             (290 . |gcd|) (296 . |removeRedundantFactorsInContents|)
             (302 . |removeRedundantFactorsInPols|)
             (308 . |unprotectedRemoveRedundantFactors|)
             (314 . |removeRedundantFactors|) (320 . |size?|)
             |PSETPK;removeRedundantFactors;LPL;44|)
          '#(|unprotectedRemoveRedundantFactors| 326
             |univariatePolynomialsGcds| 332 |univariatePolynomials|
             343 |univariate?| 348 |squareFreeFactors| 353
             |selectPolynomials| 358 |selectOrPolynomials| 364
             |selectAndPolynomials| 370 |roughBasicSet| 376
             |rewriteSetByReducingWithParticularGenerators| 381
             |rewriteIdealWithQuasiMonicGenerators| 389
             |removeSquaresIfCan| 396
             |removeRoughlyRedundantFactorsInPols| 401
             |removeRoughlyRedundantFactorsInPol| 414
             |removeRoughlyRedundantFactorsInContents| 420
             |removeRedundantFactorsInPols| 426
             |removeRedundantFactorsInContents| 432
             |removeRedundantFactors| 438
             |removeIrreducibleRedundantFactors| 468
             |quasiMonicPolynomials| 474 |probablyZeroDim?| 479
             |possiblyNewVariety?| 484 |linearPolynomials| 490
             |linear?| 495 |lazyIrreducibleFactors| 500
             |irreducibleFactors| 505 |interReduce| 510 |crushedSet|
             515 |certainlySubVariety?| 520 |bivariatePolynomials| 526
             |bivariate?| 531)
          'NIL
          (CONS (|makeByteWordVec2| 1 'NIL)
                (CONS '#()
                      (CONS '#()
                            (|makeByteWordVec2| 117
                                '(1 9 0 0 10 1 11 0 0 12 2 9 13 0 0 14
                                  2 11 0 15 0 16 1 9 13 0 23 1 9 24 0
                                  25 0 6 0 26 1 9 0 0 29 1 9 0 0 30 1 9
                                  8 0 31 2 8 13 0 0 32 2 8 13 0 0 36 2
                                  9 24 0 8 37 1 9 13 0 39 1 9 13 0 41 2
                                  11 0 18 0 42 2 9 43 0 0 44 1 9 0 0 45
                                  0 9 0 46 1 53 0 11 54 2 53 55 9 0 56
                                  1 9 57 0 58 2 57 0 0 0 59 1 57 0 0 60
                                  2 9 13 0 0 62 2 9 13 0 0 63 2 11 0 0
                                  0 64 2 68 67 11 15 69 1 68 13 0 73 1
                                  68 11 0 74 2 68 11 11 0 75 2 9 13 0 0
                                  76 2 68 13 0 0 77 2 11 13 18 0 79 0
                                  68 0 80 3 68 67 11 18 15 81 4 68 11
                                  11 0 82 15 83 1 90 89 9 91 1 89 93 0
                                  94 1 0 11 11 95 1 0 11 11 96 2 0 11
                                  11 11 97 1 9 98 0 99 1 0 11 9 100 1 9
                                  0 101 102 2 0 11 11 13 103 1 0 11 11
                                  104 1 9 0 0 105 1 0 11 11 106 3 0 11
                                  11 15 82 107 1 9 0 0 108 2 9 0 0 0
                                  109 2 0 11 11 11 110 2 9 0 0 0 111 2
                                  0 11 11 11 112 2 0 11 11 11 113 2 0
                                  11 9 9 114 2 0 11 9 9 115 2 11 13 0
                                  24 116 2 0 11 9 9 114 1 2 11 11 104 2
                                  2 11 11 13 103 1 0 17 11 34 1 0 13 9
                                  33 1 2 11 9 100 2 0 17 18 11 19 2 0
                                  17 20 11 21 2 0 17 20 11 22 1 0 71 11
                                  72 4 0 11 11 18 15 82 84 3 0 11 11 15
                                  82 107 1 0 11 11 106 3 0 11 11 11 13
                                  47 2 0 11 11 11 49 2 0 9 9 11 48 2 2
                                  11 11 11 110 2 2 11 11 11 113 2 2 11
                                  11 11 112 2 0 11 9 9 115 1 0 11 11 87
                                  2 0 11 11 11 88 2 0 11 11 9 117 3 0
                                  11 11 11 85 86 2 1 11 11 11 97 1 0 17
                                  11 40 1 0 13 11 61 2 0 13 11 51 52 1
                                  0 17 11 28 1 0 13 9 27 1 1 11 11 96 1
                                  1 11 11 95 1 0 11 11 65 1 0 11 11 78
                                  2 0 13 11 11 50 1 0 17 11 38 1 0 13 9
                                  35)))))
          '|lookupComplete|)) 
