
(/VERSIONCHECK 2) 

(DEFUN |GBEUCLID;euclideanGroebner;2L;1| (|Pol| $)
  (|GBEUCLID;eminGbasis| (|GBEUCLID;strongGbasis| |Pol| 0 0 $) $)) 

(DEFUN |GBEUCLID;euclideanGroebner;LSL;2| (|Pol| |xx1| $)
  (SEQ (COND
         ((EQUAL |xx1| "redcrit")
          (|GBEUCLID;eminGbasis| (|GBEUCLID;strongGbasis| |Pol| 1 0 $)
              $))
         ((EQUAL |xx1| "info")
          (|GBEUCLID;eminGbasis| (|GBEUCLID;strongGbasis| |Pol| 2 1 $)
              $))
         ('T
          (SEQ (SPADCALL "   " (QREFELT $ 14))
               (SPADCALL
                   "WARNING: options are - redcrit and/or info - "
                   (QREFELT $ 14))
               (SPADCALL "         you didn't type them correct"
                   (QREFELT $ 14))
               (SPADCALL "         please try again" (QREFELT $ 14))
               (SPADCALL "   " (QREFELT $ 14)) (EXIT NIL)))))) 

(DEFUN |GBEUCLID;euclideanGroebner;L2SL;3| (|Pol| |xx1| |xx2| $)
  (SEQ (COND
         ((EQUAL |xx1| "redcrit")
          (COND
            ((EQUAL |xx2| "info")
             (EXIT (|GBEUCLID;eminGbasis|
                       (|GBEUCLID;strongGbasis| |Pol| 1 1 $) $)))
            ((EQUAL |xx1| "info")
             (COND
               ((EQUAL |xx2| "redcrit")
                (EXIT (|GBEUCLID;eminGbasis|
                          (|GBEUCLID;strongGbasis| |Pol| 1 1 $) $)))))))
         ((EQUAL |xx1| "info")
          (COND
            ((EQUAL |xx2| "redcrit")
             (EXIT (|GBEUCLID;eminGbasis|
                       (|GBEUCLID;strongGbasis| |Pol| 1 1 $) $))))))
       (COND
         ((EQUAL |xx1| "redcrit")
          (COND
            ((EQUAL |xx2| "redcrit")
             (EXIT (|GBEUCLID;eminGbasis|
                       (|GBEUCLID;strongGbasis| |Pol| 1 0 $) $))))))
       (COND
         ((EQUAL |xx1| "info")
          (COND
            ((EQUAL |xx2| "info")
             (EXIT (|GBEUCLID;eminGbasis|
                       (|GBEUCLID;strongGbasis| |Pol| 2 1 $) $))))))
       (SPADCALL "   " (QREFELT $ 14))
       (SPADCALL "WARNING:  options are - redcrit and/or info - "
           (QREFELT $ 14))
       (SPADCALL "          you didn't type them correct"
           (QREFELT $ 14))
       (SPADCALL "          please try again " (QREFELT $ 14))
       (SPADCALL "   " (QREFELT $ 14)) (EXIT NIL))) 

