
(/VERSIONCHECK 2) 

(DEFUN |GROEBSOL;testPower| (|uf| |x| |lpol| $)
  (PROG (|df| #0=#:G1838 |testquo| |gg| |trailp| #1=#:G1836 |lc| |linp|
              |g|)
    (RETURN
      (SEQ (LETT |df| (SPADCALL |uf| (QREFELT $ 12))
                 . #2=(|GROEBSOL;testPower|))
           (LETT |trailp|
                 (SPADCALL |uf|
                     (PROG1 (LETT #0# (- |df| 1) . #2#)
                       (|check-subtype| (>= #0# 0)
                           '(|NonNegativeInteger|) #0#))
                     (QREFELT $ 16)) . #2#)
           (LETT |testquo|
                 (SPADCALL |trailp| (SPADCALL |df| (QREFELT $ 18))
                     (QREFELT $ 20)) . #2#)
           (EXIT (COND
                   ((QEQCAR |testquo| 1) (CONS 1 "failed"))
                   ('T
                    (SEQ (LETT |trailp| (QCDR |testquo|) . #2#)
                         (LETT |gg|
                               (SPADCALL
                                   (LETT |lc|
                                    (SPADCALL |uf| (QREFELT $ 21)) . #2#)
                                   |trailp| (QREFELT $ 22)) . #2#)
                         (LETT |trailp|
                               (PROG2 (LETT #1#
                                       (SPADCALL |trailp| |gg|
                                        (QREFELT $ 23)) . #2#)
                                      (QCDR #1#)
                                 (|check-union| (QEQCAR #1# 0)
                                     (|DistributedMultivariatePolynomial|
                                      (QREFELT $ 6) (QREFELT $ 7))
                                     #1#)) . #2#)
                         (LETT |lc|
                               (PROG2 (LETT #1#
                                       (SPADCALL |lc| |gg|
                                        (QREFELT $ 23)) . #2#)
                                      (QCDR #1#)
                                 (|check-union| (QEQCAR #1# 0)
                                     (|DistributedMultivariatePolynomial|
                                      (QREFELT $ 6) (QREFELT $ 7))
                                     #1#)) . #2#)
                         (LETT |linp|
                               (SPADCALL
                                   (SPADCALL |lc| 1 (QREFELT $ 24))
                                   (SPADCALL |trailp| 0 (QREFELT $ 24))
                                   (QREFELT $ 25)) . #2#)
                         (LETT |g|
                               (SPADCALL
                                   (SPADCALL |uf|
                                    (SPADCALL |linp| |df|
                                     (QREFELT $ 26))
                                    (QREFELT $ 27))
                                   |x| (QREFELT $ 30)) . #2#)
                         (COND
                           ((NULL (SPADCALL
                                      (SPADCALL |g| |lpol|
                                       (QREFELT $ 33))
                                      (|spadConstant| $ 34)
                                      (QREFELT $ 36)))
                            (EXIT (CONS 1 "failed"))))
                         (EXIT (CONS 0
                                     (SPADCALL |linp| |x|
                                      (QREFELT $ 30)))))))))))) 

(DEFUN |GROEBSOL;testGenPos| (|lpol| |lvar| $)
  (PROG (|rlpol| |f| #0=#:G1863 |x| |fi| |g| |newlpol| |rlvar|
                 #1=#:G1862)
    (RETURN
      (SEQ (EXIT (SEQ (LETT |rlpol| (REVERSE |lpol|)
                            . #2=(|GROEBSOL;testGenPos|))
                      (LETT |f| (|SPADfirst| |rlpol|) . #2#)
                      (EXIT (COND
                              ((EQL (LENGTH |lvar|) 1)
                               (CONS 0 (LIST |f|)))
                              ('T
                               (SEQ (LETT |rlvar|
                                     (CDR (REVERSE |lvar|)) . #2#)
                                    (LETT |newlpol| (LIST |f|) . #2#)
                                    (SEQ (LETT |f| NIL . #2#)
                                     (LETT #0# (CDR |rlpol|) . #2#)
                                     G190
                                     (COND
                                       ((OR (ATOM #0#)
                                         (PROGN
                                           (LETT |f| (CAR #0#) . #2#)
                                           NIL))
                                        (GO G191)))
                                     (SEQ
                                      (LETT |x|
                                       (|SPADfirst| |rlvar|) . #2#)
                                      (LETT |fi|
                                       (SPADCALL |f| |x|
                                        (QREFELT $ 37)) . #2#)
                                      (EXIT
                                       (COND
                                         ((QEQCAR
                                           (SPADCALL
                                            (SPADCALL |fi|
                                             (QREFELT $ 21))
                                            (QREFELT $ 39))
                                           1)
                                          (SEQ
                                           (SEQ
                                            (LETT |g|
                                             (|GROEBSOL;testPower| |fi|
                                              |x| |newlpol| $) . #2#)
                                            (EXIT
                                             (COND
                                               ((QEQCAR |g| 1)
                                                (PROGN
                                                  (LETT #1#
                                                   (CONS 1 "failed") . #2#)
                                                  (GO #1#))))))
                                           (LETT |newlpol|
                                            (CONS
                                             (SPADCALL (QCDR |g|)
                                              |newlpol| (QREFELT $ 33))
                                             |newlpol|) . #2#)
                                           (EXIT
                                            (LETT |rlvar|
                                             (CDR |rlvar|) . #2#))))
                                         ((NULL
                                           (SPADCALL
                                            (SPADCALL |f| |newlpol|
                                             (QREFELT $ 33))
                                            (|spadConstant| $ 34)
                                            (QREFELT $ 36)))
                                          (PROGN
                                            (LETT #1#
                                             (CONS 1 "failed") . #2#)
                                            (GO #1#))))))
                                     (LETT #0# (CDR #0#) . #2#)
                                     (GO G190) G191 (EXIT NIL))
                                    (EXIT (CONS 0 |newlpol|))))))))
           #1# (EXIT #1#))))) 

(DEFUN |GROEBSOL;genPos| (|lp| |lvar| $)
  (PROG (#0=#:G1875 |f| #1=#:G1876 |lnp| |x| |rlvar| |count| #2=#:G1877
            #3=#:G1878 |ranvals| |rv| #4=#:G1880 |vv| #5=#:G1879
            #6=#:G1869 #7=#:G1867 #8=#:G1868 |val| #9=#:G1881 |p|
            #10=#:G1882 |gb| |gbt| |gb1| |testfail| #11=#:G1847)
    (RETURN
      (SEQ (LETT |rlvar| (REVERSE |lvar|) . #12=(|GROEBSOL;genPos|))
           (LETT |lnp|
                 (PROGN
                   (LETT #0# NIL . #12#)
                   (SEQ (LETT |f| NIL . #12#) (LETT #1# |lp| . #12#)
                        G190
                        (COND
                          ((OR (ATOM #1#)
                               (PROGN (LETT |f| (CAR #1#) . #12#) NIL))
                           #13=(GO G191)))
                        (SEQ (EXIT (LETT #0#
                                    (CONS (SPADCALL |f| (QREFELT $ 42))
                                     #0#) . #12#)))
                        (LETT #1# (CDR #1#) . #12#) #14=(GO G190) G191
                        (EXIT (NREVERSE0 #0#)))) . #12#)
           (LETT |x| (|SPADfirst| |rlvar|) . #12#)
           (LETT |rlvar| (CDR |rlvar|) . #12#)
           (LETT |testfail| 'T . #12#)
           (SEQ (LETT |count| 1 . #12#) G190
                (COND ((NULL |testfail|) #13#))
                (SEQ (LETT |ranvals|
                           (PROGN
                             (LETT #2# NIL . #12#)
                             (SEQ (LETT |vv| NIL . #12#)
                                  (LETT #3# |rlvar| . #12#) G190
                                  (COND
                                    ((OR (ATOM #3#)
                                      (PROGN
                                        (LETT |vv| (CAR #3#) . #12#)
                                        NIL))
                                     #13#))
                                  (SEQ (EXIT
                                        (LETT #2#
                                         (CONS
                                          (+ 1
                                           (RANDOM
                                            (* |count| (LENGTH |lvar|))))
                                          #2#) . #12#)))
                                  (LETT #3# (CDR #3#) . #12#) #14# G191
                                  (EXIT (NREVERSE0 #2#)))) . #12#)
                     (LETT |val|
                           (PROGN
                             (LETT #8# NIL . #12#)
                             (SEQ (LETT |rv| NIL . #12#)
                                  (LETT #4# |ranvals| . #12#)
                                  (LETT |vv| NIL . #12#)
                                  (LETT #5# |rlvar| . #12#) G190
                                  (COND
                                    ((OR (ATOM #5#)
                                      (PROGN
                                        (LETT |vv| (CAR #5#) . #12#)
                                        NIL)
                                      (ATOM #4#)
                                      (PROGN
                                        (LETT |rv| (CAR #4#) . #12#)
                                        NIL))
                                     #13#))
                                  (SEQ (EXIT
                                        (PROGN
                                          (LETT #6#
                                           (SPADCALL |rv|
                                            (SPADCALL |vv|
                                             (QREFELT $ 43))
                                            (QREFELT $ 44)) . #12#)
                                          (COND
                                            (#8#
                                             (LETT #7#
                                              (SPADCALL #7# #6#
                                               (QREFELT $ 45)) . #12#))
                                            ('T
                                             (PROGN
                                               (LETT #7# #6# . #12#)
                                               (LETT #8# 'T . #12#)))))))
                                  (LETT #5#
                                        (PROG1 (CDR #5#)
                                          (LETT #4# (CDR #4#) . #12#)) . #12#)
                                  #14# G191 (EXIT NIL))
                             (COND
                               (#8# #7#)
                               ('T (|spadConstant| $ 46)))) . #12#)
                     (LETT |val|
                           (SPADCALL |val|
                               (SPADCALL |x| (QREFELT $ 43))
                               (QREFELT $ 45)) . #12#)
                     (LETT |gb|
                           (PROGN
                             (LETT #9# NIL . #12#)
                             (SEQ (LETT |p| NIL . #12#)
                                  (LETT #10# |lnp| . #12#) G190
                                  (COND
                                    ((OR (ATOM #10#)
                                      (PROGN
                                        (LETT |p| (CAR #10#) . #12#)
                                        NIL))
                                     #13#))
                                  (SEQ (EXIT
                                        (LETT #9#
                                         (CONS
                                          (SPADCALL
                                           (SPADCALL |p| |x|
                                            (QREFELT $ 47))
                                           |val| (QREFELT $ 49))
                                          #9#) . #12#)))
                                  (LETT #10# (CDR #10#) . #12#) #14#
                                  G191 (EXIT (NREVERSE0 #9#)))) . #12#)
                     (LETT |gb| (SPADCALL |gb| (QREFELT $ 52)) . #12#)
                     (LETT |gbt| (SPADCALL |gb| (QREFELT $ 54)) . #12#)
                     (LETT |gb1|
                           (|GROEBSOL;testGenPos| |gbt| |lvar| $) . #12#)
                     (EXIT (COND
                             ((QEQCAR |gb1| 1) "try again")
                             ('T (LETT |testfail| 'NIL . #12#)))))
                (LETT |count| (QSADD1 |count|) . #12#) #14# G191
                (EXIT NIL))
           (EXIT (VECTOR |gb| |gbt| |ranvals|
                         (SPADCALL
                             (SPADCALL
                                 (PROG2 (LETT #11# |gb1| . #12#)
                                        (QCDR #11#)
                                   (|check-union| (QEQCAR #11# 0)
                                    (|List|
                                     (|DistributedMultivariatePolynomial|
                                      (QREFELT $ 6) (QREFELT $ 7)))
                                    #11#))
                                 (QREFELT $ 55))
                             (QREFELT $ 42)))))))) 

(DEFUN |GROEBSOL;genericPosition;LLR;4| (|lp| |lvar| $)
  (PROG (|nans|)
    (RETURN
      (SEQ (LETT |nans| (|GROEBSOL;genPos| |lp| |lvar| $)
                 |GROEBSOL;genericPosition;LLR;4|)
           (EXIT (CONS (QVELT |nans| 1) (QVELT |nans| 2))))))) 

(DEFUN |GROEBSOL;select| (|lup| $)
  (PROG (|f| #0=#:G1892 #1=#:G1893 |lsel| #2=#:G1894 #3=#:G1889
             #4=#:G1887 #5=#:G1888)
    (RETURN
      (SEQ (COND
             ((SPADCALL |lup| NIL (QREFELT $ 60))
              (SPADCALL NIL (QREFELT $ 61)))
             (#6='T
              (PROGN
                (LETT #5# NIL . #7=(|GROEBSOL;select|))
                (SEQ (LETT |f| NIL . #7#)
                     (LETT #0# (|SPADfirst| |lup|) . #7#) G190
                     (COND
                       ((OR (ATOM #0#)
                            (PROGN (LETT |f| (CAR #0#) . #7#) NIL))
                        #8=(GO G191)))
                     (SEQ (EXIT (PROGN
                                  (LETT #3#
                                        (PROGN
                                          (LETT #1# NIL . #7#)
                                          (SEQ (LETT |lsel| NIL . #7#)
                                           (LETT #2#
                                            (|GROEBSOL;select|
                                             (CDR |lup|) $) . #7#)
                                           G190
                                           (COND
                                             ((OR (ATOM #2#)
                                               (PROGN
                                                 (LETT |lsel|
                                                  (CAR #2#) . #7#)
                                                 NIL))
                                              #8#))
                                           (SEQ
                                            (EXIT
                                             (LETT #1#
                                              (CONS (CONS |f| |lsel|)
                                               #1#) . #7#)))
                                           (LETT #2# (CDR #2#) . #7#)
                                           #9=(GO G190) G191
                                           (EXIT (NREVERSE0 #1#)))) . #7#)
                                  (COND
                                    (#5#
                                     (LETT #4# (APPEND #4# #3#) . #7#))
                                    ('T
                                     (PROGN
                                       (LETT #4# #3# . #7#)
                                       (LETT #5# 'T . #7#)))))))
                     (LETT #0# (CDR #0#) . #7#) #9# G191 (EXIT NIL))
                (COND (#5# #4#) (#6# NIL))))))))) 

(DEFUN |GROEBSOL;findCompon| (|leq| |lvar| $)
  (PROG (|teq| |gp| |lgp| |g| |fg| #0=#:G1912 |ff| #1=#:G1913 |lfact|
               |tfact| #2=#:G1914 |tlfact| |result| |ranvals| |x|
               |rlvar| |rv| #3=#:G1916 |vv| #4=#:G1915 #5=#:G1903
               #6=#:G1901 #7=#:G1902 |val| #8=#:G1917 |lp| #9=#:G1918
               #10=#:G1919 |p| #11=#:G1920 |ans| #12=#:G1921 |ll|
               #13=#:G1922)
    (RETURN
      (SEQ (LETT |teq| (SPADCALL |leq| (QREFELT $ 54))
                 . #14=(|GROEBSOL;findCompon|))
           (EXIT (COND
                   ((EQL (LENGTH |teq|) (LENGTH |lvar|)) (LIST |teq|))
                   ('T
                    (SEQ (LETT |gp|
                               (|GROEBSOL;genPos| |teq| |lvar| $) . #14#)
                         (LETT |lgp| (QVELT |gp| 0) . #14#)
                         (LETT |g| (QVELT |gp| 3) . #14#)
                         (LETT |fg|
                               (SPADCALL |g| (QREFELT $ 64)) . #14#)
                         (LETT |lfact|
                               (PROGN
                                 (LETT #0# NIL . #14#)
                                 (SEQ (LETT |ff| NIL . #14#)
                                      (LETT #1#
                                       (SPADCALL |fg| (QREFELT $ 67)) . #14#)
                                      G190
                                      (COND
                                        ((OR (ATOM #1#)
                                          (PROGN
                                            (LETT |ff|
                                             (CAR #1#) . #14#)
                                            NIL))
                                         #15=(GO G191)))
                                      (SEQ
                                       (EXIT
                                        (LETT #0#
                                         (CONS (QCAR |ff|) #0#) . #14#)))
                                      (LETT #1# (CDR #1#) . #14#)
                                      #16=(GO G190) G191
                                      (EXIT (NREVERSE0 #0#)))) . #14#)
                         (LETT |result| NIL . #14#)
                         (EXIT (COND
                                 ((EQL (LENGTH |lfact|) 1)
                                  (LIST |teq|))
                                 ('T
                                  (SEQ (SEQ (LETT |tfact| NIL . #14#)
                                        (LETT #2# |lfact| . #14#) G190
                                        (COND
                                          ((OR (ATOM #2#)
                                            (PROGN
                                              (LETT |tfact|
                                               (CAR #2#) . #14#)
                                              NIL))
                                           #15#))
                                        (SEQ
                                         (LETT |tlfact|
                                          (CONS |tfact| |lgp|) . #14#)
                                         (EXIT
                                          (LETT |result|
                                           (CONS |tlfact| |result|) . #14#)))
                                        (LETT #2# (CDR #2#) . #14#)
                                        #16# G191 (EXIT NIL))
                                       (LETT |ranvals|
                                        (QVELT |gp| 2) . #14#)
                                       (LETT |rlvar|
                                        (REVERSE |lvar|) . #14#)
                                       (LETT |x|
                                        (|SPADfirst| |rlvar|) . #14#)
                                       (LETT |rlvar|
                                        (CDR |rlvar|) . #14#)
                                       (LETT |val|
                                        (PROGN
                                          (LETT #7# NIL . #14#)
                                          (SEQ (LETT |rv| NIL . #14#)
                                           (LETT #3# |ranvals| . #14#)
                                           (LETT |vv| NIL . #14#)
                                           (LETT #4# |rlvar| . #14#)
                                           G190
                                           (COND
                                             ((OR (ATOM #4#)
                                               (PROGN
                                                 (LETT |vv|
                                                  (CAR #4#) . #14#)
                                                 NIL)
                                               (ATOM #3#)
                                               (PROGN
                                                 (LETT |rv|
                                                  (CAR #3#) . #14#)
                                                 NIL))
                                              #15#))
                                           (SEQ
                                            (EXIT
                                             (PROGN
                                               (LETT #5#
                                                (SPADCALL |rv|
                                                 (SPADCALL |vv|
                                                  (QREFELT $ 43))
                                                 (QREFELT $ 44)) . #14#)
                                               (COND
                                                 (#7#
                                                  (LETT #6#
                                                   (SPADCALL #6# #5#
                                                    (QREFELT $ 45)) . #14#))
                                                 ('T
                                                  (PROGN
                                                    (LETT #6#
                                                     #5# . #14#)
                                                    (LETT #7#
                                                     'T . #14#)))))))
                                           (LETT #4#
                                            (PROG1 (CDR #4#)
                                              (LETT #3#
                                               (CDR #3#) . #14#)) . #14#)
                                           #16# G191 (EXIT NIL))
                                          (COND
                                            (#7# #6#)
                                            ('T (|spadConstant| $ 46)))) . #14#)
                                       (LETT |val|
                                        (SPADCALL
                                         (SPADCALL |x| (QREFELT $ 43))
                                         |val| (QREFELT $ 68)) . #14#)
                                       (LETT |ans|
                                        (PROGN
                                          (LETT #8# NIL . #14#)
                                          (SEQ (LETT |lp| NIL . #14#)
                                           (LETT #9# |result| . #14#)
                                           G190
                                           (COND
                                             ((OR (ATOM #9#)
                                               (PROGN
                                                 (LETT |lp|
                                                  (CAR #9#) . #14#)
                                                 NIL))
                                              #15#))
                                           (SEQ
                                            (EXIT
                                             (LETT #8#
                                              (CONS
                                               (SPADCALL
                                                (SPADCALL
                                                 (PROGN
                                                   (LETT #10#
                                                    NIL . #14#)
                                                   (SEQ
                                                    (LETT |p|
                                                     NIL . #14#)
                                                    (LETT #11#
                                                     |lp| . #14#)
                                                    G190
                                                    (COND
                                                      ((OR (ATOM #11#)
                                                        (PROGN
                                                          (LETT |p|
                                                           (CAR #11#) . #14#)
                                                          NIL))
                                                       #15#))
                                                    (SEQ
                                                     (EXIT
                                                      (LETT #10#
                                                       (CONS
                                                        (SPADCALL
                                                         (SPADCALL |p|
                                                          |x|
                                                          (QREFELT $
                                                           47))
                                                         |val|
                                                         (QREFELT $ 49))
                                                        #10#) . #14#)))
                                                    (LETT #11#
                                                     (CDR #11#) . #14#)
                                                    #16# G191
                                                    (EXIT
                                                     (NREVERSE0 #10#))))
                                                 (QREFELT $ 52))
                                                (QREFELT $ 54))
                                               #8#) . #14#)))
                                           (LETT #9# (CDR #9#) . #14#)
                                           #16# G191
                                           (EXIT (NREVERSE0 #8#)))) . #14#)
                                       (EXIT
                                        (PROGN
                                          (LETT #12# NIL . #14#)
                                          (SEQ (LETT |ll| NIL . #14#)
                                           (LETT #13# |ans| . #14#)
                                           G190
                                           (COND
                                             ((OR (ATOM #13#)
                                               (PROGN
                                                 (LETT |ll|
                                                  (CAR #13#) . #14#)
                                                 NIL))
                                              #15#))
                                           (SEQ
                                            (EXIT
                                             (COND
                                               ((COND
                                                  ((SPADCALL |ll|
                                                    (LIST
                                                     (|spadConstant| $
                                                      69))
                                                    (QREFELT $ 70))
                                                   'NIL)
                                                  ('T 'T))
                                                (LETT #12#
                                                 (CONS |ll| #12#) . #14#)))))
                                           (LETT #13#
                                            (CDR #13#) . #14#)
                                           #16# G191
                                           (EXIT (NREVERSE0 #12#))))))))))))))))) 

(DEFUN |GROEBSOL;zeroDim?| (|lp| |lvar| $)
  (PROG (|n| |f| #0=#:G1933 |g| #1=#:G1925 |x| |lvint1|)
    (RETURN
      (SEQ (COND
             ((NULL |lp|) 'NIL)
             ('T
              (SEQ (LETT |n| (LENGTH |lvar|)
                         . #2=(|GROEBSOL;zeroDim?|))
                   (EXIT (COND
                           ((< (LENGTH |lp|) |n|) 'NIL)
                           ('T
                            (SEQ (LETT |lvint1| |lvar| . #2#)
                                 (SEQ (LETT |f| NIL . #2#)
                                      (LETT #0# |lp| . #2#) G190
                                      (COND
                                        ((OR (ATOM #0#)
                                          (PROGN
                                            (LETT |f| (CAR #0#) . #2#)
                                            NIL)
                                          (NULL
                                           (COND
                                             ((NULL |lvint1|) 'NIL)
                                             ('T 'T))))
                                         (GO G191)))
                                      (SEQ
                                       (LETT |g|
                                        (SPADCALL |f|
                                         (SPADCALL |f| (QREFELT $ 71))
                                         (QREFELT $ 68)) . #2#)
                                       (LETT |x|
                                        (PROG2
                                         (LETT #1#
                                          (SPADCALL |g| (QREFELT $ 72)) . #2#)
                                         (QCDR #1#)
                                          (|check-union| (QEQCAR #1# 0)
                                           (|OrderedVariableList|
                                            (QREFELT $ 6))
                                           #1#)) . #2#)
                                       (EXIT
                                        (COND
                                          ((SPADCALL
                                            (SPADCALL
                                             (SPADCALL |g| |x|
                                              (QREFELT $ 47))
                                             (QREFELT $ 73))
                                            (QREFELT $ 74))
                                           (LETT |lvint1|
                                            (SPADCALL |x| |lvint1|
                                             (QREFELT $ 75)) . #2#)))))
                                      (LETT #0# (CDR #0#) . #2#)
                                      (GO G190) G191 (EXIT NIL))
                                 (EXIT (NULL |lvint1|))))))))))))) 

(DEFUN |GROEBSOL;groebSolve;LLL;8| (|leq| |lvar| $)
  (PROG (#0=#:G1947 |f| #1=#:G1948 |lnp| |leq1| |basis| |lup| |x|
            #2=#:G1949 |g| |fg| |llfact| #3=#:G1939 #4=#:G1950 |llf|
            #5=#:G1951 #6=#:G1952 |ff| #7=#:G1953 |lfact| #8=#:G1954
            |tfact| |result|)
    (RETURN
      (SEQ (LETT |lnp|
                 (PROGN
                   (LETT #0# NIL . #9=(|GROEBSOL;groebSolve;LLL;8|))
                   (SEQ (LETT |f| NIL . #9#) (LETT #1# |leq| . #9#)
                        G190
                        (COND
                          ((OR (ATOM #1#)
                               (PROGN (LETT |f| (CAR #1#) . #9#) NIL))
                           #10=(GO G191)))
                        (SEQ (EXIT (LETT #0#
                                    (CONS (SPADCALL |f| (QREFELT $ 42))
                                     #0#) . #9#)))
                        (LETT #1# (CDR #1#) . #9#) #11=(GO G190) G191
                        (EXIT (NREVERSE0 #0#)))) . #9#)
           (LETT |leq1| (SPADCALL |lnp| (QREFELT $ 52)) . #9#)
           (COND
             ((EQL (LENGTH |leq1|) 1)
              (COND
                ((SPADCALL (|SPADfirst| |leq1|) (|spadConstant| $ 76)
                     (QREFELT $ 77))
                 (EXIT (SPADCALL NIL (QREFELT $ 79)))))))
           (COND
             ((NULL (|GROEBSOL;zeroDim?| |leq1| |lvar| $))
              (EXIT (|error| "system does not have a finite number of solutions"))))
           (LETT |basis| (SPADCALL |leq1| (QREFELT $ 80)) . #9#)
           (LETT |lup| NIL . #9#) (LETT |llfact| NIL . #9#)
           (SEQ (EXIT (SEQ (LETT |x| NIL . #9#) (LETT #2# |lvar| . #9#)
                           G190
                           (COND
                             ((OR (ATOM #2#)
                                  (PROGN
                                    (LETT |x| (CAR #2#) . #9#)
                                    NIL))
                              #10#))
                           (SEQ (LETT |g|
                                      (SPADCALL |leq1| |basis| |x|
                                       (QREFELT $ 81)) . #9#)
                                (LETT |fg|
                                      (SPADCALL |g| (QREFELT $ 64)) . #9#)
                                (LETT |llfact|
                                      (CONS |fg| |llfact|) . #9#)
                                (EXIT (COND
                                        ((EQL
                                          (SPADCALL |g| |x|
                                           (QREFELT $ 82))
                                          (LENGTH |basis|))
                                         (PROGN
                                           (LETT #3#
                                            "stop factoring" . #9#)
                                           (GO #3#))))))
                           (LETT #2# (CDR #2#) . #9#) #11# G191
                           (EXIT NIL)))
                #3# (EXIT #3#))
           (LETT |result| NIL . #9#)
           (LETT |lfact|
                 (|GROEBSOL;select|
                     (PROGN
                       (LETT #4# NIL . #9#)
                       (SEQ (LETT |llf| NIL . #9#)
                            (LETT #5# |llfact| . #9#) G190
                            (COND
                              ((OR (ATOM #5#)
                                   (PROGN
                                     (LETT |llf| (CAR #5#) . #9#)
                                     NIL))
                               #10#))
                            (SEQ (EXIT (LETT #4#
                                        (CONS
                                         (PROGN
                                           (LETT #6# NIL . #9#)
                                           (SEQ (LETT |ff| NIL . #9#)
                                            (LETT #7#
                                             (SPADCALL |llf|
                                              (QREFELT $ 67)) . #9#)
                                            G190
                                            (COND
                                              ((OR (ATOM #7#)
                                                (PROGN
                                                  (LETT |ff|
                                                   (CAR #7#) . #9#)
                                                  NIL))
                                               #10#))
                                            (SEQ
                                             (EXIT
                                              (LETT #6#
                                               (CONS (QCAR |ff|) #6#) . #9#)))
                                            (LETT #7# (CDR #7#) . #9#)
                                            #11# G191
                                            (EXIT (NREVERSE0 #6#))))
                                         #4#) . #9#)))
                            (LETT #5# (CDR #5#) . #9#) #11# G191
                            (EXIT (NREVERSE0 #4#))))
                     $) . #9#)
           (SEQ (LETT |tfact| NIL . #9#) (LETT #8# |lfact| . #9#) G190
                (COND
                  ((OR (ATOM #8#)
                       (PROGN (LETT |tfact| (CAR #8#) . #9#) NIL))
                   #10#))
                (SEQ (LETT |tfact|
                           (SPADCALL
                               (SPADCALL |tfact| |leq1| (QREFELT $ 83))
                               (QREFELT $ 52)) . #9#)
                     (EXIT (COND
                             ((SPADCALL |tfact|
                                  (LIST (|spadConstant| $ 76))
                                  (QREFELT $ 84))
                              "next value")
                             ('T
                              (LETT |result|
                                    (SPADCALL |result|
                                     (|GROEBSOL;findCompon| |tfact|
                                      |lvar| $)
                                     (QREFELT $ 85)) . #9#)))))
                (LETT #8# (CDR #8#) . #9#) #11# G191 (EXIT NIL))
           (EXIT |result|))))) 

(DEFUN |GROEBSOL;testDim;LLU;9| (|leq| |lvar| $)
  (PROG (|leq1|)
    (RETURN
      (SEQ (LETT |leq1| (SPADCALL |leq| (QREFELT $ 52))
                 |GROEBSOL;testDim;LLU;9|)
           (COND
             ((EQL (LENGTH |leq1|) 1)
              (COND
                ((SPADCALL (|SPADfirst| |leq1|) (|spadConstant| $ 76)
                     (QREFELT $ 77))
                 (EXIT (CONS 0 NIL))))))
           (COND
             ((NULL (|GROEBSOL;zeroDim?| |leq1| |lvar| $))
              (EXIT (CONS 1 "failed"))))
           (EXIT (CONS 0 |leq1|)))))) 

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

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

(MAKEPROP '|GroebnerSolve| '|infovec|
    (LIST '#(NIL NIL NIL NIL NIL NIL (|local| |#1|) (|local| |#2|)
             (|local| |#3|) '|nv| (|NonNegativeInteger|)
             (|SparseUnivariatePolynomial| 15) (0 . |degree|)
             (5 . |One|) (9 . |One|)
             (|DistributedMultivariatePolynomial| 6 7)
             (13 . |coefficient|) (|Integer|) (19 . |coerce|)
             (|Union| $ '"failed") (24 . |exquo|)
             (30 . |leadingCoefficient|) (35 . |gcd|) (41 . |exquo|)
             (47 . |monomial|) (53 . +) (59 . **) (65 . -)
             (|SparseUnivariatePolynomial| $) (|OrderedVariableList| 6)
             (71 . |multivariate|) (|List| 15)
             (|GroebnerInternalPackage| 7
                 (|DirectProduct| (NRTEVAL (LENGTH (QREFELT $ 6))) 10)
                 29 15)
             (77 . |redPol|) (83 . |Zero|) (|Boolean|) (87 . =)
             (93 . |univariate|) (|Union| 29 '"failed")
             (99 . |mainVariable|)
             (|HomogeneousDistributedMultivariatePolynomial| 6 7)
             (|PolToPol| 6 7) (104 . |dmpToHdmp|) (109 . |coerce|)
             (114 . *) (120 . +) (126 . |Zero|) (130 . |univariate|)
             (|SparseUnivariatePolynomial| 40) (136 . |elt|)
             (|List| 40)
             (|GroebnerPackage| 7
                 (|HomogeneousDirectProduct|
                     (NRTEVAL (LENGTH (QREFELT $ 6))) 10)
                 29 40)
             (142 . |groebner|) (|LinGroebnerPackage| 6 7)
             (147 . |totolex|) (152 . |last|)
             (|Record| (|:| |dpolys| 31) (|:| |coords| (|List| 17)))
             (|List| 29) |GROEBSOL;genericPosition;LLR;4| (|List| 50)
             (157 . =) (163 . |list|) (|Factored| 40)
             (|GeneralizedMultivariateFactorize| 29
                 (|HomogeneousDirectProduct|
                     (NRTEVAL (LENGTH (QREFELT $ 6))) 10)
                 8 7 40)
             (168 . |factor|)
             (|Record| (|:| |factor| 40) (|:| |exponent| 17))
             (|List| 65) (173 . |factors|) (178 . -) (184 . |One|)
             (188 . =) (194 . |reductum|) (199 . |mainVariable|)
             (204 . |leadingCoefficient|) (209 . |ground?|)
             (214 . |remove|) (220 . |One|) (224 . =) (|List| 31)
             (230 . |list|) (235 . |computeBasis|) (240 . |minPol|)
             (247 . |degree|) (253 . |concat|) (259 . =)
             (265 . |concat|) |GROEBSOL;groebSolve;LLL;8|
             (|Union| 50 '"failed") |GROEBSOL;testDim;LLU;9|)
          '#(|testDim| 271 |groebSolve| 277 |genericPosition| 283) 'NIL
          (CONS (|makeByteWordVec2| 1 'NIL)
                (CONS '#()
                      (CONS '#()
                            (|makeByteWordVec2| 88
                                '(1 11 10 0 12 0 7 0 13 0 8 0 14 2 11
                                  15 0 10 16 1 7 0 17 18 2 15 19 0 7 20
                                  1 11 15 0 21 2 15 0 0 0 22 2 15 19 0
                                  0 23 2 11 0 15 10 24 2 11 0 0 0 25 2
                                  11 0 0 10 26 2 11 0 0 0 27 2 15 0 28
                                  29 30 2 32 15 15 31 33 0 15 0 34 2 15
                                  35 0 0 36 2 15 28 0 29 37 1 15 38 0
                                  39 1 41 40 15 42 1 40 0 29 43 2 40 0
                                  17 0 44 2 40 0 0 0 45 0 40 0 46 2 40
                                  28 0 29 47 2 48 40 0 40 49 1 51 50 50
                                  52 1 53 31 50 54 1 31 15 0 55 2 59 35
                                  0 0 60 1 59 0 50 61 1 63 62 40 64 1
                                  62 66 0 67 2 40 0 0 0 68 0 15 0 69 2
                                  31 35 0 0 70 1 40 0 0 71 1 40 38 0 72
                                  1 48 40 0 73 1 40 35 0 74 2 57 0 29 0
                                  75 0 40 0 76 2 40 35 0 0 77 1 78 0 31
                                  79 1 53 50 50 80 3 53 40 50 50 29 81
                                  2 40 10 0 29 82 2 50 0 0 0 83 2 50 35
                                  0 0 84 2 78 0 0 0 85 2 0 87 50 57 88
                                  2 0 78 31 57 86 2 0 56 31 57 58)))))
          '|lookupComplete|)) 
