
(/VERSIONCHECK 2) 

(DEFUN |GBF;createGroebnerBases|
       (|basis| |redPols| |nonZeroRestrictions| |inputPolys| |lcP|
                |listOfBases| |info| $)
  (PROG (|h| |q| #0=#:G1859 #1=#:G1860 |nPq| |stopDividing|
             |terminateWithBasis| |irreducibleFactors| |doSplitting?|
             #2=#:G1861 |allReducedFactors| |nP| |fnP| #3=#:G1862
             |newInputPolys| #4=#:G1863 |p| #5=#:G1864 |newBasis|)
    (RETURN
      (SEQ (LETT |doSplitting?| 'NIL . #6=(|GBF;createGroebnerBases|))
           (LETT |terminateWithBasis| 'NIL . #6#)
           (LETT |allReducedFactors| NIL . #6#)
           (SEQ G190
                (COND
                  ((NULL (COND
                           ((OR |doSplitting?| |terminateWithBasis|)
                            'NIL)
                           ('T 'T)))
                   #7=(GO G191)))
                (SEQ (LETT |terminateWithBasis|
                           (COND
                             ((NULL |inputPolys|) (NULL |lcP|))
                             ('T 'NIL)) . #6#)
                     (EXIT (COND
                             ((NULL |terminateWithBasis|)
                              (SEQ (LETT |nP|
                                    (COND
                                      ((NULL |inputPolys|)
                                       (SEQ
                                        (LETT |h|
                                         (SPADCALL (|SPADfirst| |lcP|)
                                          (QREFELT $ 12)) . #6#)
                                        (LETT |lcP| (CDR |lcP|) . #6#)
                                        (EXIT
                                         (SPADCALL
                                          (SPADCALL |h| |redPols|
                                           (QREFELT $ 14))
                                          (QREFELT $ 15)))))
                                      ('T
                                       (SEQ
                                        (LETT |p|
                                         (|SPADfirst| |inputPolys|) . #6#)
                                        (LETT |inputPolys|
                                         (CDR |inputPolys|) . #6#)
                                        (EXIT
                                         (SPADCALL
                                          (SPADCALL |p| |redPols|
                                           (QREFELT $ 14))
                                          (QREFELT $ 15)))))) . #6#)
                                   (EXIT
                                    (COND
                                      ((SPADCALL |nP|
                                        (|spadConstant| $ 16)
                                        (QREFELT $ 18))
                                       (SEQ
                                        (LETT |basis|
                                         (LIST
                                          (CONS 0
                                           (|spadConstant| $ 16))) . #6#)
                                        (EXIT
                                         (LETT |terminateWithBasis|
                                          'T . #6#))))
                                      ((NULL
                                        (SPADCALL |nP|
                                         (|spadConstant| $ 21)
                                         (QREFELT $ 18)))
                                       (SEQ
                                        (SEQ (LETT |q| NIL . #6#)
                                         (LETT #0#
                                          |nonZeroRestrictions| . #6#)
                                         G190
                                         (COND
                                           ((OR (ATOM #0#)
                                             (PROGN
                                               (LETT |q|
                                                (CAR #0#) . #6#)
                                               NIL))
                                            #7#))
                                         (SEQ
                                          (LETT |stopDividing|
                                           'NIL . #6#)
                                          (EXIT
                                           (SEQ (LETT #1# NIL . #6#)
                                            G190 (COND (#1# #7#))
                                            (SEQ
                                             (LETT |nPq|
                                              (SPADCALL |nP| |q|
                                               (QREFELT $ 23)) . #6#)
                                             (LETT |stopDividing|
                                              (QEQCAR |nPq| 1) . #6#)
                                             (COND
                                               ((NULL |stopDividing|)
                                                (LETT |nP|
                                                 (QCDR |nPq|) . #6#)))
                                             (EXIT
                                              (LETT |stopDividing|
                                               (COND
                                                 (|stopDividing| 'T)
                                                 ('T
                                                  (SPADCALL
                                                   (SPADCALL |nP|
                                                    (QREFELT $ 24))
                                                   (QREFELT $ 25)))) . #6#)))
                                            (LETT #1#
                                             |stopDividing| . #6#)
                                            #8=(GO G190) G191
                                            (EXIT NIL))))
                                         (LETT #0# (CDR #0#) . #6#) #8#
                                         G191 (EXIT NIL))
                                        (EXIT
                                         (COND
                                           ((SPADCALL
                                             (SPADCALL |nP|
                                              (QREFELT $ 24))
                                             (QREFELT $ 25))
                                            (SEQ
                                             (LETT |basis|
                                              (LIST
                                               (CONS 0
                                                (|spadConstant| $ 16))) . #6#)
                                             (EXIT
                                              (LETT
                                               |terminateWithBasis|
                                               'T . #6#))))
                                           ('T
                                            (SEQ
                                             (LETT |nP|
                                              (SPADCALL
                                               (SPADCALL |nP| |redPols|
                                                (QREFELT $ 14))
                                               (QREFELT $ 15)) . #6#)
                                             (EXIT
                                              (COND
                                                ((SPADCALL
                                                  (SPADCALL |nP|
                                                   (QREFELT $ 24))
                                                  (QREFELT $ 25))
                                                 (SEQ
                                                  (LETT |basis|
                                                   (LIST
                                                    (CONS 0
                                                     (|spadConstant| $
                                                      16))) . #6#)
                                                  (EXIT
                                                   (LETT
                                                    |terminateWithBasis|
                                                    'T . #6#))))
                                                ((NULL
                                                  (SPADCALL |nP|
                                                   (|spadConstant| $
                                                    21)
                                                   (QREFELT $ 18)))
                                                 (SEQ
                                                  (LETT
                                                   |irreducibleFactors|
                                                   (|GBF;createAllFactors|
                                                    |nP| $) . #6#)
                                                  (LETT |doSplitting?|
                                                   (COND
                                                     ((NULL
                                                       (CDR
                                                        |irreducibleFactors|))
                                                      'NIL)
                                                     ('T 'T)) . #6#)
                                                  (EXIT
                                                   (COND
                                                     (|doSplitting?|
                                                      (SEQ
                                                       (SEQ
                                                        (LETT |fnP|
                                                         NIL . #6#)
                                                        (LETT #2#
                                                         |irreducibleFactors| . #6#)
                                                        G190
                                                        (COND
                                                          ((OR
                                                            (ATOM #2#)
                                                            (PROGN
                                                              (LETT
                                                               |fnP|
                                                               (CAR
                                                                #2#) . #6#)
                                                              NIL))
                                                           #7#))
                                                        (SEQ
                                                         (LETT |fnP|
                                                          (SPADCALL
                                                           (SPADCALL
                                                            |fnP|
                                                            |redPols|
                                                            (QREFELT $
                                                             14))
                                                           (QREFELT $
                                                            15)) . #6#)
                                                         (EXIT
                                                          (LETT
                                                           |allReducedFactors|
                                                           (CONS |fnP|
                                                            |allReducedFactors|) . #6#)))
                                                        (LETT #2#
                                                         (CDR #2#) . #6#)
                                                        #8# G191
                                                        (EXIT NIL))
                                                       (EXIT
                                                        (LETT
                                                         |allReducedFactors|
                                                         (REVERSE
                                                          |allReducedFactors|) . #6#))))
                                                     ('T
                                                      (SEQ
                                                       (LETT |nP|
                                                        (|SPADfirst|
                                                         |irreducibleFactors|) . #6#)
                                                       (LETT |lcP|
                                                        (|GBF;updateCritPairs|
                                                         |lcP|
                                                         (|GBF;newPairs|
                                                          |basis| |nP|
                                                          $)
                                                         |nP| $) . #6#)
                                                       (LETT |basis|
                                                        (|GBF;updateBasis|
                                                         |basis| |nP|
                                                         (SPADCALL |nP|
                                                          (QREFELT $
                                                           27))
                                                         $) . #6#)
                                                       (EXIT
                                                        (LETT |redPols|
                                                         (SPADCALL
                                                          |redPols|
                                                          |nP|
                                                          (QREFELT $
                                                           28)) . #6#)))))))))))))))))))))))
                NIL #8# G191 (EXIT NIL))
           (EXIT (COND
                   (|doSplitting?|
                       (SEQ (SEQ (LETT |fnP| NIL . #6#)
                                 (LETT #3# |allReducedFactors| . #6#)
                                 G190
                                 (COND
                                   ((OR (ATOM #3#)
                                     (PROGN
                                       (LETT |fnP| (CAR #3#) . #6#)
                                       NIL))
                                    #7#))
                                 (SEQ (EXIT
                                       (COND
                                         ((SPADCALL |fnP|
                                           (|spadConstant| $ 16)
                                           (QREFELT $ 18))
                                          (SEQ
                                           (COND
                                             (|info|
                                              (SPADCALL
                                               "we terminated with [1]"
                                               (QREFELT $ 32))))
                                           (EXIT
                                            (LETT |listOfBases|
                                             (CONS
                                              (LIST
                                               (|spadConstant| $ 16))
                                              |listOfBases|) . #6#))))
                                         ('T
                                          (SEQ
                                           (LETT |newInputPolys|
                                            (SPADCALL
                                             (CONS
                                              #'|GBF;createGroebnerBases!0|
                                              $)
                                             (CONS |fnP| |inputPolys|)
                                             (QREFELT $ 35)) . #6#)
                                           (LETT |listOfBases|
                                            (|GBF;createGroebnerBases|
                                             |basis| |redPols|
                                             |nonZeroRestrictions|
                                             |newInputPolys| |lcP|
                                             |listOfBases| |info| $) . #6#)
                                           (EXIT
                                            (LETT |nonZeroRestrictions|
                                             (CONS |fnP|
                                              |nonZeroRestrictions|) . #6#)))))))
                                 (LETT #3# (CDR #3#) . #6#) #8# G191
                                 (EXIT NIL))
                            (EXIT |listOfBases|)))
                   ('T
                    (SEQ (LETT |newBasis|
                               (SPADCALL
                                   (SPADCALL
                                    (CONS #'|GBF;createGroebnerBases!1|
                                     $)
                                    (PROGN
                                      (LETT #4# NIL . #6#)
                                      (SEQ (LETT |p| NIL . #6#)
                                       (LETT #5# |basis| . #6#) G190
                                       (COND
                                         ((OR (ATOM #5#)
                                           (PROGN
                                             (LETT |p| (CAR #5#) . #6#)
                                             NIL))
                                          #7#))
                                       (SEQ
                                        (EXIT
                                         (LETT #4#
                                          (CONS (QCDR |p|) #4#) . #6#)))
                                       (LETT #5# (CDR #5#) . #6#) #8#
                                       G191 (EXIT (NREVERSE0 #4#))))
                                    (QREFELT $ 35))
                                   (QREFELT $ 36)) . #6#)
                         (COND
                           (|info| (SEQ
                                    (SPADCALL
                                     "we found a groebner basis and check whether it "
                                     (QREFELT $ 32))
                                    (SPADCALL
                                     "contains reducible polynomials"
                                     (QREFELT $ 32))
                                    (EXIT
                                     (SPADCALL
                                      (SPADCALL |newBasis|
                                       (QREFELT $ 37))
                                      (QREFELT $ 38))))))
                         (EXIT (SPADCALL
                                   (APPEND
                                    (SPADCALL |newBasis| |info|
                                     (QREFELT $ 40))
                                    |listOfBases|)
                                   (QREFELT $ 41))))))))))) 

(DEFUN |GBF;createGroebnerBases!1| (|#1| |#2| $)
  (SPADCALL (SPADCALL |#2| (QREFELT $ 24))
      (SPADCALL |#1| (QREFELT $ 24)) (QREFELT $ 33))) 

(DEFUN |GBF;createGroebnerBases!0| (|#1| |#2| $)
  (SPADCALL (SPADCALL |#2| (QREFELT $ 24))
      (SPADCALL |#1| (QREFELT $ 24)) (QREFELT $ 33))) 

(DEFUN |GBF;createAllFactors| (|p| $)
  (PROG (#0=#:G1876 |el| #1=#:G1877 |loF|)
    (RETURN
      (SEQ (LETT |loF|
                 (PROGN
                   (LETT #0# NIL . #2=(|GBF;createAllFactors|))
                   (SEQ (LETT |el| NIL . #2#)
                        (LETT #1#
                              (SPADCALL (SPADCALL |p| (QREFELT $ 44))
                                  (QREFELT $ 48)) . #2#)
                        G190
                        (COND
                          ((OR (ATOM #1#)
                               (PROGN (LETT |el| (CAR #1#) . #2#) NIL))
                           (GO G191)))
                        (SEQ (EXIT (LETT #0#
                                    (CONS (QVELT |el| 1) #0#) . #2#)))
                        (LETT #1# (CDR #1#) . #2#) (GO G190) G191
                        (EXIT (NREVERSE0 #0#)))) . #2#)
           (EXIT (SPADCALL (CONS #'|GBF;createAllFactors!0| $) |loF|
                     (QREFELT $ 35))))))) 

(DEFUN |GBF;createAllFactors!0| (|#1| |#2| $)
  (SPADCALL (SPADCALL |#1| (QREFELT $ 24))
      (SPADCALL |#2| (QREFELT $ 24)) (QREFELT $ 33))) 

(DEFUN |GBF;newPairs| (|lp| |p| $)
  (PROG (|totdegreeOfp| #0=#:G1886 |q| #1=#:G1887 |lcP|)
    (RETURN
      (SEQ (LETT |totdegreeOfp| (SPADCALL |p| (QREFELT $ 27))
                 . #2=(|GBF;newPairs|))
           (LETT |lcP|
                 (PROGN
                   (LETT #0# NIL . #2#)
                   (SEQ (LETT |q| NIL . #2#) (LETT #1# |lp| . #2#) G190
                        (COND
                          ((OR (ATOM #1#)
                               (PROGN (LETT |q| (CAR #1#) . #2#) NIL))
                           (GO G191)))
                        (SEQ (EXIT (LETT #0#
                                    (CONS
                                     (SPADCALL |q| |p| |totdegreeOfp|
                                      (QREFELT $ 50))
                                     #0#) . #2#)))
                        (LETT #1# (CDR #1#) . #2#) (GO G190) G191
                        (EXIT (NREVERSE0 #0#)))) . #2#)
           (EXIT (SPADCALL (SPADCALL (ELT $ 51) |lcP| (QREFELT $ 54))
                     (QREFELT $ 55))))))) 

(DEFUN |GBF;updateCritPairs|
       (|oldListOfcritPairs| |newListOfcritPairs| |p| $)
  (SPADCALL |newListOfcritPairs|
      (SPADCALL |p| |oldListOfcritPairs| (QREFELT $ 56))
      (QREFELT $ 57))) 

(DEFUN |GBF;updateBasis| (|lp| |p| |deg| $)
  (SPADCALL |p| |deg| |lp| (QREFELT $ 59))) 

(DEFUN |GBF;factorGroebnerBasis;LL;6| (|basis| $)
  (SPADCALL |basis| 'NIL (QREFELT $ 40))) 

(DEFUN |GBF;factorGroebnerBasis;LBL;7| (|basis| |info| $)
  (PROG (|p| #0=#:G1906 #1=#:G1907 |el| #2=#:G1908 |foundAReducible|)
    (RETURN
      (SEQ (LETT |foundAReducible| 'NIL
                 . #3=(|GBF;factorGroebnerBasis;LBL;7|))
           (SEQ (LETT |p| NIL . #3#) (LETT #0# |basis| . #3#) G190
                (COND
                  ((OR (ATOM #0#)
                       (PROGN (LETT |p| (CAR #0#) . #3#) NIL)
                       (NULL (COND (|foundAReducible| 'NIL) ('T 'T))))
                   #4=(GO G191)))
                (SEQ (EXIT (LETT |foundAReducible|
                                 (< 1
                                    (LENGTH
                                     (PROGN
                                       (LETT #1# NIL . #3#)
                                       (SEQ (LETT |el| NIL . #3#)
                                        (LETT #2#
                                         (SPADCALL
                                          (SPADCALL |p| (QREFELT $ 44))
                                          (QREFELT $ 48)) . #3#)
                                        G190
                                        (COND
                                          ((OR (ATOM #2#)
                                            (PROGN
                                              (LETT |el|
                                               (CAR #2#) . #3#)
                                              NIL))
                                           #4#))
                                        (SEQ
                                         (EXIT
                                          (LETT #1#
                                           (CONS (QVELT |el| 1) #1#) . #3#)))
                                        (LETT #2# (CDR #2#) . #3#)
                                        #5=(GO G190) G191
                                        (EXIT (NREVERSE0 #1#)))))) . #3#)))
                (LETT #0# (CDR #0#) . #3#) #5# G191 (EXIT NIL))
           (EXIT (COND
                   (|foundAReducible|
                       (SEQ (COND
                              (|info| (SPADCALL
                                       "factorGroebnerBasis:        we found reducible polynomials and continue splitting"
                                       (QREFELT $ 32))))
                            (EXIT (|GBF;createGroebnerBases| NIL NIL
                                      NIL |basis| NIL NIL |info| $))))
                   ('T
                    (SEQ (COND
                           (|info| (SPADCALL
                                    "factorGroebnerBasis: no reducible polynomials in this basis"
                                    (QREFELT $ 32))))
                         (EXIT (LIST |basis|)))))))))) 

(DEFUN |GBF;groebnerFactorize;2LL;8| (|basis| |nonZeroRestrictions| $)
  (SPADCALL |basis| |nonZeroRestrictions| 'NIL (QREFELT $ 63))) 

(DEFUN |GBF;groebnerFactorize;2LBL;9|
       (|basis| |nonZeroRestrictions| |info| $)
  (PROG (#0=#:G1917 |p| #1=#:G1918)
    (RETURN
      (SEQ (COND
             ((SPADCALL |basis| NIL (QREFELT $ 65)) (LIST |basis|))
             (#2='T
              (SEQ (LETT |basis|
                         (SPADCALL
                             (CONS #'|GBF;groebnerFactorize;2LBL;9!0|
                                   $)
                             |basis| (QREFELT $ 67))
                         . #3=(|GBF;groebnerFactorize;2LBL;9|))
                   (EXIT (COND
                           ((SPADCALL |basis| NIL (QREFELT $ 65))
                            (LIST (LIST (|spadConstant| $ 21))))
                           (#2#
                            (SEQ (LETT |basis|
                                       (PROGN
                                         (LETT #0# NIL . #3#)
                                         (SEQ (LETT |p| NIL . #3#)
                                          (LETT #1# |basis| . #3#) G190
                                          (COND
                                            ((OR (ATOM #1#)
                                              (PROGN
                                                (LETT |p|
                                                 (CAR #1#) . #3#)
                                                NIL))
                                             (GO G191)))
                                          (SEQ
                                           (EXIT
                                            (LETT #0#
                                             (CONS
                                              (SPADCALL |p|
                                               (QREFELT $ 15))
                                              #0#) . #3#)))
                                          (LETT #1# (CDR #1#) . #3#)
                                          (GO G190) G191
                                          (EXIT (NREVERSE0 #0#)))) . #3#)
                                 (EXIT (COND
                                         ((SPADCALL
                                           (|spadConstant| $ 16)
                                           |basis| (QREFELT $ 68))
                                          (LIST
                                           (LIST (|spadConstant| $ 16))))
                                         ('T
                                          (SEQ
                                           (LETT |basis|
                                            (SPADCALL
                                             (CONS
                                              #'|GBF;groebnerFactorize;2LBL;9!1|
                                              $)
                                             |basis| (QREFELT $ 35)) . #3#)
                                           (EXIT
                                            (|GBF;createGroebnerBases|
                                             NIL NIL
                                             |nonZeroRestrictions|
                                             |basis| NIL NIL |info| $))))))))))))))))) 

(DEFUN |GBF;groebnerFactorize;2LBL;9!1| (|#1| |#2| $)
  (SPADCALL (SPADCALL |#2| (QREFELT $ 24))
      (SPADCALL |#1| (QREFELT $ 24)) (QREFELT $ 33))) 

(DEFUN |GBF;groebnerFactorize;2LBL;9!0| (|#1| $)
  (SPADCALL |#1| (|spadConstant| $ 21) (QREFELT $ 18))) 

(DEFUN |GBF;groebnerFactorize;LL;10| (|basis| $)
  (SPADCALL |basis| NIL 'NIL (QREFELT $ 63))) 

(DEFUN |GBF;groebnerFactorize;LBL;11| (|basis| |info| $)
  (SPADCALL |basis| NIL |info| (QREFELT $ 63))) 

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

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

(MAKEPROP '|GroebnerFactorizationPackage| '|infovec|
    (LIST '#(NIL NIL NIL NIL NIL NIL (|local| |#1|) (|local| |#2|)
             (|local| |#3|) (|local| |#4|)
             (|Record| (|:| |lcmfij| 7) (|:| |totdeg| 26)
                 (|:| |poli| 9) (|:| |polj| 9))
             (|GroebnerInternalPackage| 6 7 8 9) (0 . |sPol|)
             (|List| 9) (5 . |redPol|) (11 . |hMonic|) (16 . |One|)
             (|Boolean|) (20 . =) (26 . |Zero|) (30 . |Zero|)
             (34 . |Zero|) (|Union| $ '"failed") (38 . |exquo|)
             (44 . |degree|) (49 . |zero?|) (|NonNegativeInteger|)
             (54 . |virtualDegree|) (59 . |concat|) (|Void|) (|String|)
             (|OutputForm|) (65 . |messagePrint|) (70 . <)
             (|Mapping| 17 9 9) (76 . |sort|) (82 . |minGbasis|)
             (87 . |coerce|) (92 . |print|) (|List| 13)
             |GBF;factorGroebnerBasis;LBL;7| (97 . |removeDuplicates|)
             (|Factored| 9) (|MultivariateFactorize| 8 7 6 9)
             (102 . |factor|)
             (|Union| '"nil" '"sqfr" '"irred" '"prime")
             (|Record| (|:| |flg| 45) (|:| |fctr| 9)
                 (|:| |xpnt| (|Integer|)))
             (|List| 46) (107 . |factorList|)
             (|Record| (|:| |totdeg| 26) (|:| |pol| 9))
             (112 . |makeCrit|) (119 . |critpOrder|)
             (|Mapping| 17 10 10) (|List| 10) (125 . |sort|)
             (131 . |critMTonD1|) (136 . |critBonD|) (142 . |updatD|)
             (|List| 49) (148 . |updatF|)
             |GBF;factorGroebnerBasis;LL;6| (155 . |One|) (159 . |One|)
             |GBF;groebnerFactorize;2LBL;9|
             |GBF;groebnerFactorize;2LL;8| (163 . =) (|Mapping| 17 9)
             (169 . |remove|) (175 . |member?|)
             |GBF;groebnerFactorize;LL;10|
             |GBF;groebnerFactorize;LBL;11|)
          '#(|groebnerFactorize| 181 |factorGroebnerBasis| 205) 'NIL
          (CONS (|makeByteWordVec2| 1 'NIL)
                (CONS '#()
                      (CONS '#()
                            (|makeByteWordVec2| 70
                                '(1 11 9 10 12 2 11 9 9 13 14 1 11 9 9
                                  15 0 9 0 16 2 9 17 0 0 18 0 6 0 19 0
                                  7 0 20 0 9 0 21 2 9 22 0 0 23 1 9 7 0
                                  24 1 7 17 0 25 1 11 26 9 27 2 13 0 0
                                  9 28 1 31 29 30 32 2 7 17 0 0 33 2 13
                                  0 34 0 35 1 11 13 13 36 1 13 31 0 37
                                  1 31 29 0 38 1 39 0 0 41 1 43 42 9 44
                                  1 42 47 0 48 3 11 10 49 9 26 50 2 11
                                  17 10 10 51 2 53 0 52 0 54 1 11 53 53
                                  55 2 11 53 9 53 56 2 11 53 53 53 57 3
                                  11 58 9 26 58 59 0 6 0 61 0 42 0 62 2
                                  13 17 0 0 65 2 13 0 66 0 67 2 13 17 9
                                  0 68 2 0 39 13 13 64 3 0 39 13 13 17
                                  63 2 0 39 13 17 70 1 0 39 13 69 1 0
                                  39 13 60 2 0 39 13 17 40)))))
          '|lookupComplete|)) 
