
(/VERSIONCHECK 2) 

(DEFUN |LEXTRIPK;trueVariables| (|lp| $)
  (PROG (|lv| |s| #0=#:G1843 #1=#:G1837 |truels|)
    (RETURN
      (SEQ (LETT |lv|
                 (SPADCALL (SPADCALL |lp| (QREFELT $ 10))
                     (QREFELT $ 12))
                 . #2=(|LEXTRIPK;trueVariables|))
           (LETT |truels| NIL . #2#)
           (SEQ (LETT |s| NIL . #2#) (LETT #0# (QREFELT $ 7) . #2#)
                G190
                (COND
                  ((OR (ATOM #0#)
                       (PROGN (LETT |s| (CAR #0#) . #2#) NIL))
                   (GO G191)))
                (SEQ (EXIT (COND
                             ((SPADCALL
                                  (PROG2 (LETT #1#
                                          (SPADCALL |s| (QREFELT $ 16)) . #2#)
                                         (QCDR #1#)
                                    (|check-union| (QEQCAR #1# 0)
                                     (|OrderedVariableList|
                                      (QREFELT $ 7))
                                     #1#))
                                  |lv| (QREFELT $ 18))
                              (LETT |truels| (CONS |s| |truels|) . #2#)))))
                (LETT #0# (CDR #0#) . #2#) (GO G190) G191 (EXIT NIL))
           (EXIT (REVERSE |truels|)))))) 

(DEFUN |LEXTRIPK;zeroDimensional?;LB;2| (|lp| $)
  (PROG (|truels| |fglmpack| #0=#:G1847 |p| #1=#:G1848 |lq1|)
    (RETURN
      (SEQ (LETT |truels| (|LEXTRIPK;trueVariables| |lp| $)
                 . #2=(|LEXTRIPK;zeroDimensional?;LB;2|))
           (LETT |fglmpack|
                 (|FGLMIfCanPackage| (QREFELT $ 6) |truels|) . #2#)
           (LETT |lq1|
                 (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 $ 21))
                                     #0#) . #2#)))
                        (LETT #1# (CDR #1#) . #2#) (GO G190) G191
                        (EXIT (NREVERSE0 #0#)))) . #2#)
           (EXIT (SPADCALL |lq1|
                     (|compiledLookupCheck| '|zeroDimensional?|
                         (LIST (LIST '|Boolean|)
                               (LIST '|List|
                                     (LIST '|Polynomial|
                                      (|devaluate| (ELT $ 6)))))
                         |fglmpack|))))))) 

(DEFUN |LEXTRIPK;fglmIfCan;LU;3| (|lp| $)
  (PROG (|truels| |fglmpack| #0=#:G1863 |p| #1=#:G1864 |lq1| |foo|
            #2=#:G1862 #3=#:G1865 |q1| #4=#:G1866)
    (RETURN
      (SEQ (EXIT (SEQ (LETT |truels| (|LEXTRIPK;trueVariables| |lp| $)
                            . #5=(|LEXTRIPK;fglmIfCan;LU;3|))
                      (LETT |fglmpack|
                            (|FGLMIfCanPackage| (QREFELT $ 6) |truels|) . #5#)
                      (LETT |lq1|
                            (PROGN
                              (LETT #0# NIL . #5#)
                              (SEQ (LETT |p| NIL . #5#)
                                   (LETT #1# |lp| . #5#) G190
                                   (COND
                                     ((OR (ATOM #1#)
                                       (PROGN
                                         (LETT |p| (CAR #1#) . #5#)
                                         NIL))
                                      #6=(GO G191)))
                                   (SEQ
                                    (EXIT
                                     (LETT #0#
                                      (CONS
                                       (SPADCALL |p| (QREFELT $ 21))
                                       #0#) . #5#)))
                                   (LETT #1# (CDR #1#) . #5#)
                                   #7=(GO G190) G191
                                   (EXIT (NREVERSE0 #0#)))) . #5#)
                      (LETT |foo|
                            (SPADCALL |lq1|
                                (|compiledLookupCheck| '|fglmIfCan|
                                    (LIST
                                     (LIST '|Union|
                                      (LIST '|List|
                                       (LIST '|Polynomial|
                                        (|devaluate| (ELT $ 6))))
                                      '"failed")
                                     (LIST '|List|
                                      (LIST '|Polynomial|
                                       (|devaluate| (ELT $ 6)))))
                                    |fglmpack|)) . #5#)
                      (EXIT (COND
                              ((QEQCAR |foo| 1)
                               (PROGN
                                 (LETT #2# (CONS 1 "failed") . #5#)
                                 (GO #2#)))
                              ('T
                               (SEQ (LETT |lp|
                                     (PROGN
                                       (LETT #3# NIL . #5#)
                                       (SEQ (LETT |q1| NIL . #5#)
                                        (LETT #4# (QCDR |foo|) . #5#)
                                        G190
                                        (COND
                                          ((OR (ATOM #4#)
                                            (PROGN
                                              (LETT |q1|
                                               (CAR #4#) . #5#)
                                              NIL))
                                           #6#))
                                        (SEQ
                                         (EXIT
                                          (LETT #3#
                                           (CONS
                                            (SPADCALL |q1|
                                             (QREFELT $ 23))
                                            #3#) . #5#)))
                                        (LETT #4# (CDR #4#) . #5#) #7#
                                        G191 (EXIT (NREVERSE0 #3#)))) . #5#)
                                    (EXIT (CONS 0 |lp|))))))))
           #2# (EXIT #2#))))) 

(DEFUN |LEXTRIPK;groebner;2L;4| (|lp| $)
  (PROG (|truels| |fglmpack| #0=#:G1871 |p| #1=#:G1872 |lq1| #2=#:G1873
            |q1| #3=#:G1874)
    (RETURN
      (SEQ (LETT |truels| (|LEXTRIPK;trueVariables| |lp| $)
                 . #4=(|LEXTRIPK;groebner;2L;4|))
           (LETT |fglmpack|
                 (|FGLMIfCanPackage| (QREFELT $ 6) |truels|) . #4#)
           (LETT |lq1|
                 (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 $ 21))
                                     #0#) . #4#)))
                        (LETT #1# (CDR #1#) . #4#) #6=(GO G190) G191
                        (EXIT (NREVERSE0 #0#)))) . #4#)
           (LETT |lq1|
                 (SPADCALL |lq1|
                     (|compiledLookupCheck| '|groebner|
                         (LIST (LIST '|List|
                                     (LIST '|Polynomial|
                                      (|devaluate| (ELT $ 6))))
                               (LIST '|List|
                                     (LIST '|Polynomial|
                                      (|devaluate| (ELT $ 6)))))
                         |fglmpack|)) . #4#)
           (EXIT (LETT |lp|
                       (PROGN
                         (LETT #2# NIL . #4#)
                         (SEQ (LETT |q1| NIL . #4#)
                              (LETT #3# |lq1| . #4#) G190
                              (COND
                                ((OR (ATOM #3#)
                                     (PROGN
                                       (LETT |q1| (CAR #3#) . #4#)
                                       NIL))
                                 #5#))
                              (SEQ (EXIT
                                    (LETT #2#
                                     (CONS
                                      (SPADCALL |q1| (QREFELT $ 23))
                                      #2#) . #4#)))
                              (LETT #3# (CDR #3#) . #4#) #6# G191
                              (EXIT (NREVERSE0 #2#)))) . #4#)))))) 

(DEFUN |LEXTRIPK;lexTriangular;LBL;5| (|base| |norm?| $)
  (PROG (|lpwt| |ts| |toSave| |p| |lp| |v| |bwt| |lbwt| |b| |newp|
                |lus| |newlp| |us| #0=#:G1902 |toSee|)
    (RETURN
      (SEQ (LETT |base| (SPADCALL (ELT $ 27) |base| (QREFELT $ 29))
                 . #1=(|LEXTRIPK;lexTriangular;LBL;5|))
           (LETT |base|
                 (SPADCALL (ELT $ 30) |base| (QREFELT $ 32)) . #1#)
           (EXIT (COND
                   ((SPADCALL (ELT $ 33) |base| (QREFELT $ 34)) NIL)
                   ('T
                    (SEQ (LETT |ts| (SPADCALL (QREFELT $ 36)) . #1#)
                         (LETT |toSee| (LIST (CONS |base| |ts|)) . #1#)
                         (LETT |toSave| NIL . #1#)
                         (SEQ G190
                              (COND
                                ((NULL (COND
                                         ((NULL |toSee|) 'NIL)
                                         ('T 'T)))
                                 #2=(GO G191)))
                              (SEQ (LETT |lpwt|
                                    (|SPADfirst| |toSee|) . #1#)
                                   (LETT |toSee| (CDR |toSee|) . #1#)
                                   (LETT |lp| (QCAR |lpwt|) . #1#)
                                   (LETT |ts| (QCDR |lpwt|) . #1#)
                                   (EXIT
                                    (COND
                                      ((NULL |lp|)
                                       (LETT |toSave|
                                        (CONS |ts| |toSave|) . #1#))
                                      ('T
                                       (SEQ
                                        (LETT |p|
                                         (|SPADfirst| |lp|) . #1#)
                                        (LETT |lp| (CDR |lp|) . #1#)
                                        (LETT |v|
                                         (SPADCALL |p| (QREFELT $ 37)) . #1#)
                                        (EXIT
                                         (COND
                                           ((SPADCALL |v| |ts|
                                             (QREFELT $ 38))
                                            (|error|
                                             "lexTriangular$LEXTRIPK: should never happen !"))
                                           ('T
                                            (SEQ
                                             (COND
                                               (|norm?|
                                                (COND
                                                  ((SPADCALL
                                                    (QVELT
                                                     (SPADCALL
                                                      (SPADCALL |p|
                                                       (QREFELT $ 39))
                                                      |ts|
                                                      (QREFELT $ 41))
                                                     1)
                                                    (QREFELT $ 30))
                                                   (EXIT
                                                    (LETT |toSee|
                                                     (CONS
                                                      (CONS |lp| |ts|)
                                                      |toSee|) . #1#))))))
                                             (COND
                                               ((NULL |norm?|)
                                                (COND
                                                  ((SPADCALL
                                                    (SPADCALL
                                                     (SPADCALL |p|
                                                      (QREFELT $ 39))
                                                     |ts|
                                                     (QREFELT $ 42))
                                                    (QREFELT $ 30))
                                                   (EXIT
                                                    (LETT |toSee|
                                                     (CONS
                                                      (CONS |lp| |ts|)
                                                      |toSee|) . #1#))))))
                                             (LETT |lbwt|
                                              (SPADCALL
                                               (SPADCALL |p|
                                                (QREFELT $ 39))
                                               |ts| (QREFELT $ 45)) . #1#)
                                             (EXIT
                                              (SEQ G190
                                               (COND
                                                 ((NULL
                                                   (COND
                                                     ((NULL |lbwt|)
                                                      'NIL)
                                                     ('T 'T)))
                                                  #2#))
                                               (SEQ
                                                (LETT |bwt|
                                                 (|SPADfirst| |lbwt|) . #1#)
                                                (LETT |lbwt|
                                                 (CDR |lbwt|) . #1#)
                                                (LETT |b|
                                                 (QCAR |bwt|) . #1#)
                                                (LETT |us|
                                                 (QCDR |bwt|) . #1#)
                                                (EXIT
                                                 (COND
                                                   (|b|
                                                    (SEQ
                                                     (COND
                                                       (|norm?|
                                                        (SEQ
                                                         (LETT |newp|
                                                          (SPADCALL |p|
                                                           |us|
                                                           (QREFELT $
                                                            47)) . #1#)
                                                         (EXIT
                                                          (LETT |lus|
                                                           (LIST
                                                            (SPADCALL
                                                             |newp|
                                                             |us|
                                                             (QREFELT $
                                                              48))) . #1#))))
                                                       ('T
                                                        (SEQ
                                                         (LETT |newp|
                                                          |p| . #1#)
                                                         (EXIT
                                                          (LETT |lus|
                                                           (SPADCALL
                                                            |newp| |us|
                                                            (QREFELT $
                                                             50)) . #1#)))))
                                                     (LETT |newlp|
                                                      |lp| . #1#)
                                                     (SEQ G190
                                                      (COND
                                                        ((NULL
                                                          (COND
                                                            ((NULL
                                                              |newlp|)
                                                             'NIL)
                                                            ('T
                                                             (SPADCALL
                                                              (SPADCALL
                                                               (|SPADfirst|
                                                                |newlp|)
                                                               (QREFELT
                                                                $ 37))
                                                              |v|
                                                              (QREFELT
                                                               $ 51)))))
                                                         #2#))
                                                      (SEQ
                                                       (EXIT
                                                        (LETT |newlp|
                                                         (CDR |newlp|) . #1#)))
                                                      NIL #3=(GO G190)
                                                      G191 (EXIT NIL))
                                                     (EXIT
                                                      (SEQ
                                                       (LETT |us|
                                                        NIL . #1#)
                                                       (LETT #0#
                                                        |lus| . #1#)
                                                       G190
                                                       (COND
                                                         ((OR
                                                           (ATOM #0#)
                                                           (PROGN
                                                             (LETT |us|
                                                              (CAR #0#) . #1#)
                                                             NIL))
                                                          #2#))
                                                       (SEQ
                                                        (EXIT
                                                         (LETT |toSee|
                                                          (CONS
                                                           (CONS
                                                            |newlp|
                                                            |us|)
                                                           |toSee|) . #1#)))
                                                       (LETT #0#
                                                        (CDR #0#) . #1#)
                                                       #3# G191
                                                       (EXIT NIL)))))
                                                   ('T
                                                    (LETT |toSee|
                                                     (CONS
                                                      (CONS |lp| |us|)
                                                      |toSee|) . #1#)))))
                                               NIL #3# G191 (EXIT NIL))))))))))))
                              NIL #3# G191 (EXIT NIL))
                         (EXIT (SPADCALL |toSave| (QREFELT $ 54))))))))))) 

(DEFUN |LEXTRIPK;zeroSetSplit;LBL;6| (|lp| |norm?| $)
  (PROG (|bar|)
    (RETURN
      (SEQ (LETT |bar| (SPADCALL |lp| (QREFELT $ 25))
                 |LEXTRIPK;zeroSetSplit;LBL;6|)
           (EXIT (COND
                   ((QEQCAR |bar| 1)
                    (|error| "zeroSetSplit$LEXTRIPK: #1 not zero-dimensional"))
                   ('T (SPADCALL (QCDR |bar|) |norm?| (QREFELT $ 55))))))))) 

(DEFUN |LEXTRIPK;squareFreeLexTriangular;LBL;7| (|base| |norm?| $)
  (PROG (|lpwt| |ts| |toSave| |p| |lp| |v| |bwt| |lbwt| |b| |newp|
                |lus| |newlp| |us| #0=#:G1929 |toSee|)
    (RETURN
      (SEQ (LETT |base| (SPADCALL (ELT $ 27) |base| (QREFELT $ 29))
                 . #1=(|LEXTRIPK;squareFreeLexTriangular;LBL;7|))
           (LETT |base|
                 (SPADCALL (ELT $ 30) |base| (QREFELT $ 32)) . #1#)
           (EXIT (COND
                   ((SPADCALL (ELT $ 33) |base| (QREFELT $ 34)) NIL)
                   ('T
                    (SEQ (LETT |ts| (SPADCALL (QREFELT $ 58)) . #1#)
                         (LETT |toSee| (LIST (CONS |base| |ts|)) . #1#)
                         (LETT |toSave| NIL . #1#)
                         (SEQ G190
                              (COND
                                ((NULL (COND
                                         ((NULL |toSee|) 'NIL)
                                         ('T 'T)))
                                 #2=(GO G191)))
                              (SEQ (LETT |lpwt|
                                    (|SPADfirst| |toSee|) . #1#)
                                   (LETT |toSee| (CDR |toSee|) . #1#)
                                   (LETT |lp| (QCAR |lpwt|) . #1#)
                                   (LETT |ts| (QCDR |lpwt|) . #1#)
                                   (EXIT
                                    (COND
                                      ((NULL |lp|)
                                       (LETT |toSave|
                                        (CONS |ts| |toSave|) . #1#))
                                      ('T
                                       (SEQ
                                        (LETT |p|
                                         (|SPADfirst| |lp|) . #1#)
                                        (LETT |lp| (CDR |lp|) . #1#)
                                        (LETT |v|
                                         (SPADCALL |p| (QREFELT $ 37)) . #1#)
                                        (EXIT
                                         (COND
                                           ((SPADCALL |v| |ts|
                                             (QREFELT $ 59))
                                            (|error|
                                             "lexTriangular$LEXTRIPK: should never happen !"))
                                           ('T
                                            (SEQ
                                             (COND
                                               (|norm?|
                                                (COND
                                                  ((SPADCALL
                                                    (QVELT
                                                     (SPADCALL
                                                      (SPADCALL |p|
                                                       (QREFELT $ 39))
                                                      |ts|
                                                      (QREFELT $ 60))
                                                     1)
                                                    (QREFELT $ 30))
                                                   (EXIT
                                                    (LETT |toSee|
                                                     (CONS
                                                      (CONS |lp| |ts|)
                                                      |toSee|) . #1#))))))
                                             (COND
                                               ((NULL |norm?|)
                                                (COND
                                                  ((SPADCALL
                                                    (SPADCALL
                                                     (SPADCALL |p|
                                                      (QREFELT $ 39))
                                                     |ts|
                                                     (QREFELT $ 61))
                                                    (QREFELT $ 30))
                                                   (EXIT
                                                    (LETT |toSee|
                                                     (CONS
                                                      (CONS |lp| |ts|)
                                                      |toSee|) . #1#))))))
                                             (LETT |lbwt|
                                              (SPADCALL
                                               (SPADCALL |p|
                                                (QREFELT $ 39))
                                               |ts| (QREFELT $ 62)) . #1#)
                                             (EXIT
                                              (SEQ G190
                                               (COND
                                                 ((NULL
                                                   (COND
                                                     ((NULL |lbwt|)
                                                      'NIL)
                                                     ('T 'T)))
                                                  #2#))
                                               (SEQ
                                                (LETT |bwt|
                                                 (|SPADfirst| |lbwt|) . #1#)
                                                (LETT |lbwt|
                                                 (CDR |lbwt|) . #1#)
                                                (LETT |b|
                                                 (QCAR |bwt|) . #1#)
                                                (LETT |us|
                                                 (QCDR |bwt|) . #1#)
                                                (EXIT
                                                 (COND
                                                   (|b|
                                                    (SEQ
                                                     (COND
                                                       (|norm?|
                                                        (SEQ
                                                         (LETT |newp|
                                                          (SPADCALL |p|
                                                           |us|
                                                           (QREFELT $
                                                            64)) . #1#)
                                                         (EXIT
                                                          (LETT |lus|
                                                           (SPADCALL
                                                            |newp| |us|
                                                            (QREFELT $
                                                             65)) . #1#))))
                                                       ('T
                                                        (LETT |lus|
                                                         (SPADCALL |p|
                                                          |us|
                                                          (QREFELT $
                                                           65)) . #1#)))
                                                     (LETT |newlp|
                                                      |lp| . #1#)
                                                     (SEQ G190
                                                      (COND
                                                        ((NULL
                                                          (COND
                                                            ((NULL
                                                              |newlp|)
                                                             'NIL)
                                                            ('T
                                                             (SPADCALL
                                                              (SPADCALL
                                                               (|SPADfirst|
                                                                |newlp|)
                                                               (QREFELT
                                                                $ 37))
                                                              |v|
                                                              (QREFELT
                                                               $ 51)))))
                                                         #2#))
                                                      (SEQ
                                                       (EXIT
                                                        (LETT |newlp|
                                                         (CDR |newlp|) . #1#)))
                                                      NIL #3=(GO G190)
                                                      G191 (EXIT NIL))
                                                     (EXIT
                                                      (SEQ
                                                       (LETT |us|
                                                        NIL . #1#)
                                                       (LETT #0#
                                                        |lus| . #1#)
                                                       G190
                                                       (COND
                                                         ((OR
                                                           (ATOM #0#)
                                                           (PROGN
                                                             (LETT |us|
                                                              (CAR #0#) . #1#)
                                                             NIL))
                                                          #2#))
                                                       (SEQ
                                                        (EXIT
                                                         (LETT |toSee|
                                                          (CONS
                                                           (CONS
                                                            |newlp|
                                                            |us|)
                                                           |toSee|) . #1#)))
                                                       (LETT #0#
                                                        (CDR #0#) . #1#)
                                                       #3# G191
                                                       (EXIT NIL)))))
                                                   ('T
                                                    (LETT |toSee|
                                                     (CONS
                                                      (CONS |lp| |us|)
                                                      |toSee|) . #1#)))))
                                               NIL #3# G191 (EXIT NIL))))))))))))
                              NIL #3# G191 (EXIT NIL))
                         (EXIT (SPADCALL |toSave| (QREFELT $ 68))))))))))) 

(DEFUN |LEXTRIPK;zeroSetSplit;LBL;8| (|lp| |norm?| $)
  (PROG (|bar|)
    (RETURN
      (SEQ (LETT |bar| (SPADCALL |lp| (QREFELT $ 25))
                 |LEXTRIPK;zeroSetSplit;LBL;8|)
           (EXIT (COND
                   ((QEQCAR |bar| 1)
                    (|error| "zeroSetSplit$LEXTRIPK: #1 not zero-dimensional"))
                   ('T (SPADCALL (QCDR |bar|) |norm?| (QREFELT $ 69))))))))) 

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

(DEFUN |LexTriangularPackage;| (|#1| |#2|)
  (PROG (DV$1 DV$2 |dv$| $ |pv$|)
    (RETURN
      (PROGN
        (LETT DV$1 (|devaluate| |#1|) . #0=(|LexTriangularPackage|))
        (LETT DV$2 (|devaluate| |#2|) . #0#)
        (LETT |dv$| (LIST '|LexTriangularPackage| DV$1 DV$2) . #0#)
        (LETT $ (GETREFV 71) . #0#)
        (QSETREFV $ 0 |dv$|)
        (QSETREFV $ 3 (LETT |pv$| (|buildPredVector| 0 0 NIL) . #0#))
        (|haddProp| |$ConstructorCache| '|LexTriangularPackage|
            (LIST DV$1 DV$2) (CONS 1 $))
        (|stuffDomainSlots| $)
        (QSETREFV $ 6 |#1|)
        (QSETREFV $ 7 |#2|)
        $)))) 

(MAKEPROP '|LexTriangularPackage| '|infovec|
    (LIST '#(NIL NIL NIL NIL NIL NIL (|local| |#1|) (|local| |#2|)
             (|List| 20)
             (|GeneralPolynomialSet| 6 (|IndexedExponents| 15) 15 20)
             (0 . |construct|) (|List| 15) (5 . |variables|)
             (|Union| $ '"failed") (|Symbol|) (|OrderedVariableList| 7)
             (10 . |variable|) (|Boolean|) (15 . |member?|)
             (|Polynomial| 6) (|NewSparseMultivariatePolynomial| 6 15)
             (21 . |coerce|) |LEXTRIPK;zeroDimensional?;LB;2|
             (26 . |retract|) (|Union| 8 '"failed")
             |LEXTRIPK;fglmIfCan;LU;3| |LEXTRIPK;groebner;2L;4|
             (31 . |infRittWu?|) (|Mapping| 17 20 20) (37 . |sort|)
             (43 . |zero?|) (|Mapping| 17 20) (48 . |remove|)
             (54 . |ground?|) (59 . |any?|) (|RegularChain| 6 7)
             (65 . |empty|) (69 . |mvar|) (74 . |algebraic?|)
             (80 . |init|)
             (|Record| (|:| |rnum| 6) (|:| |polnum| 20) (|:| |den| 6))
             (85 . |remainder|) (91 . |initiallyReduce|)
             (|Record| (|:| |val| 17) (|:| |tower| $)) (|List| 43)
             (97 . |invertible?|)
             (|NormalizationPackage| 6 (|IndexedExponents| 15) 15 20
                 35)
             (103 . |normalizedAssociate|) (109 . |internalAugment|)
             (|List| $) (115 . |augment|) (121 . =) (|List| 35)
             (|QuasiComponentPackage| 6 (|IndexedExponents| 15) 15 20
                 35)
             (127 . |algebraicSort|) |LEXTRIPK;lexTriangular;LBL;5|
             |LEXTRIPK;zeroSetSplit;LBL;6|
             (|SquareFreeRegularTriangularSet| 6
                 (|IndexedExponents| 15) 15 20)
             (132 . |empty|) (136 . |algebraic?|) (142 . |remainder|)
             (148 . |initiallyReduce|) (154 . |invertible?|)
             (|NormalizationPackage| 6 (|IndexedExponents| 15) 15 20
                 57)
             (160 . |normalizedAssociate|) (166 . |augment|)
             (|List| 57)
             (|QuasiComponentPackage| 6 (|IndexedExponents| 15) 15 20
                 57)
             (172 . |algebraicSort|)
             |LEXTRIPK;squareFreeLexTriangular;LBL;7|
             |LEXTRIPK;zeroSetSplit;LBL;8|)
          '#(|zeroSetSplit| 177 |zeroDimensional?| 189
             |squareFreeLexTriangular| 194 |lexTriangular| 200
             |groebner| 206 |fglmIfCan| 211)
          'NIL
          (CONS (|makeByteWordVec2| 1 'NIL)
                (CONS '#()
                      (CONS '#()
                            (|makeByteWordVec2| 70
                                '(1 9 0 8 10 1 9 11 0 12 1 15 13 14 16
                                  2 11 17 15 0 18 1 20 19 0 21 1 20 0
                                  19 23 2 20 17 0 0 27 2 8 0 28 0 29 1
                                  20 17 0 30 2 8 0 31 0 32 1 20 17 0 33
                                  2 8 17 31 0 34 0 35 0 36 1 20 15 0 37
                                  2 35 17 15 0 38 1 20 0 0 39 2 35 40
                                  20 0 41 2 35 20 20 0 42 2 35 44 20 0
                                  45 2 46 20 20 35 47 2 35 0 20 0 48 2
                                  35 49 20 0 50 2 15 17 0 0 51 1 53 52
                                  52 54 0 57 0 58 2 57 17 15 0 59 2 57
                                  40 20 0 60 2 57 20 20 0 61 2 57 44 20
                                  0 62 2 63 20 20 57 64 2 57 49 20 0 65
                                  1 67 66 66 68 2 0 66 8 17 70 2 0 52 8
                                  17 56 1 0 17 8 22 2 0 66 8 17 69 2 0
                                  52 8 17 55 1 0 8 8 26 1 0 24 8 25)))))
          '|lookupComplete|)) 