(DEFUN |GBEUCLID;strongGbasis| (|Pol| |xx1| |xx2| $)
  (PROG (|h| |Pol1| |en| |lch| #0=#:G1900 #1=#:G1901 D0 |ep| |eh| |e|
             |leh| #2=#:G1902 |x| #3=#:G1903 |dd1| D H |ala| |xx|)
    (RETURN
      (SEQ (LETT |Pol1|
                 (SPADCALL (CONS #'|GBEUCLID;strongGbasis!0| $) |Pol|
                     (QREFELT $ 27))
                 . #4=(|GBEUCLID;strongGbasis|))
           (LETT |Pol| (LIST (|SPADfirst| |Pol1|)) . #4#)
           (LETT H |Pol| . #4#) (LETT |Pol1| (CDR |Pol1|) . #4#)
           (LETT D NIL . #4#)
           (SEQ G190
                (COND
                  ((NULL (COND ((NULL |Pol1|) 'NIL) ('T 'T)))
                   #5=(GO G191)))
                (SEQ (LETT |h| (|SPADfirst| |Pol1|) . #4#)
                     (LETT |Pol1| (CDR |Pol1|) . #4#)
                     (LETT |en| (SPADCALL |h| (QREFELT $ 18)) . #4#)
                     (LETT |lch| (SPADCALL |h| (QREFELT $ 23)) . #4#)
                     (LETT |dd1|
                           (PROGN
                             (LETT #0# NIL . #4#)
                             (SEQ (LETT |x| NIL . #4#)
                                  (LETT #1# |Pol| . #4#) G190
                                  (COND
                                    ((OR (ATOM #1#)
                                      (PROGN
                                        (LETT |x| (CAR #1#) . #4#)
                                        NIL))
                                     #5#))
                                  (SEQ (EXIT
                                        (LETT #0#
                                         (CONS
                                          (VECTOR
                                           (SPADCALL
                                            (SPADCALL |x|
                                             (QREFELT $ 18))
                                            |en| (QREFELT $ 28))
                                           (SPADCALL
                                            (SPADCALL |x|
                                             (QREFELT $ 23))
                                            |lch| (QREFELT $ 29))
                                           |x| |h|)
                                          #0#) . #4#)))
                                  (LETT #1# (CDR #1#) . #4#)
                                  #6=(GO G190) G191
                                  (EXIT (NREVERSE0 #0#)))) . #4#)
                     (LETT D
                           (|GBEUCLID;updatD|
                               (|GBEUCLID;ecritMTondd1|
                                   (SPADCALL
                                    (CONS #'|GBEUCLID;strongGbasis!1|
                                     $)
                                    |dd1| (QREFELT $ 33))
                                   $)
                               (|GBEUCLID;ecritBonD| |h| D $) $) . #4#)
                     (LETT |Pol|
                           (CONS |h| (|GBEUCLID;eupdatF| |h| |Pol| $)) . #4#)
                     (COND
                       ((SPADCALL |en|
                            (SPADCALL (|SPADfirst| H) (QREFELT $ 18))
                            (QREFELT $ 22))
                        (COND
                          ((SPADCALL (SPADCALL |h| (QREFELT $ 23))
                               (SPADCALL (|SPADfirst| H)
                                   (QREFELT $ 23))
                               (QREFELT $ 34))
                           (EXIT " go to top of while ")))))
                     (LETT H
                           (|GBEUCLID;updatH| |h| H
                               (|GBEUCLID;crithdelH| |h| H $)
                               (LIST |h|) $) . #4#)
                     (EXIT (LETT H
                                 (SPADCALL
                                     (CONS #'|GBEUCLID;strongGbasis!2|
                                      $)
                                     H (QREFELT $ 27)) . #4#)))
                NIL #6# G191 (EXIT NIL))
           (LETT D
                 (SPADCALL (CONS #'|GBEUCLID;strongGbasis!3| $) D
                     (QREFELT $ 33)) . #4#)
           (LETT |xx| |xx2| . #4#)
           (SEQ G190 (COND ((NULL (COND ((NULL D) 'NIL) ('T 'T))) #5#))
                (SEQ (LETT D0 (|SPADfirst| D) . #4#)
                     (LETT |ep| (|GBEUCLID;esPol| D0 $) . #4#)
                     (LETT D (CDR D) . #4#)
                     (LETT |eh|
                           (|GBEUCLID;ecredPol|
                               (|GBEUCLID;eRed| |ep| H H $) H $) . #4#)
                     (COND
                       ((EQL |xx1| 1) (|GBEUCLID;prinshINFO| |eh| $)))
                     (EXIT (COND
                             ((SPADCALL |eh| (|spadConstant| $ 39)
                                  (QREFELT $ 40))
                              (SEQ (COND
                                     ((EQL |xx2| 1)
                                      (SEQ
                                       (LETT |ala|
                                        (|GBEUCLID;prindINFO| D0 |ep|
                                         |eh| (LENGTH H) (LENGTH D)
                                         |xx| $) . #4#)
                                       (EXIT (LETT |xx| 2 . #4#)))))
                                   (EXIT " go to top of while ")))
                             ('T
                              (SEQ (LETT |eh|
                                    (SPADCALL |eh| (QREFELT $ 41)) . #4#)
                                   (LETT |e|
                                    (SPADCALL |eh| (QREFELT $ 18)) . #4#)
                                   (LETT |leh|
                                    (SPADCALL |eh| (QREFELT $ 23)) . #4#)
                                   (LETT |dd1|
                                    (PROGN
                                      (LETT #2# NIL . #4#)
                                      (SEQ (LETT |x| NIL . #4#)
                                       (LETT #3# |Pol| . #4#) G190
                                       (COND
                                         ((OR (ATOM #3#)
                                           (PROGN
                                             (LETT |x| (CAR #3#) . #4#)
                                             NIL))
                                          #5#))
                                       (SEQ
                                        (EXIT
                                         (LETT #2#
                                          (CONS
                                           (VECTOR
                                            (SPADCALL
                                             (SPADCALL |x|
                                              (QREFELT $ 18))
                                             |e| (QREFELT $ 28))
                                            (SPADCALL
                                             (SPADCALL |x|
                                              (QREFELT $ 23))
                                             |leh| (QREFELT $ 29))
                                            |x| |eh|)
                                           #2#) . #4#)))
                                       (LETT #3# (CDR #3#) . #4#) #6#
                                       G191 (EXIT (NREVERSE0 #2#)))) . #4#)
                                   (LETT D
                                    (|GBEUCLID;updatD|
                                     (|GBEUCLID;ecritMTondd1|
                                      (SPADCALL
                                       (CONS
                                        #'|GBEUCLID;strongGbasis!4| $)
                                       |dd1| (QREFELT $ 33))
                                      $)
                                     (|GBEUCLID;ecritBonD| |eh| D $) $) . #4#)
                                   (LETT |Pol|
                                    (CONS |eh|
                                     (|GBEUCLID;eupdatF| |eh| |Pol| $)) . #4#)
                                   (COND
                                     ((|GBEUCLID;ecrithinH| |eh| H $)
                                      (COND
                                        ((SPADCALL |e|
                                          (SPADCALL (|SPADfirst| H)
                                           (QREFELT $ 18))
                                          (QREFELT $ 22))
                                         (COND
                                           ((SPADCALL
                                             (SPADCALL |eh|
                                              (QREFELT $ 23))
                                             (SPADCALL (|SPADfirst| H)
                                              (QREFELT $ 23))
                                             (QREFELT $ 34))
                                            (EXIT
                                             (SEQ
                                              (COND
                                                ((EQL |xx2| 1)
                                                 (SEQ
                                                  (LETT |ala|
                                                   (|GBEUCLID;prindINFO|
                                                    D0 |ep| |eh|
                                                    (LENGTH H)
                                                    (LENGTH D) |xx| $) . #4#)
                                                  (EXIT
                                                   (LETT |xx| 2 . #4#)))))
                                              (EXIT
                                               " go to top of while "))))))))
                                     ('T
                                      (EXIT
                                       (SEQ
                                        (COND
                                          ((EQL |xx2| 1)
                                           (SEQ
                                            (LETT |ala|
                                             (|GBEUCLID;prindINFO| D0
                                              |ep| |eh| (LENGTH H)
                                              (LENGTH D) |xx| $) . #4#)
                                            (EXIT (LETT |xx| 2 . #4#)))))
                                        (EXIT " go to top of while ")))))
                                   (LETT H
                                    (|GBEUCLID;updatH| |eh| H
                                     (|GBEUCLID;crithdelH| |eh| H $)
                                     (LIST |eh|) $) . #4#)
                                   (LETT H
                                    (SPADCALL
                                     (CONS #'|GBEUCLID;strongGbasis!5|
                                      $)
                                     H (QREFELT $ 27)) . #4#)
                                   (EXIT
                                    (COND
                                      ((EQL |xx2| 1)
                                       (SEQ
                                        (LETT |ala|
                                         (|GBEUCLID;prindINFO| D0 |ep|
                                          |eh| (LENGTH H) (LENGTH D)
                                          |xx| $) . #4#)
                                        (LETT |xx| 2 . #4#)
                                        (EXIT " go to top of while "))))))))))
                NIL #6# G191 (EXIT NIL))
           (COND
             ((EQL |xx2| 1)
              (SEQ (|GBEUCLID;prinpolINFO| |Pol| $)
                   (EXIT (SPADCALL "    THE GROEBNER BASIS over EUCLIDEAN DOMAIN"
                                   (QREFELT $ 14))))))
           (COND
             ((EQL |xx1| 1)
              (COND
                ((NULL (EQL |xx2| 1))
                 (SPADCALL
                     "    THE GROEBNER BASIS over EUCLIDEAN DOMAIN"
                     (QREFELT $ 14))))))
           (EXIT H))))) 

(DEFUN |GBEUCLID;strongGbasis!5| (|#1| |#2| $)
  (COND
    ((SPADCALL (SPADCALL |#2| (QREFELT $ 18))
         (SPADCALL |#1| (QREFELT $ 18)) (QREFELT $ 20))
     (|spadConstant| $ 21))
    ((SPADCALL (SPADCALL |#1| (QREFELT $ 18))
         (SPADCALL |#2| (QREFELT $ 18)) (QREFELT $ 22))
     (SPADCALL (SPADCALL |#2| (QREFELT $ 23))
         (SPADCALL |#1| (QREFELT $ 23)) (QREFELT $ 24)))
    ('T (|spadConstant| $ 25)))) 

(DEFUN |GBEUCLID;strongGbasis!4| (|#1| |#2| $)
  (COND
    ((SPADCALL (QVELT |#1| 0) (QVELT |#2| 0) (QREFELT $ 20))
     (|spadConstant| $ 21))
    ((SPADCALL (QVELT |#1| 0) (QVELT |#2| 0) (QREFELT $ 22))
     (SPADCALL (QVELT |#1| 1) (QVELT |#2| 1) (QREFELT $ 24)))
    ('T (|spadConstant| $ 25)))) 

(DEFUN |GBEUCLID;strongGbasis!3| (|#1| |#2| $)
  (COND
    ((SPADCALL (QVELT |#1| 0) (QVELT |#2| 0) (QREFELT $ 20))
     (|spadConstant| $ 21))
    ((SPADCALL (QVELT |#1| 0) (QVELT |#2| 0) (QREFELT $ 22))
     (SPADCALL (QVELT |#1| 1) (QVELT |#2| 1) (QREFELT $ 24)))
    ('T (|spadConstant| $ 25)))) 

(DEFUN |GBEUCLID;strongGbasis!2| (|#1| |#2| $)
  (COND
    ((SPADCALL (SPADCALL |#2| (QREFELT $ 18))
         (SPADCALL |#1| (QREFELT $ 18)) (QREFELT $ 20))
     (|spadConstant| $ 21))
    ((SPADCALL (SPADCALL |#1| (QREFELT $ 18))
         (SPADCALL |#2| (QREFELT $ 18)) (QREFELT $ 22))
     (SPADCALL (SPADCALL |#2| (QREFELT $ 23))
         (SPADCALL |#1| (QREFELT $ 23)) (QREFELT $ 24)))
    ('T (|spadConstant| $ 25)))) 

(DEFUN |GBEUCLID;strongGbasis!1| (|#1| |#2| $)
  (COND
    ((SPADCALL (QVELT |#1| 0) (QVELT |#2| 0) (QREFELT $ 20))
     (|spadConstant| $ 21))
    ((SPADCALL (QVELT |#1| 0) (QVELT |#2| 0) (QREFELT $ 22))
     (SPADCALL (QVELT |#1| 1) (QVELT |#2| 1) (QREFELT $ 24)))
    ('T (|spadConstant| $ 25)))) 

(DEFUN |GBEUCLID;strongGbasis!0| (|#1| |#2| $)
  (COND
    ((SPADCALL (SPADCALL |#2| (QREFELT $ 18))
         (SPADCALL |#1| (QREFELT $ 18)) (QREFELT $ 20))
     (|spadConstant| $ 21))
    ((SPADCALL (SPADCALL |#1| (QREFELT $ 18))
         (SPADCALL |#2| (QREFELT $ 18)) (QREFELT $ 22))
     (SPADCALL (SPADCALL |#2| (QREFELT $ 23))
         (SPADCALL |#1| (QREFELT $ 23)) (QREFELT $ 24)))
    ('T (|spadConstant| $ 25)))) 

(DEFUN |GBEUCLID;ecritMondd1| (|e| |c| D2 $)
  (PROG (|x|)
    (RETURN
      (SEQ (COND
             ((NULL D2) NIL)
             ('T
              (SEQ (LETT |x| (|SPADfirst| D2) |GBEUCLID;ecritMondd1|)
                   (EXIT (COND
                           ((|GBEUCLID;ecritM| |e| |c| (QVELT |x| 0)
                                (SPADCALL
                                    (SPADCALL (QVELT |x| 2)
                                     (QREFELT $ 23))
                                    (SPADCALL (QVELT |x| 3)
                                     (QREFELT $ 23))
                                    (QREFELT $ 29))
                                $)
                            (|GBEUCLID;ecritMondd1| |e| |c| (CDR D2) $))
                           ('T
                            (CONS |x|
                                  (|GBEUCLID;ecritMondd1| |e| |c|
                                      (CDR D2) $)))))))))))) 

(DEFUN |GBEUCLID;ecredPol| (|h| F $)
  (PROG (|h0|)
    (RETURN
      (SEQ (LETT |h0| (|spadConstant| $ 39) . #0=(|GBEUCLID;ecredPol|))
           (EXIT (COND
                   ((NULL F) |h|)
                   ('T
                    (SEQ (SEQ G190
                              (COND
                                ((NULL (COND
                                         ((SPADCALL |h|
                                           (|spadConstant| $ 39)
                                           (QREFELT $ 40))
                                          'NIL)
                                         ('T 'T)))
                                 (GO G191)))
                              (SEQ (LETT |h0|
                                    (SPADCALL |h0|
                                     (SPADCALL
                                      (SPADCALL |h| (QREFELT $ 23))
                                      (SPADCALL |h| (QREFELT $ 18))
                                      (QREFELT $ 42))
                                     (QREFELT $ 43)) . #0#)
                                   (EXIT
                                    (LETT |h|
                                     (|GBEUCLID;eRed|
                                      (SPADCALL |h| (QREFELT $ 44)) F F
                                      $) . #0#)))
                              NIL (GO G190) G191 (EXIT NIL))
                         (EXIT |h0|))))))))) 

(DEFUN |GBEUCLID;ecritMTondd1| (|dd1| $)
  (PROG (|f1| |s1| |cT1| |e1| |r1| |f2|)
    (RETURN
      (SEQ (COND
             ((NULL |dd1|) NIL)
             (#0='T
              (SEQ (LETT |f1| (|SPADfirst| |dd1|)
                         . #1=(|GBEUCLID;ecritMTondd1|))
                   (LETT |s1| (LENGTH |dd1|) . #1#)
                   (LETT |cT1| (|GBEUCLID;ecritT| |f1| $) . #1#)
                   (COND ((EQL |s1| 1) (COND (|cT1| (EXIT NIL)))))
                   (EXIT (COND
                           ((EQL |s1| 1) |dd1|)
                           (#0#
                            (SEQ (LETT |e1| (QVELT |f1| 0) . #1#)
                                 (LETT |r1| (CDR |dd1|) . #1#)
                                 (LETT |f2| (|SPADfirst| |r1|) . #1#)
                                 (COND
                                   ((SPADCALL |e1| (QVELT |f2| 0)
                                     (QREFELT $ 22))
                                    (COND
                                      ((SPADCALL (QVELT |f1| 1)
                                        (QVELT |f2| 1) (QREFELT $ 34))
                                       (EXIT
                                        (COND
                                          (|cT1|
                                           (|GBEUCLID;ecritMTondd1|
                                            (CONS |f1| (CDR |r1|)) $))
                                          ('T
                                           (|GBEUCLID;ecritMTondd1|
                                            |r1| $))))))))
                                 (LETT |dd1|
                                       (|GBEUCLID;ecritMondd1| |e1|
                                        (QVELT |f1| 1) |r1| $) . #1#)
                                 (EXIT (COND
                                         (|cT1|
                                          (|GBEUCLID;ecritMTondd1|
                                           |dd1| $))
                                         (#0#
                                          (CONS |f1|
                                           (|GBEUCLID;ecritMTondd1|
                                            |dd1| $)))))))))))))))) 

(DEFUN |GBEUCLID;ecritBonD| (|h| D $)
  (PROG (|x| |x1| |x2|)
    (RETURN
      (SEQ (COND
             ((NULL D) NIL)
             ('T
              (SEQ (LETT |x| (|SPADfirst| D)
                         . #0=(|GBEUCLID;ecritBonD|))
                   (LETT |x1| (QVELT |x| 2) . #0#)
                   (LETT |x2| (QVELT |x| 3) . #0#)
                   (EXIT (COND
                           ((|GBEUCLID;ecritB|
                                (SPADCALL |h| (QREFELT $ 18))
                                (SPADCALL |h| (QREFELT $ 23))
                                (SPADCALL |x1| (QREFELT $ 18))
                                (SPADCALL |x1| (QREFELT $ 23))
                                (SPADCALL |x2| (QREFELT $ 18))
                                (SPADCALL |x2| (QREFELT $ 23)) $)
                            (|GBEUCLID;ecritBonD| |h| (CDR D) $))
                           ('T
                            (CONS |x|
                                  (|GBEUCLID;ecritBonD| |h| (CDR D) $)))))))))))) 

(DEFUN |GBEUCLID;eupdatF| (|h| F $)
  (PROG (|f1|)
    (RETURN
      (SEQ (COND
             ((NULL F) NIL)
             ('T
              (SEQ (LETT |f1| (|SPADfirst| F) |GBEUCLID;eupdatF|)
                   (EXIT (COND
                           ((|GBEUCLID;ecritM|
                                (SPADCALL |h| (QREFELT $ 18))
                                (SPADCALL |h| (QREFELT $ 23))
                                (SPADCALL |f1| (QREFELT $ 18))
                                (SPADCALL |f1| (QREFELT $ 23)) $)
                            (|GBEUCLID;eupdatF| |h| (CDR F) $))
                           ('T
                            (CONS |f1|
                                  (|GBEUCLID;eupdatF| |h| (CDR F) $)))))))))))) 

(DEFUN |GBEUCLID;updatH| (|h| H |Hh| |Hhh| $)
  (PROG (|h1| |hlcm| |plc| #0=#:G1928 |hpp| |hp|)
    (RETURN
      (SEQ (COND
             ((NULL H) (APPEND |Hh| |Hhh|))
             ('T
              (SEQ (LETT |h1| (|SPADfirst| H) . #1=(|GBEUCLID;updatH|))
                   (LETT |hlcm|
                         (SPADCALL (SPADCALL |h1| (QREFELT $ 18))
                             (SPADCALL |h| (QREFELT $ 18))
                             (QREFELT $ 28)) . #1#)
                   (LETT |plc|
                         (SPADCALL (SPADCALL |h| (QREFELT $ 23))
                             (SPADCALL |h1| (QREFELT $ 23))
                             (QREFELT $ 46)) . #1#)
                   (LETT |hp|
                         (SPADCALL
                             (SPADCALL
                                 (SPADCALL (QVELT |plc| 0)
                                     (PROG2
                                      (LETT #0#
                                       (SPADCALL |hlcm|
                                        (SPADCALL |h| (QREFELT $ 18))
                                        (QREFELT $ 48)) . #1#)
                                      (QCDR #0#)
                                       (|check-union| (QEQCAR #0# 0)
                                        (QREFELT $ 7) #0#))
                                     (QREFELT $ 42))
                                 |h| (QREFELT $ 49))
                             (SPADCALL
                                 (SPADCALL (QVELT |plc| 1)
                                     (PROG2
                                      (LETT #0#
                                       (SPADCALL |hlcm|
                                        (SPADCALL |h1| (QREFELT $ 18))
                                        (QREFELT $ 48)) . #1#)
                                      (QCDR #0#)
                                       (|check-union| (QEQCAR #0# 0)
                                        (QREFELT $ 7) #0#))
                                     (QREFELT $ 42))
                                 |h1| (QREFELT $ 49))
                             (QREFELT $ 43)) . #1#)
                   (COND
                     ((|GBEUCLID;ecrithinH| |hp| |Hh| $)
                      (COND
                        ((|GBEUCLID;ecrithinH| |hp| |Hhh| $)
                         (EXIT (SEQ (LETT |hpp|
                                     (APPEND (CDR H) |Hh|) . #1#)
                                    (LETT |hp|
                                     (|GBEUCLID;ecredPol|
                                      (|GBEUCLID;eRed| |hp| |hpp| |hpp|
                                       $)
                                      |hpp| $) . #1#)
                                    (EXIT
                                     (|GBEUCLID;updatH| |h| (CDR H)
                                      (|GBEUCLID;crithdelH| |hp| |Hh|
                                       $)
                                      (CONS |hp|
                                       (|GBEUCLID;crithdelH| |hp| |Hhh|
                                        $))
                                      $))))))))
                   (EXIT (|GBEUCLID;updatH| |h| (CDR H) |Hh| |Hhh| $))))))))) 

(DEFUN |GBEUCLID;crithdelH| (|h| H $)
  (PROG (|h1| |dh1| |dh| |plc| #0=#:G1937)
    (RETURN
      (SEQ (COND
             ((NULL H) NIL)
             ('T
              (SEQ (LETT |h1| (|SPADfirst| H)
                         . #1=(|GBEUCLID;crithdelH|))
                   (LETT |dh1| (SPADCALL |h1| (QREFELT $ 18)) . #1#)
                   (LETT |dh| (SPADCALL |h| (QREFELT $ 18)) . #1#)
                   (EXIT (COND
                           ((|GBEUCLID;ecritM| |dh|
                                (SPADCALL |h| (QREFELT $ 23)) |dh1|
                                (SPADCALL |h1| (QREFELT $ 23)) $)
                            (|GBEUCLID;crithdelH| |h| (CDR H) $))
                           ((SPADCALL |dh1|
                                (SPADCALL |dh| |dh1| (QREFELT $ 28))
                                (QREFELT $ 22))
                            (SEQ (LETT |plc|
                                       (SPADCALL
                                        (SPADCALL |h1| (QREFELT $ 23))
                                        (SPADCALL |h| (QREFELT $ 23))
                                        (QREFELT $ 46)) . #1#)
                                 (EXIT (CONS
                                        (SPADCALL
                                         (SPADCALL (QVELT |plc| 0) |h1|
                                          (QREFELT $ 50))
                                         (SPADCALL
                                          (SPADCALL (QVELT |plc| 1)
                                           (PROG2
                                            (LETT #0#
                                             (SPADCALL |dh1| |dh|
                                              (QREFELT $ 48)) . #1#)
                                            (QCDR #0#)
                                             (|check-union|
                                              (QEQCAR #0# 0)
                                              (QREFELT $ 7) #0#))
                                           (QREFELT $ 42))
                                          |h| (QREFELT $ 49))
                                         (QREFELT $ 43))
                                        (|GBEUCLID;crithdelH| |h|
                                         (CDR H) $)))))
                           ('T
                            (CONS |h1|
                                  (|GBEUCLID;crithdelH| |h| (CDR H) $)))))))))))) 

(DEFUN |GBEUCLID;eminGbasis| (F $)
  (PROG (|newbas|)
    (RETURN
      (SEQ (COND
             ((NULL F) NIL)
             ('T
              (SEQ (LETT |newbas| (|GBEUCLID;eminGbasis| (CDR F) $)
                         |GBEUCLID;eminGbasis|)
                   (EXIT (CONS (|GBEUCLID;ecredPol| (|SPADfirst| F)
                                   |newbas| $)
                               |newbas|))))))))) 

(DEFUN |GBEUCLID;ecrithinH| (|h| H $)
  (PROG (|h1|)
    (RETURN
      (SEQ (COND
             ((NULL H) 'T)
             ('T
              (SEQ (LETT |h1| (|SPADfirst| H) |GBEUCLID;ecrithinH|)
                   (EXIT (COND
                           ((|GBEUCLID;ecritM|
                                (SPADCALL |h1| (QREFELT $ 18))
                                (SPADCALL |h1| (QREFELT $ 23))
                                (SPADCALL |h| (QREFELT $ 18))
                                (SPADCALL |h| (QREFELT $ 23)) $)
                            'NIL)
                           ('T (|GBEUCLID;ecrithinH| |h| (CDR H) $))))))))))) 

(DEFUN |GBEUCLID;esPol| (|p| $)
  (PROG (|Tij| |fi| |fj| |lij| #0=#:G1948 #1=#:G1951)
    (RETURN
      (SEQ (LETT |Tij| (QVELT |p| 0) . #2=(|GBEUCLID;esPol|))
           (LETT |fi| (QVELT |p| 2) . #2#)
           (LETT |fj| (QVELT |p| 3) . #2#)
           (LETT |lij|
                 (SPADCALL (SPADCALL |fi| (QREFELT $ 23))
                     (SPADCALL |fj| (QREFELT $ 23)) (QREFELT $ 29)) . #2#)
           (EXIT (SPADCALL
                     (SPADCALL (SPADCALL |fi| (QREFELT $ 44))
                         (SPADCALL
                             (PROG2 (LETT #0#
                                     (SPADCALL |lij|
                                      (SPADCALL |fi| (QREFELT $ 23))
                                      (QREFELT $ 51)) . #2#)
                                    (QCDR #0#)
                               (|check-union| (QEQCAR #0# 0)
                                   (QREFELT $ 6) #0#))
                             (PROG2 (LETT #1#
                                     (SPADCALL |Tij|
                                      (SPADCALL |fi| (QREFELT $ 18))
                                      (QREFELT $ 48)) . #2#)
                                    (QCDR #1#)
                               (|check-union| (QEQCAR #1# 0)
                                   (QREFELT $ 7) #1#))
                             (QREFELT $ 42))
                         (QREFELT $ 49))
                     (SPADCALL (SPADCALL |fj| (QREFELT $ 44))
                         (SPADCALL
                             (PROG2 (LETT #0#
                                     (SPADCALL |lij|
                                      (SPADCALL |fj| (QREFELT $ 23))
                                      (QREFELT $ 51)) . #2#)
                                    (QCDR #0#)
                               (|check-union| (QEQCAR #0# 0)
                                   (QREFELT $ 6) #0#))
                             (PROG2 (LETT #1#
                                     (SPADCALL |Tij|
                                      (SPADCALL |fj| (QREFELT $ 18))
                                      (QREFELT $ 48)) . #2#)
                                    (QCDR #1#)
                               (|check-union| (QEQCAR #1# 0)
                                   (QREFELT $ 7) #1#))
                             (QREFELT $ 42))
                         (QREFELT $ 49))
                     (QREFELT $ 52))))))) 

(DEFUN |GBEUCLID;eRed| (|s| H |Hh| $)
  (PROG (|f1| |ds| |lf1| |ls| |e| #0=#:G1962 |sdf1| |q1|)
    (RETURN
      (SEQ (EXIT (COND
                   ((OR (SPADCALL |s| (|spadConstant| $ 39)
                            (QREFELT $ 40))
                        (NULL H))
                    |s|)
                   ('T
                    (SEQ (LETT |f1| (|SPADfirst| H)
                               . #1=(|GBEUCLID;eRed|))
                         (LETT |ds|
                               (SPADCALL |s| (QREFELT $ 18)) . #1#)
                         (LETT |lf1|
                               (SPADCALL |f1| (QREFELT $ 23)) . #1#)
                         (LETT |ls|
                               (SPADCALL |s| (QREFELT $ 23)) . #1#)
                         (SEQ (LETT |e|
                                    (SPADCALL |ds|
                                     (SPADCALL |f1| (QREFELT $ 18))
                                     (QREFELT $ 48)) . #1#)
                              (EXIT (COND
                                      ((OR (QEQCAR |e| 1)
                                        (SPADCALL |ls| |lf1|
                                         (QREFELT $ 24)))
                                       (PROGN
                                         (LETT #0#
                                          (|GBEUCLID;eRed| |s| (CDR H)
                                           |Hh| $) . #1#)
                                         (GO #0#))))))
                         (LETT |sdf1|
                               (SPADCALL |ls| |lf1| (QREFELT $ 54)) . #1#)
                         (LETT |q1| (QCAR |sdf1|) . #1#)
                         (EXIT (COND
                                 ((SPADCALL (QCDR |sdf1|)
                                      (|spadConstant| $ 37)
                                      (QREFELT $ 34))
                                  (|GBEUCLID;eRed|
                                      (SPADCALL
                                       (SPADCALL |s| (QREFELT $ 44))
                                       (SPADCALL
                                        (SPADCALL |q1| (QCDR |e|)
                                         (QREFELT $ 42))
                                        (SPADCALL |f1| (QREFELT $ 44))
                                        (QREFELT $ 49))
                                       (QREFELT $ 52))
                                      |Hh| |Hh| $))
                                 ('T
                                  (|GBEUCLID;eRed|
                                      (SPADCALL |s|
                                       (SPADCALL
                                        (SPADCALL |q1| (QCDR |e|)
                                         (QREFELT $ 42))
                                        |f1| (QREFELT $ 49))
                                       (QREFELT $ 52))
                                      (CDR H) |Hh| $))))))))
           #0# (EXIT #0#))))) 

(DEFUN |GBEUCLID;ecritT| (|p| $)
  (PROG (|pi| |pj| |ci| |cj|)
    (RETURN
      (SEQ (LETT |pi| (QVELT |p| 2) . #0=(|GBEUCLID;ecritT|))
           (LETT |pj| (QVELT |p| 3) . #0#)
           (LETT |ci| (SPADCALL |pi| (QREFELT $ 23)) . #0#)
           (LETT |cj| (SPADCALL |pj| (QREFELT $ 23)) . #0#)
           (EXIT (COND
                   ((SPADCALL (QVELT |p| 0)
                        (SPADCALL (SPADCALL |pi| (QREFELT $ 18))
                            (SPADCALL |pj| (QREFELT $ 18))
                            (QREFELT $ 55))
                        (QREFELT $ 22))
                    (SPADCALL (QVELT |p| 1)
                        (SPADCALL |ci| |cj| (QREFELT $ 56))
                        (QREFELT $ 34)))
                   ('T 'NIL))))))) 

(DEFUN |GBEUCLID;ecritM| (|e1| |c1| |e2| |c2| $)
  (PROG (|en| #0=#:G1974)
    (RETURN
      (SEQ (EXIT (SEQ (SEQ (LETT |en|
                                 (SPADCALL |e2| |e1| (QREFELT $ 48))
                                 . #1=(|GBEUCLID;ecritM|))
                           (EXIT (COND
                                   ((OR (QEQCAR |en| 1)
                                     (QEQCAR
                                      (SPADCALL |c2| |c1|
                                       (QREFELT $ 51))
                                      1))
                                    (PROGN
                                      (LETT #0# 'NIL . #1#)
                                      (GO #0#))))))
                      (EXIT 'T)))
           #0# (EXIT #0#))))) 

(DEFUN |GBEUCLID;ecritB| (|eh| |ch| |ei| |ci| |ek| |ck| $)
  (PROG (|eik| |cik|)
    (RETURN
      (SEQ (LETT |eik| (SPADCALL |ei| |ek| (QREFELT $ 28))
                 . #0=(|GBEUCLID;ecritB|))
           (LETT |cik| (SPADCALL |ci| |ck| (QREFELT $ 29)) . #0#)
           (EXIT (COND
                   ((|GBEUCLID;ecritM| |eh| |ch| |eik| |cik| $)
                    (COND
                      ((OR (|GBEUCLID;ecritM| |eik| |cik|
                               (SPADCALL |ei| |eh| (QREFELT $ 28))
                               (SPADCALL |ci| |ch| (QREFELT $ 29)) $)
                           (|GBEUCLID;ecritM| |eik| |cik|
                               (SPADCALL |ek| |eh| (QREFELT $ 28))
                               (SPADCALL |ck| |ch| (QREFELT $ 29)) $))
                       'NIL)
                      ('T 'T)))
                   ('T 'NIL))))))) 

(DEFUN |GBEUCLID;euclideanNormalForm;DpolLDpol;19| (|p1| |lp| $)
  (|GBEUCLID;eRed| |p1| |lp| |lp| $)) 

(DEFUN |GBEUCLID;sortin| (|p1| |lp| $)
  (PROG (|f1| |elf1| |ep1|)
    (RETURN
      (SEQ (COND
             ((NULL |lp|) (LIST |p1|))
             ('T
              (SEQ (LETT |f1| (|SPADfirst| |lp|)
                         . #0=(|GBEUCLID;sortin|))
                   (LETT |elf1| (SPADCALL |f1| (QREFELT $ 18)) . #0#)
                   (LETT |ep1| (SPADCALL |p1| (QREFELT $ 18)) . #0#)
                   (COND
                     ((SPADCALL |elf1| |ep1| (QREFELT $ 20))
                      (EXIT (CONS |f1|
                                  (|GBEUCLID;sortin| |p1| (CDR |lp|) $))))
                     ((SPADCALL |elf1| |ep1| (QREFELT $ 22))
                      (COND
                        ((SPADCALL (SPADCALL |f1| (QREFELT $ 23))
                             (SPADCALL |p1| (QREFELT $ 23))
                             (QREFELT $ 24))
                         (EXIT (CONS |f1|
                                     (|GBEUCLID;sortin| |p1| (CDR |lp|)
                                      $)))))))
                   (EXIT (CONS |p1| |lp|))))))))) 

(DEFUN |GBEUCLID;updatD| (D1 D2 $)
  (PROG (|dl1| |dl2|)
    (RETURN
      (SEQ (COND
             ((NULL D1) D2)
             ((NULL D2) D1)
             ('T
              (SEQ (LETT |dl1| (|SPADfirst| D1)
                         . #0=(|GBEUCLID;updatD|))
                   (LETT |dl2| (|SPADfirst| D2) . #0#)
                   (EXIT (COND
                           ((SPADCALL (QVELT |dl1| 0) (QVELT |dl2| 0)
                                (QREFELT $ 20))
                            (CONS |dl1|
                                  (|GBEUCLID;updatD| (CDR D1) D2 $)))
                           ('T
                            (CONS |dl2|
                                  (|GBEUCLID;updatD| D1 (CDR D2) $)))))))))))) 

(DEFUN |GBEUCLID;lepol| (|p1| $)
  (PROG (|n|)
    (RETURN
      (SEQ (LETT |n| 0 . #0=(|GBEUCLID;lepol|))
           (SEQ G190
                (COND
                  ((NULL (COND
                           ((SPADCALL |p1| (|spadConstant| $ 39)
                                (QREFELT $ 40))
                            'NIL)
                           ('T 'T)))
                   (GO G191)))
                (SEQ (LETT |n| (+ |n| 1) . #0#)
                     (EXIT (LETT |p1|
                                 (SPADCALL |p1| (QREFELT $ 44)) . #0#)))
                NIL (GO G190) G191 (EXIT NIL))
           (EXIT |n|))))) 

(DEFUN |GBEUCLID;prinb| (|n| $)
  (PROG (|i|)
    (RETURN
      (SEQ (LETT |i| 1 . #0=(|GBEUCLID;prinb|)) G190
           (COND ((QSGREATERP |i| |n|) (GO G191)))
           (SEQ (EXIT (SPADCALL "    " (QREFELT $ 58))))
           (LETT |i| (QSADD1 |i|) . #0#) (GO G190) G191 (EXIT NIL))))) 

(DEFUN |GBEUCLID;prinshINFO| (|h| $)
  (SEQ (|GBEUCLID;prinb| 2 $)
       (SPADCALL " reduced Critpair - Polynom :" (QREFELT $ 58))
       (|GBEUCLID;prinb| 2 $)
       (SPADCALL (SPADCALL |h| (QREFELT $ 59)) (QREFELT $ 14))
       (EXIT (|GBEUCLID;prinb| 2 $)))) 

(DEFUN |GBEUCLID;prindINFO| (|cp| |ps| |ph| |i1| |i2| |n| $)
  (PROG (|cpi| |cpj| |a| |ll|)
    (RETURN
      (SEQ (LETT |cpi| (QVELT |cp| 2) . #0=(|GBEUCLID;prindINFO|))
           (LETT |cpj| (QVELT |cp| 3) . #0#)
           (COND
             ((EQL |n| 1)
              (SEQ (|GBEUCLID;prinb| 1 $)
                   (SPADCALL "you choose option  -info-  "
                       (QREFELT $ 58))
                   (SPADCALL
                       "abbrev. for the following information strings are"
                       (QREFELT $ 58))
                   (SPADCALL
                       "  ci  =>  Leading monomial  for critpair calculation"
                       (QREFELT $ 58))
                   (SPADCALL
                       "  tci =>  Number of terms of polynomial i"
                       (QREFELT $ 58))
                   (SPADCALL
                       "  cj  =>  Leading monomial  for critpair calculation"
                       (QREFELT $ 58))
                   (SPADCALL
                       "  tcj =>  Number of terms of polynomial j"
                       (QREFELT $ 58))
                   (SPADCALL
                       "  c   =>  Leading monomial of critpair polynomial"
                       (QREFELT $ 58))
                   (SPADCALL
                       "  tc  =>  Number of terms of critpair polynomial"
                       (QREFELT $ 58))
                   (SPADCALL
                       "  rc  =>  Leading monomial of redcritpair polynomial"
                       (QREFELT $ 58))
                   (SPADCALL
                       "  trc =>  Number of terms of redcritpair polynomial"
                       (QREFELT $ 58))
                   (SPADCALL
                       "  tF  =>  Number of polynomials in reduction list F"
                       (QREFELT $ 58))
                   (SPADCALL
                       "  tD  =>  Number of critpairs still to do"
                       (QREFELT $ 58))
                   (|GBEUCLID;prinb| 4 $) (EXIT (LETT |n| 2 . #0#)))))
           (|GBEUCLID;prinb| 1 $)
           (LETT |a| (|spadConstant| $ 35) . #0#)
           (EXIT (COND
                   ((SPADCALL |ph| (|spadConstant| $ 39)
                        (QREFELT $ 40))
                    (COND
                      ((SPADCALL |ps| (|spadConstant| $ 39)
                           (QREFELT $ 40))
                       (SEQ (LETT |ll|
                                  (LIST (VECTOR
                                         (SPADCALL |a|
                                          (SPADCALL |cpi|
                                           (QREFELT $ 18))
                                          (QREFELT $ 42))
                                         (|GBEUCLID;lepol| |cpi| $)
                                         (SPADCALL |a|
                                          (SPADCALL |cpj|
                                           (QREFELT $ 18))
                                          (QREFELT $ 42))
                                         (|GBEUCLID;lepol| |cpj| $)
                                         |ps| 0 |ph| 0 |i1| |i2|)) . #0#)
                            (SPADCALL (SPADCALL |ll| (QREFELT $ 62))
                                (QREFELT $ 14))
                            (|GBEUCLID;prinb| 1 $) (EXIT |n|)))
                      (#1='T
                       (SEQ (LETT |ll|
                                  (LIST (VECTOR
                                         (SPADCALL |a|
                                          (SPADCALL |cpi|
                                           (QREFELT $ 18))
                                          (QREFELT $ 42))
                                         (|GBEUCLID;lepol| |cpi| $)
                                         (SPADCALL |a|
                                          (SPADCALL |cpj|
                                           (QREFELT $ 18))
                                          (QREFELT $ 42))
                                         (|GBEUCLID;lepol| |cpj| $)
                                         (SPADCALL |a|
                                          (SPADCALL |ps|
                                           (QREFELT $ 18))
                                          (QREFELT $ 42))
                                         (|GBEUCLID;lepol| |ps| $) |ph|
                                         0 |i1| |i2|)) . #0#)
                            (SPADCALL (SPADCALL |ll| (QREFELT $ 62))
                                (QREFELT $ 14))
                            (|GBEUCLID;prinb| 1 $) (EXIT |n|)))))
                   (#1#
                    (SEQ (LETT |ll|
                               (LIST (VECTOR
                                      (SPADCALL |a|
                                       (SPADCALL |cpi| (QREFELT $ 18))
                                       (QREFELT $ 42))
                                      (|GBEUCLID;lepol| |cpi| $)
                                      (SPADCALL |a|
                                       (SPADCALL |cpj| (QREFELT $ 18))
                                       (QREFELT $ 42))
                                      (|GBEUCLID;lepol| |cpj| $)
                                      (SPADCALL |a|
                                       (SPADCALL |ps| (QREFELT $ 18))
                                       (QREFELT $ 42))
                                      (|GBEUCLID;lepol| |ps| $)
                                      (SPADCALL |a|
                                       (SPADCALL |ph| (QREFELT $ 18))
                                       (QREFELT $ 42))
                                      (|GBEUCLID;lepol| |ph| $) |i1|
                                      |i2|)) . #0#)
                         (SPADCALL (SPADCALL |ll| (QREFELT $ 62))
                             (QREFELT $ 14))
                         (|GBEUCLID;prinb| 1 $) (EXIT |n|))))))))) 

(DEFUN |GBEUCLID;prinpolINFO| (|pl| $)
  (PROG (|n|)
    (RETURN
      (SEQ (LETT |n| (LENGTH |pl|) |GBEUCLID;prinpolINFO|)
           (|GBEUCLID;prinb| 1 $)
           (EXIT (COND
                   ((EQL |n| 1)
                    (SEQ (SPADCALL
                             "  There is 1  Groebner Basis Polynomial "
                             (QREFELT $ 14))
                         (EXIT (|GBEUCLID;prinb| 2 $))))
                   ('T
                    (SEQ (SPADCALL "  There are " (QREFELT $ 14))
                         (|GBEUCLID;prinb| 1 $)
                         (SPADCALL (SPADCALL |n| (QREFELT $ 64))
                             (QREFELT $ 14))
                         (|GBEUCLID;prinb| 1 $)
                         (SPADCALL "  Groebner Basis Polynomials. "
                             (QREFELT $ 14))
                         (EXIT (|GBEUCLID;prinb| 2 $)))))))))) 

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

(DEFUN |EuclideanGroebnerBasisPackage;| (|#1| |#2| |#3| |#4|)
  (PROG (DV$1 DV$2 DV$3 DV$4 |dv$| $ |pv$|)
    (RETURN
      (PROGN
        (LETT DV$1 (|devaluate| |#1|)
              . #0=(|EuclideanGroebnerBasisPackage|))
        (LETT DV$2 (|devaluate| |#2|) . #0#)
        (LETT DV$3 (|devaluate| |#3|) . #0#)
        (LETT DV$4 (|devaluate| |#4|) . #0#)
        (LETT |dv$|
              (LIST '|EuclideanGroebnerBasisPackage| DV$1 DV$2 DV$3
                    DV$4) . #0#)
        (LETT $ (GETREFV 65) . #0#)
        (QSETREFV $ 0 |dv$|)
        (QSETREFV $ 3 (LETT |pv$| (|buildPredVector| 0 0 NIL) . #0#))
        (|haddProp| |$ConstructorCache|
            '|EuclideanGroebnerBasisPackage| (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 '|EuclideanGroebnerBasisPackage| '|infovec|
    (LIST '#(NIL NIL NIL NIL NIL NIL (|local| |#1|) (|local| |#2|)
             (|local| |#3|) (|local| |#4|) (|List| 9)
             |GBEUCLID;euclideanGroebner;2L;1| (|Void|) (|OutputForm|)
             (0 . |print|) (|String|)
             |GBEUCLID;euclideanGroebner;LSL;2|
             |GBEUCLID;euclideanGroebner;L2SL;3| (5 . |degree|)
             (|Boolean|) (10 . <) (16 . |true|) (20 . =)
             (26 . |leadingCoefficient|) (31 . |sizeLess?|)
             (37 . |false|) (|Mapping| 19 9 9) (41 . |sort|)
             (47 . |sup|) (53 . |lcm|)
             (|Record| (|:| |lcmfij| 7) (|:| |lcmcij| 6) (|:| |poli| 9)
                 (|:| |polj| 9))
             (|Mapping| 19 30 30) (|List| 30) (59 . |sort|) (65 . =)
             (71 . |One|) (75 . |One|) (79 . |Zero|) (83 . |Zero|)
             (87 . |Zero|) (91 . =) (97 . |unitCanonical|)
             (102 . |monomial|) (108 . +) (114 . |reductum|)
             (|Record| (|:| |coef1| $) (|:| |coef2| $)
                 (|:| |generator| $))
             (119 . |extendedEuclidean|) (|Union| $ '"failed")
             (125 . |subtractIfCan|) (131 . *) (137 . *)
             (143 . |exquo|) (149 . -)
             (|Record| (|:| |quotient| $) (|:| |remainder| $))
             (155 . |divide|) (161 . +) (167 . *)
             |GBEUCLID;euclideanNormalForm;DpolLDpol;19|
             (173 . |messagePrint|) (178 . |coerce|)
             (|Record| (|:| |ci| 9) (|:| |tci| 63) (|:| |cj| 9)
                 (|:| |tcj| 63) (|:| |c| 9) (|:| |tc| 63) (|:| |rc| 9)
                 (|:| |trc| 63) (|:| |tH| 63) (|:| |tD| 63))
             (|List| 60) (183 . |coerce|) (|Integer|) (188 . |coerce|))
          '#(|euclideanNormalForm| 193 |euclideanGroebner| 199) 'NIL
          (CONS (|makeByteWordVec2| 1 'NIL)
                (CONS '#()
                      (CONS '#()
                            (|makeByteWordVec2| 64
                                '(1 13 12 0 14 1 9 7 0 18 2 7 19 0 0 20
                                  0 19 0 21 2 7 19 0 0 22 1 9 6 0 23 2
                                  6 19 0 0 24 0 19 0 25 2 10 0 26 0 27
                                  2 7 0 0 0 28 2 6 0 0 0 29 2 32 0 31 0
                                  33 2 6 19 0 0 34 0 6 0 35 0 9 0 36 0
                                  6 0 37 0 7 0 38 0 9 0 39 2 9 19 0 0
                                  40 1 9 0 0 41 2 9 0 6 7 42 2 9 0 0 0
                                  43 1 9 0 0 44 2 6 45 0 0 46 2 7 47 0
                                  0 48 2 9 0 0 0 49 2 9 0 6 0 50 2 6 47
                                  0 0 51 2 9 0 0 0 52 2 6 53 0 0 54 2 7
                                  0 0 0 55 2 6 0 0 0 56 1 13 12 15 58 1
                                  9 13 0 59 1 61 13 0 62 1 63 13 0 64 2
                                  0 9 9 10 57 1 0 10 10 11 3 0 10 10 15
                                  15 17 2 0 10 10 15 16)))))
          '|lookupComplete|)) 
