
(/VERSIONCHECK 2) 

(PUT '|SREGSET;rep| '|SPADreplace| '(XLAM (|s|) |s|)) 

(DEFUN |SREGSET;rep| (|s| $) |s|) 

(PUT '|SREGSET;per| '|SPADreplace| '(XLAM (|l|) |l|)) 

(DEFUN |SREGSET;per| (|l| $) |l|) 

(DEFUN |SREGSET;copy;2$;3| (|ts| $)
  (|SREGSET;per| (SPADCALL (|SREGSET;rep| |ts| $) (QREFELT $ 11)) $)) 

(DEFUN |SREGSET;empty;$;4| ($) (|SREGSET;per| NIL $)) 

(DEFUN |SREGSET;empty?;$B;5| (|ts| $) (NULL (|SREGSET;rep| |ts| $))) 

(DEFUN |SREGSET;parts;$L;6| (|ts| $) (|SREGSET;rep| |ts| $)) 

(DEFUN |SREGSET;members;$L;7| (|ts| $) (|SREGSET;rep| |ts| $)) 

(DEFUN |SREGSET;map;M2$;8| (|f| |ts| $)
  (SPADCALL (SPADCALL |f| (|SREGSET;rep| |ts| $) (QREFELT $ 19))
            (QREFELT $ 20))) 

(DEFUN |SREGSET;map!;M2$;9| (|f| |ts| $)
  (SPADCALL (SPADCALL |f| (|SREGSET;rep| |ts| $) (QREFELT $ 22))
      (QREFELT $ 20))) 

(DEFUN |SREGSET;member?;P$B;10| (|p| |ts| $)
  (SPADCALL |p| (|SREGSET;rep| |ts| $) (QREFELT $ 24))) 

(PUT '|SREGSET;roughUnitIdeal?;$B;11| '|SPADreplace|
     '(XLAM (|ts|) 'NIL)) 

(DEFUN |SREGSET;roughUnitIdeal?;$B;11| (|ts| $) 'NIL) 

(DEFUN |SREGSET;coerce;$Of;12| (|ts| $)
  (PROG (|lp| #0=#:G1878 |p| #1=#:G1879)
    (RETURN
      (SEQ (LETT |lp| (REVERSE (|SREGSET;rep| |ts| $))
                 . #2=(|SREGSET;coerce;$Of;12|))
           (EXIT (SPADCALL
                     (PROGN
                       (LETT #0# NIL . #2#)
                       (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 $ 28))
                                         #0#) . #2#)))
                            (LETT #1# (CDR #1#) . #2#) (GO G190) G191
                            (EXIT (NREVERSE0 #0#))))
                     (QREFELT $ 30))))))) 

(DEFUN |SREGSET;mvar;$V;13| (|ts| $)
  (COND
    ((SPADCALL |ts| (QREFELT $ 15))
     (|error| "mvar$SREGSET: #1 is empty"))
    ('T (SPADCALL (|SPADfirst| (|SREGSET;rep| |ts| $)) (QREFELT $ 32))))) 

(DEFUN |SREGSET;first;$U;14| (|ts| $)
  (COND
    ((SPADCALL |ts| (QREFELT $ 15)) (CONS 1 "failed"))
    ('T (CONS 0 (|SPADfirst| (|SREGSET;rep| |ts| $)))))) 

(DEFUN |SREGSET;last;$U;15| (|ts| $)
  (COND
    ((SPADCALL |ts| (QREFELT $ 15)) (CONS 1 "failed"))
    ('T (CONS 0 (SPADCALL (|SREGSET;rep| |ts| $) (QREFELT $ 36)))))) 

(DEFUN |SREGSET;rest;$U;16| (|ts| $)
  (COND
    ((SPADCALL |ts| (QREFELT $ 15)) (CONS 1 "failed"))
    ('T (CONS 0 (|SREGSET;per| (CDR (|SREGSET;rep| |ts| $)) $))))) 

(DEFUN |SREGSET;coerce;$L;17| (|ts| $) (|SREGSET;rep| |ts| $)) 

(DEFUN |SREGSET;collectUpper;$V$;18| (|ts| |v| $)
  (PROG (|newlp| |lp|)
    (RETURN
      (SEQ (COND
             ((SPADCALL |ts| (QREFELT $ 15)) |ts|)
             ('T
              (SEQ (LETT |lp| (|SREGSET;rep| |ts| $)
                         . #0=(|SREGSET;collectUpper;$V$;18|))
                   (LETT |newlp| NIL . #0#)
                   (SEQ G190
                        (COND
                          ((NULL (COND
                                   ((NULL |lp|) 'NIL)
                                   ('T
                                    (SPADCALL |v|
                                     (SPADCALL (|SPADfirst| |lp|)
                                      (QREFELT $ 32))
                                     (QREFELT $ 41)))))
                           (GO G191)))
                        (SEQ (LETT |newlp|
                                   (CONS (|SPADfirst| |lp|) |newlp|) . #0#)
                             (EXIT (LETT |lp| (CDR |lp|) . #0#)))
                        NIL (GO G190) G191 (EXIT NIL))
                   (EXIT (|SREGSET;per| (REVERSE |newlp|) $))))))))) 

(DEFUN |SREGSET;collectUnder;$V$;19| (|ts| |v| $)
  (PROG (|lp|)
    (RETURN
      (SEQ (COND
             ((SPADCALL |ts| (QREFELT $ 15)) |ts|)
             ('T
              (SEQ (LETT |lp| (|SREGSET;rep| |ts| $)
                         . #0=(|SREGSET;collectUnder;$V$;19|))
                   (SEQ G190
                        (COND
                          ((NULL (COND
                                   ((OR (NULL |lp|)
                                     (SPADCALL
                                      (SPADCALL (|SPADfirst| |lp|)
                                       (QREFELT $ 32))
                                      |v| (QREFELT $ 41)))
                                    'NIL)
                                   ('T 'T)))
                           (GO G191)))
                        (SEQ (EXIT (LETT |lp| (CDR |lp|) . #0#))) NIL
                        (GO G190) G191 (EXIT NIL))
                   (EXIT (|SREGSET;per| |lp| $))))))))) 

(DEFUN |SREGSET;construct;L$;20| (|lp| $)
  (PROG (|eif| |ts|)
    (RETURN
      (SEQ (LETT |ts| (|SREGSET;per| NIL $)
                 . #0=(|SREGSET;construct;L$;20|))
           (EXIT (COND
                   ((NULL |lp|) |ts|)
                   ('T
                    (SEQ (LETT |lp|
                               (SPADCALL (ELT $ 44) |lp|
                                   (QREFELT $ 46)) . #0#)
                         (SEQ G190
                              (COND
                                ((NULL (COND
                                         ((NULL |lp|) 'NIL)
                                         ('T 'T)))
                                 (GO G191)))
                              (SEQ (LETT |eif|
                                    (SPADCALL |ts| (|SPADfirst| |lp|)
                                     (QREFELT $ 47)) . #0#)
                                   (EXIT
                                    (COND
                                      ((QEQCAR |eif| 0)
                                       (SEQ
                                        (LETT |ts| (QCDR |eif|) . #0#)
                                        (EXIT
                                         (LETT |lp| (CDR |lp|) . #0#))))
                                      ('T
                                       (|error|
                                        "in construct : List P -> $  from SREGSET : bad #1")))))
                              NIL (GO G190) G191 (EXIT NIL))
                         (EXIT |ts|))))))))) 

(DEFUN |SREGSET;extendIfCan;$PU;21| (|ts| |p| $)
  (PROG (|lts|)
    (RETURN
      (SEQ (COND
             ((SPADCALL |p| (QREFELT $ 48)) (CONS 1 "failed"))
             ((SPADCALL |ts| (QREFELT $ 15))
              (SEQ (LETT |p|
                         (SPADCALL (SPADCALL |p| (QREFELT $ 49))
                             (QREFELT $ 50))
                         . #0=(|SREGSET;extendIfCan;$PU;21|))
                   (EXIT (CONS 0 (|SREGSET;per| (LIST |p|) $)))))
             ((NULL (SPADCALL (SPADCALL |ts| (QREFELT $ 33))
                        (SPADCALL |p| (QREFELT $ 32)) (QREFELT $ 41)))
              (CONS 1 "failed"))
             ('T
              (COND
                ((SPADCALL (SPADCALL |p| (QREFELT $ 51)) |ts|
                     (QREFELT $ 52))
                 (SEQ (LETT |lts|
                            (SPADCALL |p| |ts| (QREFELT $ 53)) . #0#)
                      (EXIT (COND
                              ((SPADCALL
                                   (SPADCALL |lts| (QREFELT $ 56)) 1
                                   (QREFELT $ 58))
                               (CONS 1 "failed"))
                              ('T
                               (CONS 0 (SPADCALL |lts| (QREFELT $ 59))))))))
                ('T (CONS 1 "failed"))))))))) 

(DEFUN |SREGSET;removeZero;P$P;22| (|p| |ts| $)
  (PROG (|v| |tsv-| #0=#:G1940 #1=#:G1949 |q|)
    (RETURN
      (SEQ (EXIT (COND
                   ((OR (SPADCALL |p| (QREFELT $ 48))
                        (SPADCALL |ts| (QREFELT $ 15)))
                    |p|)
                   ('T
                    (SEQ (LETT |v| (SPADCALL |p| (QREFELT $ 32))
                               . #2=(|SREGSET;removeZero;P$P;22|))
                         (LETT |tsv-|
                               (SPADCALL |ts| |v| (QREFELT $ 43)) . #2#)
                         (COND
                           ((SPADCALL |v| |ts| (QREFELT $ 60))
                            (SEQ (LETT |q|
                                       (SPADCALL |p|
                                        (PROG2
                                         (LETT #0#
                                          (SPADCALL |ts| |v|
                                           (QREFELT $ 61)) . #2#)
                                         (QCDR #0#)
                                          (|check-union| (QEQCAR #0# 0)
                                           (QREFELT $ 9) #0#))
                                        (QREFELT $ 62)) . #2#)
                                 (EXIT (COND
                                         ((SPADCALL |q| (QREFELT $ 63))
                                          (PROGN
                                            (LETT #1# |q| . #2#)
                                            (GO #1#)))
                                         ((SPADCALL
                                           (SPADCALL |q| |tsv-|
                                            (QREFELT $ 64))
                                           (QREFELT $ 63))
                                          (PROGN
                                            (LETT #1#
                                             (|spadConstant| $ 65) . #2#)
                                            (GO #1#))))))))
                         (EXIT (COND
                                 ((SPADCALL |tsv-| (QREFELT $ 15)) |p|)
                                 ('T
                                  (SEQ (LETT |q|
                                        (|spadConstant| $ 65) . #2#)
                                       (SEQ G190
                                        (COND
                                          ((NULL
                                            (SPADCALL
                                             (SPADCALL |p| |v|
                                              (QREFELT $ 66))
                                             (QREFELT $ 68)))
                                           (GO G191)))
                                        (SEQ
                                         (LETT |q|
                                          (SPADCALL
                                           (SPADCALL
                                            (SPADCALL
                                             (SPADCALL |p|
                                              (QREFELT $ 51))
                                             |tsv-| (QREFELT $ 64))
                                            (SPADCALL |p|
                                             (QREFELT $ 69))
                                            (QREFELT $ 70))
                                           |q| (QREFELT $ 71)) . #2#)
                                         (EXIT
                                          (LETT |p|
                                           (SPADCALL |p|
                                            (QREFELT $ 72)) . #2#)))
                                        NIL (GO G190) G191 (EXIT NIL))
                                       (EXIT
                                        (SPADCALL |q|
                                         (SPADCALL |p| |tsv-|
                                          (QREFELT $ 64))
                                         (QREFELT $ 71)))))))))))
           #1# (EXIT #1#))))) 

(DEFUN |SREGSET;internalAugment;P2$;23| (|p| |ts| $)
  (COND
    ((SPADCALL |p| (QREFELT $ 48))
     (|error| "in internalAugment$SREGSET: ground? #1"))
    ('T
     (SPADCALL
         (SPADCALL |p| |ts| 'NIL 'NIL 'NIL 'NIL 'NIL (QREFELT $ 73))
         (QREFELT $ 59))))) 

(DEFUN |SREGSET;internalAugment;L2$;24| (|lp| |ts| $)
  (COND
    ((NULL |lp|) |ts|)
    ('T
     (SPADCALL (CDR |lp|)
         (SPADCALL (|SPADfirst| |lp|) |ts| (QREFELT $ 74))
         (QREFELT $ 75))))) 

(DEFUN |SREGSET;internalAugment;P$5BL;25|
       (|p| |ts| |rem?| |red?| |prim?| |sqfr?| |extend?| $)
  (PROG (|v| |tsv-| |tsv+| |lsfp| |f| #0=#:G1969 |lpwt| |pwt|
             #1=#:G1970 |sfp| |lts| #2=#:G1971 |us| #3=#:G1972)
    (RETURN
      (SEQ (LETT |v| (SPADCALL |p| (QREFELT $ 32))
                 . #4=(|SREGSET;internalAugment;P$5BL;25|))
           (LETT |tsv-| (SPADCALL |ts| |v| (QREFELT $ 43)) . #4#)
           (LETT |tsv+| (SPADCALL |ts| |v| (QREFELT $ 42)) . #4#)
           (COND
             (|rem?| (LETT |p|
                           (QVELT (SPADCALL |p| |tsv-| (QREFELT $ 77))
                                  1) . #4#)))
           (COND
             (|red?| (LETT |p|
                           (SPADCALL |p| |tsv-| (QREFELT $ 64)) . #4#)))
           (COND
             (|prim?| (LETT |p| (SPADCALL |p| (QREFELT $ 78)) . #4#)))
           (COND
             (|sqfr?| (SEQ (LETT |lts| NIL . #4#)
                           (LETT |lsfp|
                                 (SPADCALL |p| (QREFELT $ 80)) . #4#)
                           (EXIT (SEQ (LETT |f| NIL . #4#)
                                      (LETT #0# |lsfp| . #4#) G190
                                      (COND
                                        ((OR (ATOM #0#)
                                          (PROGN
                                            (LETT |f| (CAR #0#) . #4#)
                                            NIL))
                                         #5=(GO G191)))
                                      (SEQ
                                       (EXIT
                                        (COND
                                          ((OR
                                            (SPADCALL |f|
                                             (QREFELT $ 48))
                                            (SPADCALL
                                             (SPADCALL |f|
                                              (QREFELT $ 32))
                                             |v| (QREFELT $ 41)))
                                           "leave")
                                          ('T
                                           (SEQ
                                            (LETT |lpwt|
                                             (SPADCALL |f| |tsv-|
                                              (QREFELT $ 83)) . #4#)
                                            (EXIT
                                             (SEQ
                                              (LETT |pwt| NIL . #4#)
                                              (LETT #1# |lpwt| . #4#)
                                              G190
                                              (COND
                                                ((OR (ATOM #1#)
                                                  (PROGN
                                                    (LETT |pwt|
                                                     (CAR #1#) . #4#)
                                                    NIL))
                                                 #5#))
                                              (SEQ
                                               (LETT |sfp|
                                                (QCAR |pwt|) . #4#)
                                               (LETT |us|
                                                (QCDR |pwt|) . #4#)
                                               (EXIT
                                                (LETT |lts|
                                                 (SPADCALL
                                                  (|SREGSET;per|
                                                   (CONS (QCAR |pwt|)
                                                    (|SREGSET;rep|
                                                     (QCDR |pwt|) $))
                                                   $)
                                                  |lts| (QREFELT $ 84)) . #4#)))
                                              (LETT #1#
                                               (CDR #1#) . #4#)
                                              #6=(GO G190) G191
                                              (EXIT NIL))))))))
                                      (LETT #0# (CDR #0#) . #4#) #6#
                                      G191 (EXIT NIL)))))
             (#7='T
              (LETT |lts|
                    (LIST (|SREGSET;per|
                              (CONS |p| (|SREGSET;rep| |tsv-| $)) $)) . #4#)))
           (EXIT (COND
                   (|extend?|
                       (SPADCALL (SPADCALL |tsv+| (QREFELT $ 17)) |lts|
                           (QREFELT $ 85)))
                   (#7#
                    (PROGN
                      (LETT #2# NIL . #4#)
                      (SEQ (LETT |us| NIL . #4#) (LETT #3# |lts| . #4#)
                           G190
                           (COND
                             ((OR (ATOM #3#)
                                  (PROGN
                                    (LETT |us| (CAR #3#) . #4#)
                                    NIL))
                              #5#))
                           (SEQ (EXIT (LETT #2#
                                       (CONS
                                        (|SREGSET;per|
                                         (SPADCALL
                                          (|SREGSET;rep| |tsv+| $)
                                          (|SREGSET;rep| |us| $)
                                          (QREFELT $ 86))
                                         $)
                                        #2#) . #4#)))
                           (LETT #3# (CDR #3#) . #4#) #6# G191
                           (EXIT (NREVERSE0 #2#))))))))))) 

(DEFUN |SREGSET;augment;P$L;26| (|p| |ts| $)
  (COND
    ((SPADCALL |p| (QREFELT $ 48))
     (|error| "in augment$SREGSET: ground? #1"))
    ((SPADCALL (SPADCALL |p| (QREFELT $ 32)) |ts| (QREFELT $ 60))
     (|error| "in augment$SREGSET: bad #1"))
    ('T (SPADCALL |p| |ts| 'T 'T 'T 'T 'T (QREFELT $ 73))))) 

(DEFUN |SREGSET;extend;P$L;27| (|p| |ts| $)
  (PROG (|v| |split| |us| #0=#:G1981 |lts|)
    (RETURN
      (SEQ (COND
             ((SPADCALL |p| (QREFELT $ 48))
              (|error| "in extend$SREGSET: ground? #1"))
             ('T
              (SEQ (LETT |v| (SPADCALL |p| (QREFELT $ 32))
                         . #1=(|SREGSET;extend;P$L;27|))
                   (COND
                     ((NULL (SPADCALL (SPADCALL |ts| (QREFELT $ 33))
                                (SPADCALL |p| (QREFELT $ 32))
                                (QREFELT $ 41)))
                      (EXIT (|error| "in extend$SREGSET: bad #1"))))
                   (LETT |split|
                         (SPADCALL (SPADCALL |p| (QREFELT $ 51)) |ts|
                                   (QREFELT $ 87)) . #1#)
                   (LETT |lts| NIL . #1#)
                   (SEQ (LETT |us| NIL . #1#) (LETT #0# |split| . #1#)
                        G190
                        (COND
                          ((OR (ATOM #0#)
                               (PROGN (LETT |us| (CAR #0#) . #1#) NIL))
                           (GO G191)))
                        (SEQ (EXIT (LETT |lts|
                                    (SPADCALL
                                     (SPADCALL |p| |us| (QREFELT $ 53))
                                     |lts| (QREFELT $ 88)) . #1#)))
                        (LETT #0# (CDR #0#) . #1#) (GO G190) G191
                        (EXIT NIL))
                   (EXIT |lts|)))))))) 

(DEFUN |SREGSET;invertible?;P$B;28| (|p| |ts| $)
  (SPADCALL |p| |ts| (QREFELT $ 91))) 

(DEFUN |SREGSET;invertible?;P$L;29| (|p| |ts| $)
  (SPADCALL |p| |ts| (QREFELT $ 94))) 

(DEFUN |SREGSET;invertibleSet;P$L;30| (|p| |ts| $)
  (SPADCALL |p| |ts| (QREFELT $ 98))) 

(DEFUN |SREGSET;lastSubResultant;2P$L;31| (|p1| |p2| |ts| $)
  (SPADCALL |p1| |p2| |ts| (QREFELT $ 101))) 

(DEFUN |SREGSET;squareFreePart;P$L;32| (|p| |ts| $)
  (SPADCALL |p| |ts| (QREFELT $ 103))) 

(DEFUN |SREGSET;intersect;P$L;33| (|p| |ts| $)
  (SPADCALL (LIST |p|) (LIST |ts|) 'NIL 'NIL (QREFELT $ 105))) 

(DEFUN |SREGSET;intersect;L2L;34| (|lp| |lts| $)
  (SPADCALL |lp| |lts| 'NIL 'NIL (QREFELT $ 105))) 

(DEFUN |SREGSET;zeroSetSplit;LL;35| (|lp| $)
  (SPADCALL |lp| 'T 'NIL (QREFELT $ 108))) 

(DEFUN |SREGSET;zeroSetSplit;LBL;36| (|lp| |clos?| $)
  (SPADCALL |lp| |clos?| 'NIL (QREFELT $ 108))) 

(DEFUN |SREGSET;zeroSetSplit;L2BL;37| (|lp| |clos?| |info?| $)
  (SPADCALL |lp| 'T |clos?| |info?| 'T (QREFELT $ 111))) 

(DEFUN |SREGSET;zeroSetSplit;L4BL;38|
       (|lp| |hash?| |clos?| |info?| |prep?| $)
  (PROG (|e| |#G80| |#G81| |#G82| |#G83| |#G84| |#G85| |s1| |s2| |s3|
             |#G89| |#G90| |#G91| |#G92| |#G93| |#G94| |dom1| |dom2|
             |dom3| |lts|)
    (RETURN
      (SEQ (COND
             (|hash?| (SEQ (LETT |e| (MAKE-FULL-CVEC 0)
                                 . #0=(|SREGSET;zeroSetSplit;L4BL;38|))
                           (COND
                             (|info?| (PROGN
                                        (LETT |#G80| "w" . #0#)
                                        (LETT |#G81| "g" . #0#)
                                        (LETT |#G82| "i" . #0#)
                                        (LETT |s1| |#G80| . #0#)
                                        (LETT |s2| |#G81| . #0#)
                                        (LETT |s3| |#G82| . #0#)))
                             (#1='T
                              (PROGN
                                (LETT |#G83| |e| . #0#)
                                (LETT |#G84| |e| . #0#)
                                (LETT |#G85| |e| . #0#)
                                (LETT |s1| |#G83| . #0#)
                                (LETT |s2| |#G84| . #0#)
                                (LETT |s3| |#G85| . #0#))))
                           (COND
                             (|info?| (PROGN
                                        (LETT |#G89| "QCMPACK" . #0#)
                                        (LETT |#G90|
                                         "REGSETGCD: Gcd" . #0#)
                                        (LETT |#G91|
                                         "REGSETGCD: Inv Set" . #0#)
                                        (LETT |dom1| |#G89| . #0#)
                                        (LETT |dom2| |#G90| . #0#)
                                        (LETT |dom3| |#G91| . #0#)))
                             (#1#
                              (PROGN
                                (LETT |#G92| |e| . #0#)
                                (LETT |#G93| |e| . #0#)
                                (LETT |#G94| |e| . #0#)
                                (LETT |dom1| |#G92| . #0#)
                                (LETT |dom2| |#G93| . #0#)
                                (LETT |dom3| |#G94| . #0#))))
                           (SPADCALL |s1| "W" |dom1| (QREFELT $ 115))
                           (SPADCALL |s2| "G" |dom2| (QREFELT $ 116))
                           (EXIT (SPADCALL |s3| "I" |dom3|
                                     (QREFELT $ 117))))))
           (LETT |lts|
                 (SPADCALL |lp| |clos?| |info?| |prep?|
                     (QREFELT $ 118)) . #0#)
           (COND
             (|hash?| (SEQ (SPADCALL (QREFELT $ 119))
                           (SPADCALL (QREFELT $ 120))
                           (EXIT (SPADCALL (QREFELT $ 121))))))
           (EXIT |lts|))))) 

(DEFUN |SREGSET;internalZeroSetSplit;L3BL;39|
       (|lp| |clos?| |info?| |prep?| $)
  (PROG (|pp| |ts| |p| #0=#:G2017 |lts|)
    (RETURN
      (SEQ (COND
             (|prep?| (SEQ (LETT |pp|
                                 (SPADCALL |lp| |clos?| |info?|
                                     (QREFELT $ 123))
                                 . #1=(|SREGSET;internalZeroSetSplit;L3BL;39|))
                           (LETT |lp| (QCAR |pp|) . #1#)
                           (EXIT (LETT |lts| (QCDR |pp|) . #1#))))
             ('T
              (SEQ (LETT |ts| (SPADCALL NIL (QREFELT $ 20)) . #1#)
                   (EXIT (LETT |lts| (LIST |ts|) . #1#)))))
           (LETT |lp| (SPADCALL (ELT $ 63) |lp| (QREFELT $ 125)) . #1#)
           (EXIT (COND
                   ((SPADCALL (ELT $ 48) |lp| (QREFELT $ 126)) NIL)
                   ((OR (NULL |lp|) (SPADCALL |lts| (QREFELT $ 127)))
                    |lts|)
                   ('T
                    (SEQ (LETT |lp|
                               (SPADCALL (ELT $ 44) |lp|
                                   (QREFELT $ 46)) . #1#)
                         (EXIT (COND
                                 (|clos?| (SPADCALL |lp| |lts| |clos?|
                                           |info?| (QREFELT $ 105)))
                                 ('T
                                  (SEQ (SEQ (LETT |p| NIL . #1#)
                                        (LETT #0# |lp| . #1#) G190
                                        (COND
                                          ((OR (ATOM #0#)
                                            (PROGN
                                              (LETT |p|
                                               (CAR #0#) . #1#)
                                              NIL))
                                           (GO G191)))
                                        (SEQ
                                         (EXIT
                                          (LETT |lts|
                                           (SPADCALL (LIST |p|) |lts|
                                            |clos?| |info?|
                                            (QREFELT $ 105)) . #1#)))
                                        (LETT #0# (CDR #0#) . #1#)
                                        (GO G190) G191 (EXIT NIL))
                                       (EXIT |lts|))))))))))))) 

(DEFUN |SREGSET;largeSystem?| (|lp| $)
  (PROG (|lts|)
    (RETURN
      (SEQ (COND
             ((< 16 (LENGTH |lp|)) 'T)
             ((< (LENGTH |lp|) 13) 'NIL)
             ('T
              (SEQ (LETT |lts| NIL |SREGSET;largeSystem?|)
                   (EXIT (< 3
                            (- (LENGTH |lp|)
                               (SPADCALL |lp| |lts| (QREFELT $ 128)))))))))))) 

(DEFUN |SREGSET;smallSystem?| (|lp| $) (< (LENGTH |lp|) 5)) 

(DEFUN |SREGSET;mediumSystem?| (|lp| $)
  (PROG (|lts|)
    (RETURN
      (SEQ (LETT |lts| NIL |SREGSET;mediumSystem?|)
           (EXIT (< (- (SPADCALL |lp| |lts| (QREFELT $ 128))
                       (LENGTH |lp|))
                    2)))))) 

(DEFUN |SREGSET;lin?| (|p| $)
  (COND
    ((SPADCALL (SPADCALL |p| (QREFELT $ 51)) (QREFELT $ 48))
     (EQL (SPADCALL |p| (QREFELT $ 129)) 1))
    ('T 'NIL))) 

(DEFUN |SREGSET;preprocess;L2BR;44| (|lp| |clos?| |info?| $)
  (PROG (|ts| #0=#:G2056 |lp1| #1=#:G2057 #2=#:G2058 #3=#:G2059
              #4=#:G2060 #5=#:G2061 #6=#:G2062 #7=#:G2063 #8=#:G2064
              #9=#:G2065 #10=#:G2066 |lp4| #11=#:G2067 |lp3| |p|
              #12=#:G2068 |lts| |lp2| #13=#:G2055)
    (RETURN
      (SEQ (EXIT (SEQ (LETT |ts| (SPADCALL NIL (QREFELT $ 20))
                            . #14=(|SREGSET;preprocess;L2BR;44|))
                      (LETT |lts| (LIST |ts|) . #14#)
                      (EXIT (COND
                              ((NULL |lp|) (CONS |lp| |lts|))
                              ('T
                               (SEQ (LETT |lp1| NIL . #14#)
                                    (LETT |lp2| NIL . #14#)
                                    (SEQ (LETT |p| NIL . #14#)
                                     (LETT #0# |lp| . #14#) G190
                                     (COND
                                       ((OR (ATOM #0#)
                                         (PROGN
                                           (LETT |p| (CAR #0#) . #14#)
                                           NIL))
                                        #15=(GO G191)))
                                     (SEQ
                                      (EXIT
                                       (COND
                                         ((SPADCALL
                                           (SPADCALL |p|
                                            (QREFELT $ 72))
                                           (QREFELT $ 48))
                                          (LETT |lp1|
                                           (CONS |p| |lp1|) . #14#))
                                         ('T
                                          (LETT |lp2|
                                           (CONS |p| |lp2|) . #14#)))))
                                     (LETT #0# (CDR #0#) . #14#)
                                     #16=(GO G190) G191 (EXIT NIL))
                                    (LETT |lts|
                                     (SPADCALL |lp1| (LIST |ts|)
                                      |clos?| |info?| (QREFELT $ 105)) . #14#)
                                    (EXIT
                                     (COND
                                       ((SPADCALL |lp| (QREFELT $ 130))
                                        (COND
                                          ((|SREGSET;largeSystem?| |lp|
                                            $)
                                           (PROGN
                                             (LETT #13#
                                              (CONS |lp2| |lts|) . #14#)
                                             (GO #13#)))
                                          ('T
                                           (SEQ
                                            (COND
                                              ((< 7 (LENGTH |lp|))
                                               (SEQ
                                                (LETT |lp2|
                                                 (SPADCALL |lp2|
                                                  (QREFELT $ 131)) . #14#)
                                                (LETT |lp2|
                                                 (SPADCALL (ELT $ 63)
                                                  |lp2|
                                                  (QREFELT $ 125)) . #14#)
                                                (EXIT
                                                 (COND
                                                   ((SPADCALL
                                                     (ELT $ 48) |lp2|
                                                     (QREFELT $ 126))
                                                    (PROGN
                                                      (LETT #13#
                                                       (CONS |lp2|
                                                        |lts|) . #14#)
                                                      (GO #13#)))
                                                   ('T
                                                    (SEQ
                                                     (LETT |lp3|
                                                      (PROGN
                                                        (LETT #1#
                                                         NIL . #14#)
                                                        (SEQ
                                                         (LETT |p|
                                                          NIL . #14#)
                                                         (LETT #2#
                                                          |lp2| . #14#)
                                                         G190
                                                         (COND
                                                           ((OR
                                                             (ATOM #2#)
                                                             (PROGN
                                                               (LETT
                                                                |p|
                                                                (CAR
                                                                 #2#) . #14#)
                                                               NIL))
                                                            #15#))
                                                         (SEQ
                                                          (EXIT
                                                           (COND
                                                             ((|SREGSET;lin?|
                                                               |p| $)
                                                              (LETT #1#
                                                               (CONS
                                                                |p|
                                                                #1#) . #14#)))))
                                                         (LETT #2#
                                                          (CDR #2#) . #14#)
                                                         #16# G191
                                                         (EXIT
                                                          (NREVERSE0
                                                           #1#)))) . #14#)
                                                     (LETT |lp4|
                                                      (PROGN
                                                        (LETT #3#
                                                         NIL . #14#)
                                                        (SEQ
                                                         (LETT |p|
                                                          NIL . #14#)
                                                         (LETT #4#
                                                          |lp2| . #14#)
                                                         G190
                                                         (COND
                                                           ((OR
                                                             (ATOM #4#)
                                                             (PROGN
                                                               (LETT
                                                                |p|
                                                                (CAR
                                                                 #4#) . #14#)
                                                               NIL))
                                                            #15#))
                                                         (SEQ
                                                          (EXIT
                                                           (COND
                                                             ((COND
                                                                ((|SREGSET;lin?|
                                                                  |p|
                                                                  $)
                                                                 'NIL)
                                                                ('T 'T))
                                                              (LETT #3#
                                                               (CONS
                                                                |p|
                                                                #3#) . #14#)))))
                                                         (LETT #4#
                                                          (CDR #4#) . #14#)
                                                         #16# G191
                                                         (EXIT
                                                          (NREVERSE0
                                                           #3#)))) . #14#)
                                                     (COND
                                                       (|clos?|
                                                        (LETT |lts|
                                                         (SPADCALL
                                                          |lp4| |lts|
                                                          |clos?|
                                                          |info?|
                                                          (QREFELT $
                                                           105)) . #14#))
                                                       ('T
                                                        (SEQ
                                                         (LETT |lp4|
                                                          (SPADCALL
                                                           (ELT $ 44)
                                                           |lp4|
                                                           (QREFELT $
                                                            46)) . #14#)
                                                         (EXIT
                                                          (SEQ
                                                           (LETT |p|
                                                            NIL . #14#)
                                                           (LETT #5#
                                                            |lp4| . #14#)
                                                           G190
                                                           (COND
                                                             ((OR
                                                               (ATOM
                                                                #5#)
                                                               (PROGN
                                                                 (LETT
                                                                  |p|
                                                                  (CAR
                                                                   #5#) . #14#)
                                                                 NIL))
                                                              #15#))
                                                           (SEQ
                                                            (EXIT
                                                             (LETT
                                                              |lts|
                                                              (SPADCALL
                                                               (LIST
                                                                |p|)
                                                               |lts|
                                                               |clos?|
                                                               |info?|
                                                               (QREFELT
                                                                $ 105)) . #14#)))
                                                           (LETT #5#
                                                            (CDR #5#) . #14#)
                                                           #16# G191
                                                           (EXIT NIL))))))
                                                     (EXIT
                                                      (LETT |lp2|
                                                       |lp3| . #14#))))))))
                                              ('T
                                               (SEQ
                                                (LETT |lp2|
                                                 (SPADCALL |lp2|
                                                  (QREFELT $ 131)) . #14#)
                                                (LETT |lp2|
                                                 (SPADCALL (ELT $ 63)
                                                  |lp2|
                                                  (QREFELT $ 125)) . #14#)
                                                (EXIT
                                                 (COND
                                                   ((SPADCALL
                                                     (ELT $ 48) |lp2|
                                                     (QREFELT $ 126))
                                                    (PROGN
                                                      (LETT #13#
                                                       (CONS |lp2|
                                                        |lts|) . #14#)
                                                      (GO #13#))))))))
                                            (COND
                                              (|clos?|
                                               (LETT |lts|
                                                (SPADCALL |lp2| |lts|
                                                 |clos?| |info?|
                                                 (QREFELT $ 105)) . #14#))
                                              ('T
                                               (SEQ
                                                (LETT |lp2|
                                                 (SPADCALL (ELT $ 44)
                                                  |lp2| (QREFELT $ 46)) . #14#)
                                                (EXIT
                                                 (SEQ
                                                  (LETT |p| NIL . #14#)
                                                  (LETT #6#
                                                   |lp2| . #14#)
                                                  G190
                                                  (COND
                                                    ((OR (ATOM #6#)
                                                      (PROGN
                                                        (LETT |p|
                                                         (CAR #6#) . #14#)
                                                        NIL))
                                                     #15#))
                                                  (SEQ
                                                   (EXIT
                                                    (LETT |lts|
                                                     (SPADCALL
                                                      (LIST |p|) |lts|
                                                      |clos?| |info?|
                                                      (QREFELT $ 105)) . #14#)))
                                                  (LETT #6#
                                                   (CDR #6#) . #14#)
                                                  #16# G191 (EXIT NIL))))))
                                            (LETT |lp2| NIL . #14#)
                                            (EXIT
                                             (PROGN
                                               (LETT #13#
                                                (CONS |lp2| |lts|) . #14#)
                                               (GO #13#)))))))
                                       ((|SREGSET;smallSystem?| |lp| $)
                                        (CONS |lp2| |lts|))
                                       ((|SREGSET;mediumSystem?| |lp|
                                         $)
                                        (CONS
                                         (SPADCALL |lp2|
                                          (QREFELT $ 131))
                                         |lts|))
                                       ('T
                                        (SEQ
                                         (LETT |lp3|
                                          (PROGN
                                            (LETT #7# NIL . #14#)
                                            (SEQ (LETT |p| NIL . #14#)
                                             (LETT #8# |lp2| . #14#)
                                             G190
                                             (COND
                                               ((OR (ATOM #8#)
                                                 (PROGN
                                                   (LETT |p|
                                                    (CAR #8#) . #14#)
                                                   NIL))
                                                #15#))
                                             (SEQ
                                              (EXIT
                                               (COND
                                                 ((|SREGSET;lin?| |p|
                                                   $)
                                                  (LETT #7#
                                                   (CONS |p| #7#) . #14#)))))
                                             (LETT #8#
                                              (CDR #8#) . #14#)
                                             #16# G191
                                             (EXIT (NREVERSE0 #7#)))) . #14#)
                                         (LETT |lp4|
                                          (PROGN
                                            (LETT #9# NIL . #14#)
                                            (SEQ (LETT |p| NIL . #14#)
                                             (LETT #10# |lp2| . #14#)
                                             G190
                                             (COND
                                               ((OR (ATOM #10#)
                                                 (PROGN
                                                   (LETT |p|
                                                    (CAR #10#) . #14#)
                                                   NIL))
                                                #15#))
                                             (SEQ
                                              (EXIT
                                               (COND
                                                 ((COND
                                                    ((|SREGSET;lin?|
                                                      |p| $)
                                                     'NIL)
                                                    ('T 'T))
                                                  (LETT #9#
                                                   (CONS |p| #9#) . #14#)))))
                                             (LETT #10#
                                              (CDR #10#) . #14#)
                                             #16# G191
                                             (EXIT (NREVERSE0 #9#)))) . #14#)
                                         (COND
                                           (|clos?|
                                            (LETT |lts|
                                             (SPADCALL |lp4| |lts|
                                              |clos?| |info?|
                                              (QREFELT $ 105)) . #14#))
                                           ('T
                                            (SEQ
                                             (LETT |lp4|
                                              (SPADCALL (ELT $ 44)
                                               |lp4| (QREFELT $ 46)) . #14#)
                                             (EXIT
                                              (SEQ
                                               (LETT |p| NIL . #14#)
                                               (LETT #11# |lp4| . #14#)
                                               G190
                                               (COND
                                                 ((OR (ATOM #11#)
                                                   (PROGN
                                                     (LETT |p|
                                                      (CAR #11#) . #14#)
                                                     NIL))
                                                  #15#))
                                               (SEQ
                                                (EXIT
                                                 (LETT |lts|
                                                  (SPADCALL (LIST |p|)
                                                   |lts| |clos?|
                                                   |info?|
                                                   (QREFELT $ 105)) . #14#)))
                                               (LETT #11#
                                                (CDR #11#) . #14#)
                                               #16# G191 (EXIT NIL))))))
                                         (COND
                                           (|clos?|
                                            (LETT |lts|
                                             (SPADCALL |lp3| |lts|
                                              |clos?| |info?|
                                              (QREFELT $ 105)) . #14#))
                                           ('T
                                            (SEQ
                                             (LETT |lp3|
                                              (SPADCALL (ELT $ 44)
                                               |lp3| (QREFELT $ 46)) . #14#)
                                             (EXIT
                                              (SEQ
                                               (LETT |p| NIL . #14#)
                                               (LETT #12# |lp3| . #14#)
                                               G190
                                               (COND
                                                 ((OR (ATOM #12#)
                                                   (PROGN
                                                     (LETT |p|
                                                      (CAR #12#) . #14#)
                                                     NIL))
                                                  #15#))
                                               (SEQ
                                                (EXIT
                                                 (LETT |lts|
                                                  (SPADCALL (LIST |p|)
                                                   |lts| |clos?|
                                                   |info?|
                                                   (QREFELT $ 105)) . #14#)))
                                               (LETT #12#
                                                (CDR #12#) . #14#)
                                               #16# G191 (EXIT NIL))))))
                                         (LETT |lp2| NIL . #14#)
                                         (EXIT
                                          (PROGN
                                            (LETT #13#
                                             (CONS |lp2| |lts|) . #14#)
                                            (GO #13#)))))))))))))
           #13# (EXIT #13#))))) 

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

(DEFUN |SquareFreeRegularTriangularSet;| (|#1| |#2| |#3| |#4|)
  (PROG (DV$1 DV$2 DV$3 DV$4 |dv$| $ #0=#:G2086 |pv$| #1=#:G2087)
    (RETURN
      (PROGN
        (LETT DV$1 (|devaluate| |#1|)
              . #2=(|SquareFreeRegularTriangularSet|))
        (LETT DV$2 (|devaluate| |#2|) . #2#)
        (LETT DV$3 (|devaluate| |#3|) . #2#)
        (LETT DV$4 (|devaluate| |#4|) . #2#)
        (LETT |dv$|
              (LIST '|SquareFreeRegularTriangularSet| DV$1 DV$2 DV$3
                    DV$4) . #2#)
        (LETT $ (GETREFV 148) . #2#)
        (QSETREFV $ 0 |dv$|)
        (QSETREFV $ 3
            (LETT |pv$|
                  (|buildPredVector| 0 0
                      (LIST (|HasCategory| |#4|
                                '(|ConvertibleTo| (|InputForm|)))
                            (LETT #0#
                                  (|HasCategory| |#4| '(|SetCategory|)) . #2#)
                            (AND #0#
                                 (|HasCategory| |#4|
                                     (LIST '|Evalable|
                                      (|devaluate| |#4|))))
                            (|HasCategory| |#1| '(|IntegralDomain|))
                            (|HasCategory| |#3| '(|Finite|)))) . #2#))
        (|haddProp| |$ConstructorCache|
            '|SquareFreeRegularTriangularSet|
            (LIST DV$1 DV$2 DV$3 DV$4) (CONS 1 $))
        (|stuffDomainSlots| $)
        (QSETREFV $ 6 |#1|)
        (QSETREFV $ 7 |#2|)
        (QSETREFV $ 8 |#3|)
        (QSETREFV $ 9 |#4|)
        (AND (|HasCategory| $ '(|shallowlyMutable|))
             (|augmentPredVector| $ 32))
        (AND (LETT #1# (|HasCategory| $ '(|finiteAggregate|)) . #2#)
             (|augmentPredVector| $ 64))
        (AND #1# #0# (|augmentPredVector| $ 128))
        $)))) 

(MAKEPROP '|SquareFreeRegularTriangularSet| '|infovec|
    (LIST '#(NIL NIL NIL NIL NIL NIL (|local| |#1|) (|local| |#2|)
             (|local| |#3|) (|local| |#4|) (|List| 9) (0 . |copy|)
             |SREGSET;copy;2$;3| |SREGSET;empty;$;4| (|Boolean|)
             |SREGSET;empty?;$B;5| |SREGSET;parts;$L;6|
             |SREGSET;members;$L;7| (|Mapping| 9 9) (5 . |map|)
             |SREGSET;construct;L$;20| |SREGSET;map;M2$;8|
             (11 . |map!|) |SREGSET;map!;M2$;9| (17 . |member?|)
             |SREGSET;member?;P$B;10| |SREGSET;roughUnitIdeal?;$B;11|
             (|OutputForm|) (23 . |coerce|) (|List| $) (28 . |brace|)
             |SREGSET;coerce;$Of;12| (33 . |mvar|) |SREGSET;mvar;$V;13|
             (|Union| 9 '"failed") |SREGSET;first;$U;14| (38 . |last|)
             |SREGSET;last;$U;15| (|Union| $ '"failed")
             |SREGSET;rest;$U;16| |SREGSET;coerce;$L;17| (43 . <)
             |SREGSET;collectUpper;$V$;18|
             |SREGSET;collectUnder;$V$;19| (49 . |infRittWu?|)
             (|Mapping| 14 9 9) (55 . |sort|)
             |SREGSET;extendIfCan;$PU;21| (61 . |ground?|)
             (66 . |primitivePart|) (71 . |squareFreePart|)
             (76 . |init|) |SREGSET;invertible?;P$B;28|
             |SREGSET;augment;P$L;26| (|NonNegativeInteger|)
             (|List| $$) (81 . |#|) (86 . |One|) (90 . ~=)
             (96 . |first|) (101 . |algebraic?|) (107 . |select|)
             (113 . |lazyPrem|) (119 . |zero?|)
             |SREGSET;removeZero;P$P;22| (124 . |Zero|)
             (128 . |degree|) (|Integer|) (134 . |positive?|)
             (139 . |mainMonomial|) (144 . *) (150 . +) (156 . |tail|)
             |SREGSET;internalAugment;P$5BL;25|
             |SREGSET;internalAugment;P2$;23|
             |SREGSET;internalAugment;L2$;24|
             (|Record| (|:| |rnum| 6) (|:| |polnum| 9) (|:| |den| 6))
             (161 . |remainder|) (167 . |mainPrimitivePart|)
             (|PolynomialSetUtilitiesPackage| 6 7 8 9)
             (172 . |squareFreeFactors|)
             (|Record| (|:| |val| 9) (|:| |tower| $)) (|List| 81)
             |SREGSET;squareFreePart;P$L;32| (177 . |cons|)
             (183 . |extend|) (189 . |concat|)
             |SREGSET;invertibleSet;P$L;30| (195 . |concat|)
             |SREGSET;extend;P$L;27|
             (|SquareFreeRegularTriangularSetGcdPackage| 6 7 8 9 $$)
             (201 . |stoseInvertible?|)
             (|Record| (|:| |val| 14) (|:| |tower| $$)) (|List| 92)
             (207 . |stoseInvertible?sqfreg|)
             (|Record| (|:| |val| 14) (|:| |tower| $)) (|List| 95)
             |SREGSET;invertible?;P$L;29|
             (213 . |stoseInvertibleSetsqfreg|)
             (|Record| (|:| |val| 9) (|:| |tower| $$)) (|List| 99)
             (219 . |stoseLastSubResultant|)
             |SREGSET;lastSubResultant;2P$L;31|
             (226 . |stoseSquareFreePart|)
             (|SquareFreeRegularSetDecompositionPackage| 6 7 8 9 $$)
             (232 . |decompose|) |SREGSET;intersect;P$L;33|
             |SREGSET;intersect;L2L;34| |SREGSET;zeroSetSplit;L2BL;37|
             |SREGSET;zeroSetSplit;LL;35| |SREGSET;zeroSetSplit;LBL;36|
             |SREGSET;zeroSetSplit;L4BL;38| (|Void|) (|String|)
             (|SquareFreeQuasiComponentPackage| 6 7 8 9 $$)
             (240 . |startTable!|) (247 . |startTableGcd!|)
             (254 . |startTableInvSet!|)
             |SREGSET;internalZeroSetSplit;L3BL;39|
             (261 . |stopTable!|) (265 . |stopTableGcd!|)
             (269 . |stopTableInvSet!|)
             (|Record| (|:| |val| 10) (|:| |towers| 29))
             |SREGSET;preprocess;L2BR;44| (|Mapping| 14 9)
             (273 . |remove|) (279 . |any?|) (285 . |empty?|)
             (290 . |numberOfVariables|) (296 . |mdeg|)
             (301 . |probablyZeroDim?|) (306 . |crushedSet|)
             (|Mapping| 9 9 9) (|List| 134) (|Equation| 9)
             (|InputForm|) (|Record| (|:| |num| 9) (|:| |den| 6))
             (|Union| 9 29) (|Union| 14 29) (|List| 8)
             (|Record| (|:| |close| $) (|:| |open| 10)) (|List| 140)
             (|Mapping| 14 9 10)
             (|Record| (|:| |close| 10) (|:| |open| 10))
             (|Record| (|:| |bas| $) (|:| |top| 10))
             (|Union| 144 '"failed")
             (|Record| (|:| |under| $) (|:| |floor| $) (|:| |upper| $))
             (|SingleInteger|))
          '#(~= 311 |zeroSetSplitIntoTriangularSystems| 317
             |zeroSetSplit| 322 |variables| 349 |trivialIdeal?| 354
             |triangular?| 359 |stronglyReduced?| 364 |stronglyReduce|
             375 |squareFreePart| 381 |sort| 387 |size?| 393 |select|
             399 |sample| 411 |roughUnitIdeal?| 415 |roughSubIdeal?|
             420 |roughEqualIdeals?| 426 |roughBase?| 432
             |rewriteSetWithReduction| 437 |rewriteIdealWithRemainder|
             445 |rewriteIdealWithHeadRemainder| 451 |retractIfCan| 457
             |retract| 462 |rest| 467 |removeZero| 472
             |removeDuplicates| 478 |remove| 483 |remainder| 495
             |reduced?| 501 |reduceByQuasiMonic| 508 |reduce| 514
             |quasiComponent| 543 |purelyTranscendental?| 548
             |purelyAlgebraicLeadingMonomial?| 554 |purelyAlgebraic?|
             560 |preprocess| 571 |parts| 578 |normalized?| 583 |mvar|
             594 |more?| 599 |members| 605 |member?| 610 |map!| 616
             |map| 622 |mainVariables| 628 |mainVariable?| 633 |less?|
             639 |latex| 645 |lastSubResultantElseSplit| 650
             |lastSubResultant| 657 |last| 664 |invertibleSet| 669
             |invertibleElseSplit?| 675 |invertible?| 681 |intersect|
             693 |internalZeroSetSplit| 717 |internalAugment| 725
             |initials| 748 |initiallyReduced?| 753 |initiallyReduce|
             764 |infRittWu?| 770 |iexactQuo| 776 |headRemainder| 782
             |headReduced?| 788 |headReduce| 799 |hash| 805 |first| 810
             |find| 815 |extendIfCan| 821 |extend| 827 |every?| 857
             |eval| 863 |eq?| 889 |empty?| 895 |empty| 900 |degree| 904
             |count| 909 |copy| 921 |convert| 926 |construct| 931
             |collectUpper| 936 |collectUnder| 942 |collectQuasiMonic|
             948 |collect| 953 |coerce| 959 |coHeight| 969 |basicSet|
             974 |autoReduced?| 987 |augment| 993 |any?| 1017
             |algebraicVariables| 1023 |algebraicCoefficients?| 1028
             |algebraic?| 1034 = 1040 |#| 1046)
          'NIL
          (CONS (|makeByteWordVec2| 3
                    '(0 0 0 0 0 0 0 0 3 0 0 0 0 0 0 3 1))
                (CONS '#(NIL |RegularTriangularSetCategory&|
                         |TriangularSetCategory&|
                         |PolynomialSetCategory&| |Collection&|
                         |HomogeneousAggregate&| |SetCategory&|
                         |Aggregate&| |Evalable&| |BasicType&| NIL NIL
                         NIL NIL NIL |InnerEvalable&| NIL)
                      (CONS '#((|SquareFreeRegularTriangularSetCategory|
                                   6 7 8 9)
                               (|RegularTriangularSetCategory| 6 7 8 9)
                               (|TriangularSetCategory| 6 7 8 9)
                               (|PolynomialSetCategory| 6 7 8 9)
                               (|Collection| 9)
                               (|HomogeneousAggregate| 9)
                               (|SetCategory|) (|Aggregate|)
                               (|Evalable| 9) (|BasicType|)
                               (|shallowlyMutable|) (|finiteAggregate|)
                               (|CoercibleTo| (|List| 9)) (|Type|)
                               (|CoercibleTo| 27) (|InnerEvalable| 9 9)
                               (|ConvertibleTo| 135))
                            (|makeByteWordVec2| 147
                                '(1 10 0 0 11 2 10 0 18 0 19 2 10 0 18
                                  0 22 2 10 14 9 0 24 1 9 27 0 28 1 27
                                  0 29 30 1 9 8 0 32 1 10 9 0 36 2 8 14
                                  0 0 41 2 9 14 0 0 44 2 10 0 45 0 46 1
                                  9 14 0 48 1 9 0 0 49 1 9 0 0 50 1 9 0
                                  0 51 1 55 54 0 56 0 6 0 57 2 54 14 0
                                  0 58 1 55 2 0 59 2 0 14 8 0 60 2 0 34
                                  0 8 61 2 9 0 0 0 62 1 9 14 0 63 0 9 0
                                  65 2 9 54 0 8 66 1 67 14 0 68 1 9 0 0
                                  69 2 9 0 0 0 70 2 9 0 0 0 71 1 9 0 0
                                  72 2 0 76 9 0 77 1 9 0 0 78 1 79 10 9
                                  80 2 55 0 2 0 84 2 0 29 10 29 85 2 10
                                  0 0 0 86 2 55 0 0 0 88 2 90 14 9 2 91
                                  2 90 93 9 2 94 2 90 55 9 2 98 3 90
                                  100 9 9 2 101 2 90 100 9 2 103 4 104
                                  55 10 55 14 14 105 3 114 112 113 113
                                  113 115 3 90 112 113 113 113 116 3 90
                                  112 113 113 113 117 0 114 112 119 0
                                  90 112 120 0 90 112 121 2 10 0 124 0
                                  125 2 10 14 124 0 126 1 55 14 0 127 2
                                  104 54 10 55 128 1 9 54 0 129 1 79 14
                                  10 130 1 79 10 10 131 2 0 14 0 0 1 1
                                  0 141 10 1 5 0 29 10 14 14 14 14 111
                                  3 0 29 10 14 14 108 2 0 29 10 14 110
                                  1 0 29 10 109 1 0 139 0 1 1 0 14 0 1
                                  1 4 14 0 1 1 0 14 0 1 2 0 14 9 0 1 2
                                  0 9 9 0 1 2 0 82 9 0 83 2 0 146 0 8 1
                                  2 0 14 0 54 1 2 7 0 124 0 1 2 0 34 0
                                  8 61 0 0 0 1 1 4 14 0 26 2 4 14 0 0 1
                                  2 4 14 0 0 1 1 4 14 0 1 4 0 10 10 0
                                  132 45 1 2 4 10 10 0 1 2 4 10 10 0 1
                                  1 0 38 10 1 1 0 0 10 1 1 0 38 0 39 2
                                  0 9 9 0 64 1 8 0 0 1 2 8 0 9 0 1 2 7
                                  0 124 0 1 2 4 76 9 0 77 3 0 14 9 0 45
                                  1 2 0 9 9 0 1 4 8 9 132 0 9 9 1 2 7 9
                                  132 0 1 3 7 9 132 0 9 1 4 0 9 9 0 132
                                  45 1 1 0 143 0 1 2 0 14 9 0 1 2 0 14
                                  9 0 1 1 0 14 0 1 2 0 14 9 0 1 3 0 122
                                  10 14 14 123 1 7 10 0 16 2 0 14 9 0 1
                                  1 0 14 0 1 1 0 8 0 33 2 0 14 0 54 1 1
                                  7 10 0 17 2 8 14 9 0 25 2 6 0 18 0 23
                                  2 0 0 18 0 21 1 0 139 0 1 2 0 14 8 0
                                  1 2 0 14 0 54 1 1 0 113 0 1 3 0 137 9
                                  9 0 1 3 0 82 9 9 0 102 1 0 34 0 37 2
                                  0 29 9 0 87 2 0 138 9 0 1 2 0 14 9 0
                                  52 2 0 96 9 0 97 2 0 29 9 29 1 2 0 29
                                  10 0 1 2 0 29 10 29 107 2 0 29 9 0
                                  106 4 0 29 10 14 14 14 118 7 0 29 9 0
                                  14 14 14 14 14 73 2 0 0 10 0 75 2 0 0
                                  9 0 74 1 0 10 0 1 1 0 14 0 1 2 0 14 9
                                  0 1 2 0 9 9 0 1 2 0 14 0 0 1 2 4 6 6
                                  6 1 2 4 136 9 0 1 1 0 14 0 1 2 0 14 9
                                  0 1 2 0 9 9 0 1 1 0 147 0 1 1 0 34 0
                                  35 2 0 34 124 0 1 2 0 38 0 9 47 2 0
                                  29 10 29 85 2 0 29 9 29 1 2 0 29 10 0
                                  1 2 0 29 9 0 89 2 0 0 0 9 1 2 7 14
                                  124 0 1 2 3 0 0 133 1 3 3 0 0 9 9 1 2
                                  3 0 0 134 1 3 3 0 0 10 10 1 2 0 14 0
                                  0 1 1 0 14 0 15 0 0 0 13 1 0 54 0 1 2
                                  8 54 9 0 1 2 7 54 124 0 1 1 0 0 0 12
                                  1 1 135 0 1 1 0 0 10 20 2 0 0 0 8 42
                                  2 0 0 0 8 43 1 0 0 0 1 2 0 0 0 8 1 1
                                  0 10 0 40 1 0 27 0 31 1 5 54 0 1 2 0
                                  145 10 45 1 3 0 145 10 124 45 1 2 0
                                  14 0 142 1 2 0 29 10 29 1 2 0 29 9 29
                                  1 2 0 29 10 0 1 2 0 29 9 0 53 2 7 14
                                  124 0 1 1 0 139 0 1 2 0 14 9 0 1 2 0
                                  14 8 0 60 2 0 14 0 0 1 1 7 54 0 1)))))
          '|lookupComplete|)) 
