
(/VERSIONCHECK 2) 

(PUT '|GDMP;zero?;$B;1| '|SPADreplace| 'NULL) 

(DEFUN |GDMP;zero?;$B;1| (|p| $) (NULL |p|)) 

(DEFUN |GDMP;totalDegree;$Nni;2| (|p| $)
  (PROG (#1=#:G1825 #2=#:G1824 #3=#:G1826 #4=#:G1832 |t|)
    (RETURN
     (SEQ
      (COND ((SPADCALL |p| (QREFELT $ 13)) 0)
            (#5='T
             (PROGN
              (LETT #1# NIL . #6=(|GDMP;totalDegree;$Nni;2|))
              (SEQ (LETT |t| NIL . #6#) (LETT #4# |p| . #6#) G190
                   (COND
                    ((OR (ATOM #4#) (PROGN (LETT |t| (CAR #4#) . #6#) NIL))
                     (GO G191)))
                   (SEQ
                    (EXIT
                     (PROGN
                      (LETT #3#
                            (SPADCALL (ELT $ 18)
                                      (SPADCALL (QCAR |t|) (QREFELT $ 15)) 0
                                      (QREFELT $ 20))
                            . #6#)
                      (COND (#1# (LETT #2# (MAX #2# #3#) . #6#))
                            ('T
                             (PROGN
                              (LETT #2# #3# . #6#)
                              (LETT #1# 'T . #6#)))))))
                   (LETT #4# (CDR #4#) . #6#) (GO G190) G191 (EXIT NIL))
              (COND (#1# #2#) (#5# (|IdentityError| '|max|)))))))))) 

(DEFUN |GDMP;monomial;$OvlNni$;3| (|p| |v| |e| $)
  (PROG (#1=#:G1840 |z| #2=#:G1839 #3=#:G1838 |locv|)
    (RETURN
     (SEQ
      (LETT |locv| (SPADCALL |v| (QREFELT $ 24))
            . #4=(|GDMP;monomial;$OvlNni$;3|))
      (EXIT
       (SPADCALL |p|
                 (SPADCALL (|spadConstant| $ 26)
                           (SPADCALL
                            (PROGN
                             (LETT #3# (GETREFV #5=(QREFELT $ 11)) . #4#)
                             (SEQ (LETT #2# 0 . #4#) (LETT |z| 1 . #4#)
                                  (LETT #1# #5# . #4#) G190
                                  (COND ((QSGREATERP |z| #1#) (GO G191)))
                                  (SEQ
                                   (EXIT
                                    (SETELT #3# #2#
                                            (COND ((EQL |z| |locv|) |e|)
                                                  ('T 0)))))
                                  (LETT |z|
                                        (PROG1 (QSADD1 |z|)
                                          (LETT #2# (QSADD1 #2#) . #4#))
                                        . #4#)
                                  (GO G190) G191 (EXIT NIL))
                             #3#)
                            (QREFELT $ 27))
                           (QREFELT $ 28))
                 (QREFELT $ 29))))))) 

(DEFUN |GDMP;coerce;Ovl$;4| (|v| $)
  (SPADCALL (|spadConstant| $ 25) |v| 1 (QREFELT $ 30))) 

(DEFUN |GDMP;listCoef| (|p| $)
  (PROG (#1=#:G1846 |rec| #2=#:G1845)
    (RETURN
     (SEQ
      (PROGN
       (LETT #2# NIL . #3=(|GDMP;listCoef|))
       (SEQ (LETT |rec| NIL . #3#) (LETT #1# |p| . #3#) G190
            (COND
             ((OR (ATOM #1#) (PROGN (LETT |rec| (CAR #1#) . #3#) NIL))
              (GO G191)))
            (SEQ (EXIT (LETT #2# (CONS (QCDR |rec|) #2#) . #3#)))
            (LETT #1# (CDR #1#) . #3#) (GO G190) G191
            (EXIT (NREVERSE0 #2#)))))))) 

(DEFUN |GDMP;mainVariable;$U;6| (|p| $)
  (PROG (#1=#:G1860 |vv| #2=#:G1848 #3=#:G1861 |v|)
    (RETURN
     (SEQ
      (EXIT
       (COND ((SPADCALL |p| (QREFELT $ 13)) (CONS 1 "failed"))
             ('T
              (SEQ
               (SEQ (LETT |v| NIL . #4=(|GDMP;mainVariable;$U;6|))
                    (LETT #3# (QREFELT $ 6) . #4#) G190
                    (COND
                     ((OR (ATOM #3#) (PROGN (LETT |v| (CAR #3#) . #4#) NIL))
                      (GO G191)))
                    (SEQ
                     (LETT |vv|
                           (PROG2
                               (LETT #2# (SPADCALL |v| (QREFELT $ 34)) . #4#)
                               (QCDR #2#)
                             (|check-union| (QEQCAR #2# 0)
                                            (|OrderedVariableList|
                                             (QREFELT $ 6))
                                            #2#))
                           . #4#)
                     (EXIT
                      (COND
                       ((< 0 (SPADCALL |p| |vv| (QREFELT $ 37)))
                        (PROGN (LETT #1# (CONS 0 |vv|) . #4#) (GO #1#))))))
                    (LETT #3# (CDR #3#) . #4#) (GO G190) G191 (EXIT NIL))
               (EXIT (CONS 1 "failed"))))))
      #1# (EXIT #1#))))) 

(DEFUN |GDMP;ground?;$B;7| (|p| $) (QEQCAR (SPADCALL |p| (QREFELT $ 39)) 1)) 

(DEFUN |GDMP;retract;$R;8| (|p| $)
  (COND ((NULL (SPADCALL |p| (QREFELT $ 40))) (|error| "not a constant"))
        ('T (SPADCALL |p| (QREFELT $ 41))))) 

(DEFUN |GDMP;retractIfCan;$U;9| (|p| $)
  (COND ((SPADCALL |p| (QREFELT $ 40)) (CONS 0 (SPADCALL |p| (QREFELT $ 41))))
        ('T (CONS 1 "failed")))) 

(DEFUN |GDMP;degree;$OvlNni;10| (|p| |v| $)
  (PROG (|res| |j| |t| |locv|)
    (RETURN
     (SEQ
      (COND ((SPADCALL |p| (QREFELT $ 13)) 0)
            ('T
             (SEQ (LETT |res| 0 . #1=(|GDMP;degree;$OvlNni;10|))
                  (LETT |locv| (SPADCALL |v| (QREFELT $ 24)) . #1#)
                  (SEQ G190
                       (COND
                        ((NULL (COND ((NULL |p|) 'NIL) ('T 'T))) (GO G191)))
                       (SEQ (LETT |t| (|SPADfirst| |p|) . #1#)
                            (LETT |j|
                                  (SPADCALL (QCAR |t|) |locv| (QREFELT $ 46))
                                  . #1#)
                            (COND ((< |res| |j|) (LETT |res| |j| . #1#)))
                            (EXIT (LETT |p| (CDR |p|) . #1#)))
                       NIL (GO G190) G191 (EXIT NIL))
                  (EXIT |res|)))))))) 

(DEFUN |GDMP;minimumDegree;$OvlNni;11| (|p| |v| $)
  (SPADCALL (SPADCALL |p| |v| (QREFELT $ 48)) (QREFELT $ 50))) 

(DEFUN |GDMP;differentiate;$Ovl$;12| (|p| |v| $)
  (SPADCALL (SPADCALL (SPADCALL |p| |v| (QREFELT $ 48)) (QREFELT $ 52)) |v|
            (QREFELT $ 53))) 

(DEFUN |GDMP;degree;$LL;13| (|p| |lv| $)
  (PROG (#1=#:G1888 |v| #2=#:G1887)
    (RETURN
     (SEQ
      (PROGN
       (LETT #2# NIL . #3=(|GDMP;degree;$LL;13|))
       (SEQ (LETT |v| NIL . #3#) (LETT #1# |lv| . #3#) G190
            (COND
             ((OR (ATOM #1#) (PROGN (LETT |v| (CAR #1#) . #3#) NIL))
              (GO G191)))
            (SEQ
             (EXIT
              (LETT #2# (CONS (SPADCALL |p| |v| (QREFELT $ 37)) #2#) . #3#)))
            (LETT #1# (CDR #1#) . #3#) (GO G190) G191
            (EXIT (NREVERSE0 #2#)))))))) 

(DEFUN |GDMP;minimumDegree;$LL;14| (|p| |lv| $)
  (PROG (#1=#:G1892 |v| #2=#:G1891)
    (RETURN
     (SEQ
      (PROGN
       (LETT #2# NIL . #3=(|GDMP;minimumDegree;$LL;14|))
       (SEQ (LETT |v| NIL . #3#) (LETT #1# |lv| . #3#) G190
            (COND
             ((OR (ATOM #1#) (PROGN (LETT |v| (CAR #1#) . #3#) NIL))
              (GO G191)))
            (SEQ
             (EXIT
              (LETT #2# (CONS (SPADCALL |p| |v| (QREFELT $ 51)) #2#) . #3#)))
            (LETT #1# (CDR #1#) . #3#) (GO G190) G191
            (EXIT (NREVERSE0 #2#)))))))) 

(DEFUN |GDMP;numberOfMonomials;$Nni;15| (|p| $)
  (PROG (|l|)
    (RETURN
     (SEQ (LETT |l| |p| |GDMP;numberOfMonomials;$Nni;15|)
          (EXIT (COND ((NULL |l|) 1) ('T (LENGTH |l|)))))))) 

(DEFUN |GDMP;monomial?;$B;16| (|p| $)
  (PROG (|l|)
    (RETURN
     (SEQ (LETT |l| |p| |GDMP;monomial?;$B;16|)
          (EXIT (COND ((NULL |l|) 'T) ('T (NULL (CDR |l|))))))))) 

(DEFUN |GDMP;maxNorm| (|p| $)
  (PROG (|m| #1=#:G1901 |r| |l|)
    (RETURN
     (SEQ (LETT |l| NIL . #2=(|GDMP;maxNorm|))
          (LETT |m| (|spadConstant| $ 35) . #2#)
          (SEQ (LETT |r| NIL . #2#) (LETT #1# (|GDMP;listCoef| |p| $) . #2#)
               G190
               (COND
                ((OR (ATOM #1#) (PROGN (LETT |r| (CAR #1#) . #2#) NIL))
                 (GO G191)))
               (SEQ
                (EXIT
                 (COND ((SPADCALL |m| |r| (QREFELT $ 61)) (LETT |m| |r| . #2#))
                       ((SPADCALL |m| (SPADCALL |r| (QREFELT $ 62))
                                  (QREFELT $ 61))
                        (LETT |m| (SPADCALL |r| (QREFELT $ 62)) . #2#)))))
               (LETT #1# (CDR #1#) . #2#) (GO G190) G191 (EXIT NIL))
          (EXIT |m|))))) 

(DEFUN |GDMP;/;$R$;18| (|p| |r| $)
  (SPADCALL (SPADCALL |r| (QREFELT $ 63)) |p| (QREFELT $ 64))) 

(DEFUN |GDMP;variables;$L;19| (|p| $)
  (PROG (#1=#:G1913 #2=#:G1919 |i| #3=#:G1918 #4=#:G1917 |tdeg| |maxdeg|)
    (RETURN
     (SEQ
      (LETT |maxdeg| (SPADCALL (QREFELT $ 11) 0 (QREFELT $ 66))
            . #5=(|GDMP;variables;$L;19|))
      (SEQ G190
           (COND
            ((NULL (COND ((SPADCALL |p| (QREFELT $ 13)) 'NIL) ('T 'T)))
             #6=(GO G191)))
           (SEQ (LETT |tdeg| (SPADCALL |p| (QREFELT $ 67)) . #5#)
                (LETT |p| (SPADCALL |p| (QREFELT $ 68)) . #5#)
                (EXIT
                 (SEQ (LETT |i| 1 . #5#) (LETT #4# (QREFELT $ 11) . #5#) G190
                      (COND ((QSGREATERP |i| #4#) #6#))
                      (SEQ
                       (EXIT
                        (SPADCALL |maxdeg| |i|
                                  (MAX (SPADCALL |maxdeg| |i| (QREFELT $ 69))
                                       (SPADCALL |tdeg| |i| (QREFELT $ 46)))
                                  (QREFELT $ 70))))
                      (LETT |i| (QSADD1 |i|) . #5#) #7=(GO G190) G191
                      (EXIT NIL))))
           NIL #7# G191 (EXIT NIL))
      (EXIT
       (PROGN
        (LETT #3# NIL . #5#)
        (SEQ (LETT |i| 1 . #5#) (LETT #2# (QREFELT $ 11) . #5#) G190
             (COND ((QSGREATERP |i| #2#) #6#))
             (SEQ
              (EXIT
               (COND
                ((COND ((EQL (SPADCALL |maxdeg| |i| (QREFELT $ 69)) 0) 'NIL)
                       ('T 'T))
                 (LETT #3#
                       (CONS
                        (SPADCALL
                         (PROG1 (LETT #1# |i| . #5#)
                           (|check-subtype| (> #1# 0) '(|PositiveInteger|)
                                            #1#))
                         (QREFELT $ 71))
                        #3#)
                       . #5#)))))
             (LETT |i| (QSADD1 |i|) . #5#) #7# G191
             (EXIT (NREVERSE0 #3#))))))))) 

(DEFUN |GDMP;reorder;$L$;20| (|p| |perm| $)
  (PROG (|q| #1=#:G1932 |j| #2=#:G1931 #3=#:G1930 #4=#:G1929 |term| #5=#:G1928)
    (RETURN
     (SEQ
      (COND
       ((NULL (EQL (LENGTH |perm|) (QREFELT $ 11)))
        (|error| "must be a complete permutation of all vars"))
       ('T
        (SEQ
         (LETT |q|
               (PROGN
                (LETT #5# NIL . #6=(|GDMP;reorder;$L$;20|))
                (SEQ (LETT |term| NIL . #6#) (LETT #4# |p| . #6#) G190
                     (COND
                      ((OR (ATOM #4#)
                           (PROGN (LETT |term| (CAR #4#) . #6#) NIL))
                       #7=(GO G191)))
                     (SEQ
                      (EXIT
                       (LETT #5#
                             (CONS
                              (CONS
                               (SPADCALL
                                (PROGN
                                 (LETT #3# (GETREFV (SIZE |perm|)) . #6#)
                                 (SEQ (LETT #2# 0 . #6#) (LETT |j| NIL . #6#)
                                      (LETT #1# |perm| . #6#) G190
                                      (COND
                                       ((OR (ATOM #1#)
                                            (PROGN
                                             (LETT |j| (CAR #1#) . #6#)
                                             NIL))
                                        #7#))
                                      (SEQ
                                       (EXIT
                                        (SETELT #3# #2#
                                                (SPADCALL (QCAR |term|) |j|
                                                          (QREFELT $ 46)))))
                                      (LETT #1#
                                            (PROG1 (CDR #1#)
                                              (LETT #2# (QSADD1 #2#) . #6#))
                                            . #6#)
                                      #8=(GO G190) G191 (EXIT NIL))
                                 #3#)
                                (QREFELT $ 27))
                               (QCDR |term|))
                              #5#)
                             . #6#)))
                     (LETT #4# (CDR #4#) . #6#) #8# G191
                     (EXIT (NREVERSE0 #5#))))
               . #6#)
         (EXIT
          (SPADCALL (CONS #'|GDMP;reorder;$L$;20!0| $) |q|
                    (QREFELT $ 75)))))))))) 

(DEFUN |GDMP;reorder;$L$;20!0| (|z1| |z2| $)
  (SPADCALL (QCAR |z2|) (QCAR |z1|) (QREFELT $ 73))) 

(DEFUN |GDMP;univariate;$OvlSup;21| (|p| |v| $)
  (PROG (|nexp| |deg| #1=#:G1941 |i| #2=#:G1940 #3=#:G1939 |locv| |exp|)
    (RETURN
     (SEQ
      (COND ((SPADCALL |p| (QREFELT $ 13)) (|spadConstant| $ 78))
            ('T
             (SEQ
              (LETT |exp| (SPADCALL |p| (QREFELT $ 67))
                    . #4=(|GDMP;univariate;$OvlSup;21|))
              (LETT |locv| (SPADCALL |v| (QREFELT $ 24)) . #4#)
              (LETT |deg| 0 . #4#)
              (LETT |nexp|
                    (SPADCALL
                     (PROGN
                      (LETT #3# (GETREFV #5=(QREFELT $ 11)) . #4#)
                      (SEQ (LETT #2# 0 . #4#) (LETT |i| 1 . #4#)
                           (LETT #1# #5# . #4#) G190
                           (COND ((QSGREATERP |i| #1#) (GO G191)))
                           (SEQ
                            (EXIT
                             (SETELT #3# #2#
                                     (COND
                                      ((EQL |i| |locv|)
                                       (SEQ
                                        (LETT |deg|
                                              (SPADCALL |exp| |i|
                                                        (QREFELT $ 46))
                                              . #4#)
                                        (EXIT 0)))
                                      ('T
                                       (SPADCALL |exp| |i| (QREFELT $ 46)))))))
                           (LETT |i|
                                 (PROG1 (QSADD1 |i|)
                                   (LETT #2# (QSADD1 #2#) . #4#))
                                 . #4#)
                           (GO G190) G191 (EXIT NIL))
                      #3#)
                     (QREFELT $ 27))
                    . #4#)
              (EXIT
               (SPADCALL
                (SPADCALL
                 (SPADCALL (SPADCALL |p| (QREFELT $ 41)) |nexp| (QREFELT $ 28))
                 |deg| (QREFELT $ 79))
                (SPADCALL (SPADCALL |p| (QREFELT $ 68)) |v| (QREFELT $ 48))
                (QREFELT $ 80)))))))))) 

(DEFUN |GDMP;eval;$Ovl2$;22| (|p| |v| |val| $)
  (SPADCALL (SPADCALL |p| |v| (QREFELT $ 48)) |val| (QREFELT $ 81))) 

(DEFUN |GDMP;eval;$OvlR$;23| (|p| |v| |val| $)
  (SPADCALL |p| |v| (SPADCALL |val| (QREFELT $ 83)) (QREFELT $ 82))) 

(DEFUN |GDMP;eval;$LL$;24| (|p| |lv| |lval| $)
  (COND ((SPADCALL |lv| NIL (QREFELT $ 85)) |p|)
        ('T
         (SPADCALL
          (SPADCALL |p| (|SPADfirst| |lv|)
                    (SPADCALL (|SPADfirst| |lval|) (QREFELT $ 83))
                    (QREFELT $ 82))
          (CDR |lv|) (CDR |lval|) (QREFELT $ 87))))) 

(DEFUN |GDMP;evalSortedVarlist| (|p| |Lvar| |Lpval| $)
  (PROG (|pts| |pval| |mvar| |pv| |v|)
    (RETURN
     (SEQ
      (LETT |v| (SPADCALL |p| (QREFELT $ 39)) . #1=(|GDMP;evalSortedVarlist|))
      (EXIT
       (COND ((QEQCAR |v| 1) |p|)
             (#2='T
              (SEQ (LETT |pv| (QCDR |v|) . #1#)
                   (COND
                    ((OR (SPADCALL |Lvar| NIL (QREFELT $ 85))
                         (SPADCALL |Lpval| NIL (QREFELT $ 89)))
                     (EXIT |p|)))
                   (LETT |mvar| (|SPADfirst| |Lvar|) . #1#)
                   (EXIT
                    (COND
                     ((SPADCALL |pv| |mvar| (QREFELT $ 90))
                      (|GDMP;evalSortedVarlist| |p| (CDR |Lvar|)
                       (SPADCALL |Lpval| '|rest| (QREFELT $ 92)) $))
                     (#2#
                      (SEQ
                       (LETT |pval| (SPADCALL |Lpval| '|first| (QREFELT $ 94))
                             . #1#)
                       (LETT |pts|
                             (SPADCALL
                              (CONS #'|GDMP;evalSortedVarlist!0|
                                    (VECTOR $ |Lpval| |Lvar|))
                              (SPADCALL |p| |pv| (QREFELT $ 48))
                              (QREFELT $ 96))
                             . #1#)
                       (EXIT
                        (COND
                         ((SPADCALL |mvar| |pv| (QREFELT $ 97))
                          (SPADCALL |pts| |pval| (QREFELT $ 81)))
                         (#2#
                          (SPADCALL |pts| |pv| (QREFELT $ 53))))))))))))))))) 

(DEFUN |GDMP;evalSortedVarlist!0| (|x| $$)
  (PROG (|Lvar| |Lpval| $)
    (LETT |Lvar| (QREFELT $$ 2) . #1=(|GDMP;evalSortedVarlist|))
    (LETT |Lpval| (QREFELT $$ 1) . #1#)
    (LETT $ (QREFELT $$ 0) . #1#)
    (RETURN (PROGN (|GDMP;evalSortedVarlist| |x| |Lvar| |Lpval| $))))) 

(DEFUN |GDMP;eval;$LL$;26| (|p| |Lvar| |Lpval| $)
  (PROG (|nlpval| #1=#:G1970 |mvar| #2=#:G1969 |nlvar|)
    (RETURN
     (SEQ
      (LETT |nlvar|
            (SPADCALL (CONS #'|GDMP;eval;$LL$;26!0| $) |Lvar| (QREFELT $ 99))
            . #3=(|GDMP;eval;$LL$;26|))
      (LETT |nlpval|
            (COND ((SPADCALL |Lvar| |nlvar| (QREFELT $ 85)) |Lpval|)
                  ('T
                   (LETT |nlpval|
                         (PROGN
                          (LETT #2# NIL . #3#)
                          (SEQ (LETT |mvar| NIL . #3#) (LETT #1# |nlvar| . #3#)
                               G190
                               (COND
                                ((OR (ATOM #1#)
                                     (PROGN (LETT |mvar| (CAR #1#) . #3#) NIL))
                                 (GO G191)))
                               (SEQ
                                (EXIT
                                 (LETT #2#
                                       (CONS
                                        (SPADCALL |Lpval|
                                                  (SPADCALL |mvar| |Lvar|
                                                            (QREFELT $ 100))
                                                  (QREFELT $ 101))
                                        #2#)
                                       . #3#)))
                               (LETT #1# (CDR #1#) . #3#) (GO G190) G191
                               (EXIT (NREVERSE0 #2#))))
                         . #3#)))
            . #3#)
      (EXIT (|GDMP;evalSortedVarlist| |p| |nlvar| |nlpval| $)))))) 

(DEFUN |GDMP;eval;$LL$;26!0| (|x| |y| $) (SPADCALL |y| |x| (QREFELT $ 90))) 

(DEFUN |GDMP;multivariate;SupOvl$;27| (|p1| |v| $)
  (COND
   ((SPADCALL (|spadConstant| $ 78) |p1| (QREFELT $ 104))
    (|spadConstant| $ 16))
   ((EQL (SPADCALL |p1| (QREFELT $ 105)) 0) (SPADCALL |p1| (QREFELT $ 106)))
   ('T
    (SPADCALL
     (SPADCALL (SPADCALL |p1| (QREFELT $ 106))
               (SPADCALL (SPADCALL |v| (QREFELT $ 31))
                         (SPADCALL |p1| (QREFELT $ 105)) (QREFELT $ 107))
               (QREFELT $ 29))
     (SPADCALL (SPADCALL |p1| (QREFELT $ 108)) |v| (QREFELT $ 53))
     (QREFELT $ 109))))) 

(DEFUN |GDMP;univariate;$Sup;28| (|p| $)
  (PROG (|q| |ans| |v|)
    (RETURN
     (SEQ
      (LETT |v| (SPADCALL |p| (QREFELT $ 39)) . #1=(|GDMP;univariate;$Sup;28|))
      (EXIT
       (COND
        ((QEQCAR |v| 1)
         (SPADCALL (SPADCALL |p| (QREFELT $ 41)) 0 (QREFELT $ 111)))
        ('T
         (SEQ (LETT |q| (SPADCALL |p| (QCDR |v|) (QREFELT $ 48)) . #1#)
              (LETT |ans| (|spadConstant| $ 112) . #1#)
              (SEQ G190
                   (COND
                    ((NULL
                      (COND
                       ((SPADCALL |q| (|spadConstant| $ 78) (QREFELT $ 104))
                        'NIL)
                       ('T 'T)))
                     (GO G191)))
                   (SEQ
                    (LETT |ans|
                          (SPADCALL |ans|
                                    (SPADCALL
                                     (SPADCALL (SPADCALL |q| (QREFELT $ 106))
                                               (QREFELT $ 113))
                                     (SPADCALL |q| (QREFELT $ 105))
                                     (QREFELT $ 111))
                                    (QREFELT $ 114))
                          . #1#)
                    (EXIT (LETT |q| (SPADCALL |q| (QREFELT $ 108)) . #1#)))
                   NIL (GO G190) G191 (EXIT NIL))
              (EXIT |ans|))))))))) 

(DEFUN |GDMP;multivariate;SupOvl$;29| (|p| |v| $)
  (COND
   ((SPADCALL (|spadConstant| $ 112) |p| (QREFELT $ 116))
    (|spadConstant| $ 16))
   ('T
    (SPADCALL
     (SPADCALL (SPADCALL |p| (QREFELT $ 117))
               (SPADCALL (|spadConstant| $ 25) |v|
                         (SPADCALL |p| (QREFELT $ 118)) (QREFELT $ 30))
               (QREFELT $ 64))
     (SPADCALL (SPADCALL |p| (QREFELT $ 119)) |v| (QREFELT $ 120))
     (QREFELT $ 109))))) 

(DEFUN |GDMP;content;$R;30| (|p| $)
  (PROG (#1=#:G1985 #2=#:G1984 #3=#:G1986 #4=#:G1989 |t|)
    (RETURN
     (SEQ
      (COND ((SPADCALL |p| (QREFELT $ 13)) (|spadConstant| $ 35))
            (#5='T
             (PROGN
              (LETT #1# NIL . #6=(|GDMP;content;$R;30|))
              (SEQ (LETT |t| NIL . #6#) (LETT #4# |p| . #6#) G190
                   (COND
                    ((OR (ATOM #4#) (PROGN (LETT |t| (CAR #4#) . #6#) NIL))
                     (GO G191)))
                   (SEQ
                    (EXIT
                     (PROGN
                      (LETT #3# (QCDR |t|) . #6#)
                      (COND
                       (#1#
                        (LETT #2# (SPADCALL #2# #3# (QREFELT $ 121)) . #6#))
                       ('T
                        (PROGN (LETT #2# #3# . #6#) (LETT #1# 'T . #6#)))))))
                   (LETT #4# (CDR #4#) . #6#) (GO G190) G191 (EXIT NIL))
              (COND (#1# #2#) (#5# (|spadConstant| $ 35)))))))))) 

(DEFUN |GDMP;gcd;3$;31| (|p| |q| $)
  (PROG (|r| |qv| |pv|)
    (RETURN
     (SEQ (LETT |pv| (SPADCALL |p| (QREFELT $ 39)) . #1=(|GDMP;gcd;3$;31|))
          (EXIT
           (COND
            ((QEQCAR |pv| 1)
             (SEQ (LETT |r| (SPADCALL |p| (QREFELT $ 41)) . #1#)
                  (EXIT
                   (COND
                    ((SPADCALL |r| (|spadConstant| $ 35) (QREFELT $ 123)) |q|)
                    (#2='T
                     (SPADCALL
                      (SPADCALL |r| (SPADCALL |q| (QREFELT $ 122))
                                (QREFELT $ 121))
                      (QREFELT $ 83)))))))
            (#2#
             (SEQ (LETT |qv| (SPADCALL |q| (QREFELT $ 39)) . #1#)
                  (EXIT
                   (COND
                    ((QEQCAR |qv| 1)
                     (SEQ (LETT |r| (SPADCALL |q| (QREFELT $ 41)) . #1#)
                          (EXIT
                           (COND
                            ((SPADCALL |r| (|spadConstant| $ 35)
                                       (QREFELT $ 123))
                             |p|)
                            (#2#
                             (SPADCALL
                              (SPADCALL |r| (SPADCALL |p| (QREFELT $ 122))
                                        (QREFELT $ 121))
                              (QREFELT $ 83)))))))
                    ((SPADCALL (QCDR |pv|) (QCDR |qv|) (QREFELT $ 90))
                     (SPADCALL |p|
                               (SPADCALL
                                (SPADCALL |q| (QCDR |qv|) (QREFELT $ 48))
                                (QREFELT $ 124))
                               (QREFELT $ 125)))
                    ((SPADCALL (QCDR |qv|) (QCDR |pv|) (QREFELT $ 90))
                     (SPADCALL |q|
                               (SPADCALL
                                (SPADCALL |p| (QCDR |pv|) (QREFELT $ 48))
                                (QREFELT $ 124))
                               (QREFELT $ 125)))
                    (#2#
                     (SPADCALL
                      (SPADCALL (SPADCALL |p| (QCDR |pv|) (QREFELT $ 48))
                                (SPADCALL |q| (QCDR |qv|) (QREFELT $ 48))
                                (QREFELT $ 126))
                      (QCDR |pv|) (QREFELT $ 53))))))))))))) 

(DEFUN |GDMP;gcd;3$;32| (|p| |q| $) (SPADCALL |p| |q| (QREFELT $ 128))) 

(DEFUN |GDMP;gcd;3$;33| (|p| |q| $)
  (PROG (|r| |qv| |pv|)
    (RETURN
     (SEQ (LETT |pv| (SPADCALL |p| (QREFELT $ 39)) . #1=(|GDMP;gcd;3$;33|))
          (EXIT
           (COND
            ((QEQCAR |pv| 1)
             (SEQ (LETT |r| (SPADCALL |p| (QREFELT $ 41)) . #1#)
                  (EXIT
                   (COND
                    ((SPADCALL |r| (|spadConstant| $ 35) (QREFELT $ 123)) |q|)
                    (#2='T
                     (SPADCALL
                      (SPADCALL |r| (SPADCALL |q| (QREFELT $ 122))
                                (QREFELT $ 121))
                      (QREFELT $ 83)))))))
            (#2#
             (SEQ (LETT |qv| (SPADCALL |q| (QREFELT $ 39)) . #1#)
                  (EXIT
                   (COND
                    ((QEQCAR |qv| 1)
                     (SEQ (LETT |r| (SPADCALL |q| (QREFELT $ 41)) . #1#)
                          (EXIT
                           (COND
                            ((SPADCALL |r| (|spadConstant| $ 35)
                                       (QREFELT $ 123))
                             |p|)
                            (#2#
                             (SPADCALL
                              (SPADCALL |r| (SPADCALL |p| (QREFELT $ 122))
                                        (QREFELT $ 121))
                              (QREFELT $ 83)))))))
                    ((SPADCALL (QCDR |pv|) (QCDR |qv|) (QREFELT $ 90))
                     (SPADCALL |p|
                               (SPADCALL
                                (SPADCALL |q| (QCDR |qv|) (QREFELT $ 48))
                                (QREFELT $ 124))
                               (QREFELT $ 125)))
                    ((SPADCALL (QCDR |qv|) (QCDR |pv|) (QREFELT $ 90))
                     (SPADCALL |q|
                               (SPADCALL
                                (SPADCALL |p| (QCDR |pv|) (QREFELT $ 48))
                                (QREFELT $ 124))
                               (QREFELT $ 125)))
                    (#2#
                     (SPADCALL
                      (SPADCALL (SPADCALL |p| (QCDR |pv|) (QREFELT $ 48))
                                (SPADCALL |q| (QCDR |qv|) (QREFELT $ 48))
                                (QREFELT $ 126))
                      (QCDR |pv|) (QREFELT $ 53))))))))))))) 

(DEFUN |GDMP;coerce;$Of;34| (|p| $)
  (PROG (|lt| |l| #1=#:G2032 |i| #2=#:G2031 |t| |vl1| #3=#:G2030 |v|
         #4=#:G2029)
    (RETURN
     (SEQ
      (COND
       ((SPADCALL |p| (QREFELT $ 13))
        (SPADCALL (|spadConstant| $ 35) (QREFELT $ 130)))
       (#5='T
        (SEQ (LETT |lt| NIL . #6=(|GDMP;coerce;$Of;34|))
             (LETT |vl1|
                   (PROGN
                    (LETT #4# NIL . #6#)
                    (SEQ (LETT |v| NIL . #6#) (LETT #3# (QREFELT $ 6) . #6#)
                         G190
                         (COND
                          ((OR (ATOM #3#)
                               (PROGN (LETT |v| (CAR #3#) . #6#) NIL))
                           #7=(GO G191)))
                         (SEQ
                          (EXIT
                           (LETT #4# (CONS (SPADCALL |v| (QREFELT $ 131)) #4#)
                                 . #6#)))
                         (LETT #3# (CDR #3#) . #6#) #8=(GO G190) G191
                         (EXIT (NREVERSE0 #4#))))
                   . #6#)
             (SEQ (LETT |t| NIL . #6#) (LETT #2# (REVERSE |p|) . #6#) G190
                  (COND
                   ((OR (ATOM #2#) (PROGN (LETT |t| (CAR #2#) . #6#) NIL))
                    #7#))
                  (SEQ (LETT |l| NIL . #6#)
                       (SEQ (LETT |i| 1 . #6#) (LETT #1# (LENGTH |vl1|) . #6#)
                            G190 (COND ((QSGREATERP |i| #1#) #7#))
                            (SEQ
                             (EXIT
                              (COND
                               ((EQL (SPADCALL (QCAR |t|) |i| (QREFELT $ 46))
                                     0)
                                "next")
                               ((EQL (SPADCALL (QCAR |t|) |i| (QREFELT $ 46))
                                     1)
                                (LETT |l|
                                      (CONS
                                       (SPADCALL |vl1| |i| (QREFELT $ 133))
                                       |l|)
                                      . #6#))
                               ('T
                                (LETT |l|
                                      (CONS
                                       (SPADCALL
                                        (SPADCALL |vl1| |i| (QREFELT $ 133))
                                        (SPADCALL
                                         (SPADCALL (QCAR |t|) |i|
                                                   (QREFELT $ 46))
                                         (QREFELT $ 134))
                                        (QREFELT $ 135))
                                       |l|)
                                      . #6#)))))
                            (LETT |i| (QSADD1 |i|) . #6#) #8# G191 (EXIT NIL))
                       (LETT |l| (REVERSE |l|) . #6#)
                       (COND
                        ((SPADCALL (QCDR |t|) (|spadConstant| $ 26)
                                   (QREFELT $ 123))
                         (COND
                          ((NULL |l|)
                           (LETT |l|
                                 (CONS (SPADCALL (QCDR |t|) (QREFELT $ 130))
                                       |l|)
                                 . #6#))))
                        ('T
                         (LETT |l|
                               (CONS (SPADCALL (QCDR |t|) (QREFELT $ 130)) |l|)
                               . #6#)))
                       (EXIT
                        (COND
                         ((EQL 1 (LENGTH |l|))
                          (LETT |lt| (CONS (|SPADfirst| |l|) |lt|) . #6#))
                         ('T
                          (LETT |lt|
                                (CONS
                                 (SPADCALL (ELT $ 137) |l| (QREFELT $ 139))
                                 |lt|)
                                . #6#)))))
                  (LETT #2# (CDR #2#) . #6#) #8# G191 (EXIT NIL))
             (EXIT
              (COND ((EQL 1 (LENGTH |lt|)) (|SPADfirst| |lt|))
                    (#5# (SPADCALL (ELT $ 140) |lt| (QREFELT $ 139)))))))))))) 

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

(DEFUN |GeneralDistributedMultivariatePolynomial;| (|#1| |#2| |#3|)
  (PROG (|pv$| #1=#:G2063 $ |dv$| DV$3 DV$2 DV$1)
    (RETURN
     (PROGN
      (LETT DV$1 (|devaluate| |#1|)
            . #2=(|GeneralDistributedMultivariatePolynomial|))
      (LETT DV$2 (|devaluate| |#2|) . #2#)
      (LETT DV$3 (|devaluate| |#3|) . #2#)
      (LETT |dv$|
            (LIST '|GeneralDistributedMultivariatePolynomial| DV$1 DV$2 DV$3)
            . #2#)
      (LETT $ (GETREFV 172) . #2#)
      (QSETREFV $ 0 |dv$|)
      (QSETREFV $ 3
                (LETT |pv$|
                      (|buildPredVector| 0 0
                                         (LIST
                                          (|HasCategory| |#2|
                                                         '(|PolynomialFactorizationExplicit|))
                                          (|HasCategory| |#2|
                                                         '(|CommutativeRing|))
                                          (|HasCategory| |#2|
                                                         '(|IntegralDomain|))
                                          (OR
                                           (|HasCategory| |#2|
                                                          '(|CommutativeRing|))
                                           (|HasCategory| |#2|
                                                          '(|IntegralDomain|)))
                                          (|HasCategory| |#2|
                                                         '(|canonicalUnitNormal|))
                                          (AND
                                           (|HasCategory| |#2|
                                                          '(|PatternMatchable|
                                                            (|Float|)))
                                           (|HasCategory|
                                            (|OrderedVariableList| |#1|)
                                            '(|PatternMatchable| (|Float|))))
                                          (AND
                                           (|HasCategory| |#2|
                                                          '(|PatternMatchable|
                                                            (|Integer|)))
                                           (|HasCategory|
                                            (|OrderedVariableList| |#1|)
                                            '(|PatternMatchable| (|Integer|))))
                                          (AND
                                           (|HasCategory| |#2|
                                                          '(|ConvertibleTo|
                                                            (|Pattern|
                                                             (|Float|))))
                                           (|HasCategory|
                                            (|OrderedVariableList| |#1|)
                                            '(|ConvertibleTo|
                                              (|Pattern| (|Float|)))))
                                          (AND
                                           (|HasCategory| |#2|
                                                          '(|ConvertibleTo|
                                                            (|Pattern|
                                                             (|Integer|))))
                                           (|HasCategory|
                                            (|OrderedVariableList| |#1|)
                                            '(|ConvertibleTo|
                                              (|Pattern| (|Integer|)))))
                                          (AND
                                           (|HasCategory| |#2|
                                                          '(|ConvertibleTo|
                                                            (|InputForm|)))
                                           (|HasCategory|
                                            (|OrderedVariableList| |#1|)
                                            '(|ConvertibleTo| (|InputForm|))))
                                          (|HasCategory| |#2| '(|Comparable|))
                                          (|HasCategory| |#2|
                                                         '(|LinearlyExplicitRingOver|
                                                           (|Integer|)))
                                          (|HasCategory| |#2|
                                                         '(|Algebra|
                                                           (|Fraction|
                                                            (|Integer|))))
                                          (|HasCategory| |#2|
                                                         '(|CharacteristicNonZero|))
                                          (|HasCategory| |#2|
                                                         '(|CharacteristicZero|))
                                          (|HasCategory| |#2|
                                                         '(|RetractableTo|
                                                           (|Integer|)))
                                          (|HasCategory| |#2|
                                                         '(|RetractableTo|
                                                           (|Fraction|
                                                            (|Integer|))))
                                          (|HasCategory| |#2| '(|Field|))
                                          (OR
                                           (|HasCategory| |#2|
                                                          '(|Algebra|
                                                            (|Fraction|
                                                             (|Integer|))))
                                           (|HasCategory| |#2|
                                                          '(|RetractableTo|
                                                            (|Fraction|
                                                             (|Integer|)))))
                                          (LETT #1#
                                                (|HasCategory| |#2|
                                                               '(|GcdDomain|))
                                                . #2#)
                                          (OR
                                           (|HasCategory| |#2|
                                                          '(|CommutativeRing|))
                                           #1#
                                           (|HasCategory| |#2|
                                                          '(|IntegralDomain|))
                                           (|HasCategory| |#2|
                                                          '(|PolynomialFactorizationExplicit|)))
                                          (OR #1#
                                              (|HasCategory| |#2|
                                                             '(|IntegralDomain|))
                                              (|HasCategory| |#2|
                                                             '(|PolynomialFactorizationExplicit|)))
                                          (OR #1#
                                              (|HasCategory| |#2|
                                                             '(|PolynomialFactorizationExplicit|)))))
                      . #2#))
      (|haddProp| |$ConstructorCache|
                  '|GeneralDistributedMultivariatePolynomial|
                  (LIST DV$1 DV$2 DV$3) (CONS 1 $))
      (|stuffDomainSlots| $)
      (QSETREFV $ 6 |#1|)
      (QSETREFV $ 7 |#2|)
      (QSETREFV $ 8 |#3|)
      (AND (|HasCategory| |#2| '(|PolynomialFactorizationExplicit|))
           (|HasCategory| $ '(|CharacteristicNonZero|))
           (|augmentPredVector| $ 8388608))
      (AND
       (OR (|HasCategory| |#2| '(|CharacteristicNonZero|))
           (AND (|HasCategory| |#2| '(|PolynomialFactorizationExplicit|))
                (|HasCategory| $ '(|CharacteristicNonZero|))))
       (|augmentPredVector| $ 16777216))
      (SETF |pv$| (QREFELT $ 3))
      (QSETREFV $ 9 (|Record| (|:| |k| |#3|) (|:| |c| |#2|)))
      (QSETREFV $ 10 (|List| (QREFELT $ 9)))
      (QSETREFV $ 11 (LENGTH |#1|))
      (COND
       ((|testBitVector| |pv$| 18)
        (QSETREFV $ 65 (CONS (|dispatchFunction| |GDMP;/;$R$;18|) $))))
      (COND
       ((|testBitVector| |pv$| 20)
        (PROGN
         (QSETREFV $ 122 (CONS (|dispatchFunction| |GDMP;content;$R;30|) $))
         (COND
          ((|HasCategory| |#2| '(|EuclideanDomain|))
           (COND
            ((|HasCategory| |#2| '(|FloatingPointSystem|))
             (QSETREFV $ 125 (CONS (|dispatchFunction| |GDMP;gcd;3$;31|) $)))
            ('T
             (QSETREFV $ 125 (CONS (|dispatchFunction| |GDMP;gcd;3$;32|) $)))))
          ('T
           (QSETREFV $ 125 (CONS (|dispatchFunction| |GDMP;gcd;3$;33|) $)))))))
      $)))) 

(MAKEPROP '|GeneralDistributedMultivariatePolynomial| '|infovec|
          (LIST
           '#(NIL NIL NIL NIL NIL (|PolynomialRing| 7 8) (|local| |#1|)
              (|local| |#2|) (|local| |#3|) '|Term| '|Rep| '|n| (|Boolean|)
              |GDMP;zero?;$B;1| (|Vector| 17) (0 . |coerce|) (5 . |Zero|)
              (|NonNegativeInteger|) (9 . +) (|Mapping| 17 17 17)
              (15 . |reduce|) |GDMP;totalDegree;$Nni;2| (|PositiveInteger|)
              (|OrderedVariableList| 6) (22 . |lookup|) (27 . |One|)
              (31 . |One|) (35 . |directProduct|) (40 . |monomial|) (46 . *)
              |GDMP;monomial;$OvlNni$;3| |GDMP;coerce;Ovl$;4|
              (|Union| $ '"failed") (|Symbol|) (52 . |variable|) (57 . |Zero|)
              (61 . |Zero|) |GDMP;degree;$OvlNni;10| (|Union| 23 '#1="failed")
              |GDMP;mainVariable;$U;6| |GDMP;ground?;$B;7|
              (65 . |leadingCoefficient|) |GDMP;retract;$R;8|
              (|Union| 7 '"failed") |GDMP;retractIfCan;$U;9| (|Integer|)
              (70 . |elt|) (|SparseUnivariatePolynomial| $)
              |GDMP;univariate;$OvlSup;21| (|SparseUnivariatePolynomial| $$)
              (76 . |minimumDegree|) |GDMP;minimumDegree;$OvlNni;11|
              (81 . |differentiate|) |GDMP;multivariate;SupOvl$;27|
              |GDMP;differentiate;$Ovl$;12| (|List| 17) (|List| 23)
              |GDMP;degree;$LL;13| |GDMP;minimumDegree;$LL;14|
              |GDMP;numberOfMonomials;$Nni;15| |GDMP;monomial?;$B;16| (86 . <)
              (92 . -) (97 . |inv|) (102 . *) (108 . /) (114 . |new|)
              (120 . |degree|) (125 . |reductum|) (130 . |elt|)
              (136 . |setelt|) (143 . |index|) |GDMP;variables;$L;19| (148 . <)
              (|Mapping| 12 9 9) (154 . |sort|) (|List| 45)
              |GDMP;reorder;$L$;20| (160 . |Zero|) (164 . |monomial|) (170 . +)
              (176 . |elt|) |GDMP;eval;$Ovl2$;22| (182 . |coerce|)
              |GDMP;eval;$OvlR$;23| (187 . =) (|List| 7) |GDMP;eval;$LL$;24|
              (|List| $$) (193 . =) (199 . <) '"rest" (205 . |elt|) '"first"
              (211 . |elt|) (|Mapping| $$ $$) (217 . |map|) (223 . =)
              (|Mapping| 12 23 23) (229 . |sort|) (235 . |position|)
              (241 . |elt|) (|List| $) |GDMP;eval;$LL$;26| (247 . =)
              (253 . |degree|) (258 . |leadingCoefficient|) (263 . ^)
              (269 . |reductum|) (274 . +) (|SparseUnivariatePolynomial| 7)
              (280 . |monomial|) (286 . |Zero|) (290 . |ground|) (295 . +)
              |GDMP;univariate;$Sup;28| (301 . =) (307 . |leadingCoefficient|)
              (312 . |degree|) (317 . |reductum|)
              |GDMP;multivariate;SupOvl$;29| (322 . |gcd|) (328 . |content|)
              (333 . =) (339 . |content|) (344 . |gcd|) (350 . |gcd|)
              (|PolynomialGcdPackage| 8 23 7 $$) (356 . |gcd|) (|OutputForm|)
              (362 . |coerce|) (367 . |coerce|) (|List| 129) (372 . |elt|)
              (378 . |coerce|) (383 . ^) (389 . |One|) (393 . *)
              (|Mapping| 129 129 129) (399 . |reduce|) (405 . +)
              |GDMP;coerce;$Of;34| (|Union| 154 '#2="failed") (|Matrix| $)
              (|InputForm|) (|Pattern| (|Float|)) (|Pattern| 45)
              (|PatternMatchResult| (|Float|) $) (|PatternMatchResult| 45 $)
              (|Fraction| 45) (|Factored| $)
              (|Record| (|:| |unit| $) (|:| |canonical| $) (|:| |associate| $))
              (|Matrix| 45)
              (|Record| (|:| |mat| 152) (|:| |vec| (|Vector| 45))) (|Vector| $)
              (|Factored| 47) (|Union| 157 '#2#) (|List| 47)
              (|Union| 149 '#3="failed") (|Union| 45 '#3#) (|Union| 102 '#1#)
              (|Record| (|:| |var| 23) (|:| |exponent| 17)) (|Union| 161 '#1#)
              (|Record| (|:| |quotient| $) (|:| |remainder| $))
              (|Record| (|:| |mat| 165) (|:| |vec| (|Vector| 7))) (|Matrix| 7)
              (|List| 167) (|Equation| $) (|Mapping| 7 7) (|Mapping| 8 8)
              (|SingleInteger|) (|String|))
           '#(~= 411 |zero?| 417 |variables| 422 |univariate| 427 |unitNormal|
              438 |unitCanonical| 443 |unit?| 448 |totalDegree| 453
              |subtractIfCan| 464 |squareFreePolynomial| 470 |squareFreePart|
              475 |squareFree| 480 |solveLinearPolynomialEquation| 485
              |smaller?| 491 |sample| 497 |retractIfCan| 501 |retract| 521
              |resultant| 541 |reorder| 548 |reductum| 554 |reducedSystem| 559
              |recip| 581 |primitivePart| 586 |primitiveMonomials| 597 |prime?|
              602 |pomopo!| 607 |patternMatch| 615 |one?| 629
              |numberOfMonomials| 634 |multivariate| 639 |monomials| 651
              |monomial?| 656 |monomial| 661 |monicDivide| 681 |minimumDegree|
              688 |mapExponents| 705 |map| 711 |mainVariable| 717
              |leadingMonomial| 722 |leadingCoefficient| 727 |lcm| 732 |latex|
              743 |isTimes| 748 |isPlus| 753 |isExpt| 758 |hash| 763 |ground?|
              768 |ground| 773 |gcdPolynomial| 778 |gcd| 784
              |factorSquareFreePolynomial| 795 |factorPolynomial| 800 |factor|
              805 |exquo| 810 |eval| 822 |discriminant| 876 |differentiate| 882
              |degree| 908 |convert| 925 |content| 940 |conditionP| 951
              |coerce| 956 |coefficients| 986 |coefficient| 991 |charthRoot|
              1011 |characteristic| 1016 |binomThmExpt| 1020 |associates?| 1027
              ^ 1033 |Zero| 1045 |One| 1049 D 1053 = 1079 / 1085 - 1091 + 1102
              * 1108)
           'NIL
           (CONS
            (|makeByteWordVec2| 23
                                '(0 1 0 1 0 23 22 0 3 13 2 0 0 21 3 3 12 13 14
                                  15 2 0 0 4 13 0 0 0 0 2 13 13 0 0 0 0 0 0 0 0
                                  6 7 11 0 0 0 0 0 0 0 0 0 0 0 2 3 5 8 9 10 16
                                  17))
            (CONS
             '#(|PolynomialCategory&| |PolynomialFactorizationExplicit&|
                |FiniteAbelianMonoidRing&| |UniqueFactorizationDomain&|
                |AbelianMonoidRing&| |GcdDomain&| |IntegralDomain&|
                |FullyLinearlyExplicitRingOver&| |Algebra&| |Algebra&|
                |Algebra&| |PartialDifferentialRing&| NIL NIL |Module&| NIL NIL
                |Module&| NIL NIL |Module&| NIL |Ring&| NIL NIL NIL NIL NIL NIL
                NIL NIL NIL |AbelianGroup&| NIL NIL |AbelianMonoid&| |Monoid&|
                NIL |SemiGroup&| |AbelianSemiGroup&| NIL NIL NIL |Evalable&|
                |FullyRetractableTo&| |SetCategory&| |RetractableTo&|
                |InnerEvalable&| |InnerEvalable&| |InnerEvalable&|
                |RetractableTo&| NIL |BasicType&| NIL NIL NIL NIL NIL NIL NIL
                |RetractableTo&| |RetractableTo&|)
             (CONS
              '#((|PolynomialCategory| 7 8 (|OrderedVariableList| 6))
                 (|PolynomialFactorizationExplicit|)
                 (|FiniteAbelianMonoidRing| 7 8) (|UniqueFactorizationDomain|)
                 (|AbelianMonoidRing| 7 8) (|GcdDomain|) (|IntegralDomain|)
                 (|FullyLinearlyExplicitRingOver| 7) (|Algebra| $$)
                 (|Algebra| 149) (|Algebra| 7)
                 (|PartialDifferentialRing| (|OrderedVariableList| 6))
                 (|LinearlyExplicitRingOver| 7) (|CommutativeRing|)
                 (|Module| $$) (|EntireRing|) (|LinearlyExplicitRingOver| 45)
                 (|Module| 149) (|CharacteristicNonZero|)
                 (|CharacteristicZero|) (|Module| 7) (|BiModule| 7 7) (|Ring|)
                 (|BiModule| $$ $$) (|BiModule| 149 149) (|LeftModule| 7)
                 (|Rng|) (|RightModule| 7) (|LeftModule| $$) (|RightModule| $$)
                 (|LeftModule| 149) (|RightModule| 149) (|AbelianGroup|)
                 (|CancellationAbelianMonoid|) (|SemiRing|) (|AbelianMonoid|)
                 (|Monoid|) (|SemiRng|) (|SemiGroup|) (|AbelianSemiGroup|)
                 (|PatternMatchable| (|Float|)) (|PatternMatchable| 45)
                 (|Comparable|) (|Evalable| $$) (|FullyRetractableTo| 7)
                 (|SetCategory|) (|RetractableTo| (|OrderedVariableList| 6))
                 (|InnerEvalable| (|OrderedVariableList| 6) $$)
                 (|InnerEvalable| (|OrderedVariableList| 6) 7)
                 (|InnerEvalable| $$ $$) (|RetractableTo| 7) (|unitsKnown|)
                 (|BasicType|) (|CoercibleTo| 129) (|CommutativeStar|)
                 (|noZeroDivisors|) (|canonicalUnitNormal|)
                 (|ConvertibleTo| 145) (|ConvertibleTo| 146)
                 (|ConvertibleTo| 144) (|RetractableTo| 45)
                 (|RetractableTo| 149))
              (|makeByteWordVec2| 171
                                  '(1 8 14 0 15 0 0 0 16 2 17 0 0 0 18 3 14 17
                                    19 0 17 20 1 23 22 0 24 0 0 0 25 0 7 0 26 1
                                    8 0 14 27 2 0 0 7 8 28 2 0 0 0 0 29 1 23 32
                                    33 34 0 7 0 35 0 8 0 36 1 0 7 0 41 2 8 17 0
                                    45 46 1 49 17 0 50 1 49 0 0 52 2 7 12 0 0
                                    61 1 7 0 0 62 1 7 0 0 63 2 0 0 7 0 64 2 0 0
                                    0 7 65 2 14 0 17 17 66 1 0 8 0 67 1 0 0 0
                                    68 2 14 17 0 45 69 3 14 17 0 45 17 70 1 23
                                    0 22 71 2 8 12 0 0 73 2 10 0 74 0 75 0 49 0
                                    78 2 49 0 2 17 79 2 49 0 0 0 80 2 49 2 0 2
                                    81 1 0 0 7 83 2 56 12 0 0 85 2 88 12 0 0 89
                                    2 23 12 0 0 90 2 88 0 0 91 92 2 88 2 0 93
                                    94 2 49 0 95 0 96 2 23 12 0 0 97 2 56 0 98
                                    0 99 2 56 45 23 0 100 2 88 2 0 45 101 2 49
                                    12 0 0 104 1 49 17 0 105 1 49 2 0 106 2 0 0
                                    0 17 107 1 49 0 0 108 2 0 0 0 0 109 2 110 0
                                    7 17 111 0 110 0 112 1 0 7 0 113 2 110 0 0
                                    0 114 2 110 12 0 0 116 1 110 7 0 117 1 110
                                    17 0 118 1 110 0 0 119 2 7 0 0 0 121 1 0 7
                                    0 122 2 7 12 0 0 123 1 49 2 0 124 2 0 0 0 0
                                    125 2 49 0 0 0 126 2 127 2 2 2 128 1 7 129
                                    0 130 1 33 129 0 131 2 132 129 0 45 133 1
                                    17 129 0 134 2 129 0 0 0 135 0 8 0 136 2
                                    129 0 0 0 137 2 132 129 138 0 139 2 129 0 0
                                    0 140 2 0 12 0 0 1 1 0 12 0 13 1 0 56 0 72
                                    1 0 110 0 115 2 0 47 0 23 48 1 3 151 0 1 1
                                    3 0 0 1 1 3 12 0 1 1 0 17 0 21 2 0 17 0 56
                                    1 2 0 32 0 0 1 1 1 155 47 1 1 20 0 0 1 1 20
                                    150 0 1 2 1 156 157 47 1 2 11 12 0 0 1 0 0
                                    0 1 1 17 158 0 1 1 16 159 0 1 1 0 38 0 1 1
                                    0 43 0 44 1 17 149 0 1 1 16 45 0 1 1 0 23 0
                                    1 1 0 7 0 42 3 2 0 0 0 23 1 2 0 0 0 76 77 1
                                    0 0 0 68 1 12 152 143 1 2 12 153 143 154 1
                                    2 0 164 143 154 1 1 0 165 143 1 1 0 32 0 1
                                    2 20 0 0 23 1 1 20 0 0 1 1 0 102 0 1 1 1 12
                                    0 1 4 0 0 0 7 8 0 1 3 6 147 0 145 147 1 3 7
                                    148 0 146 148 1 1 0 12 0 1 1 0 17 0 59 2 0
                                    0 47 23 53 2 0 0 110 23 120 1 0 102 0 1 1 0
                                    12 0 60 3 0 0 0 56 55 1 3 0 0 0 23 17 30 2
                                    0 0 7 8 28 3 0 163 0 0 23 1 2 0 17 0 23 51
                                    2 0 55 0 56 58 1 0 8 0 1 2 0 0 169 0 1 2 0
                                    0 168 0 1 1 0 38 0 39 1 0 0 0 1 1 0 7 0 41
                                    1 20 0 102 1 2 20 0 0 0 1 1 0 171 0 1 1 0
                                    160 0 1 1 0 160 0 1 1 0 162 0 1 1 0 170 0 1
                                    1 0 12 0 40 1 0 7 0 113 2 20 47 47 47 1 1
                                    20 0 102 1 2 20 0 0 0 125 1 1 155 47 1 1 1
                                    155 47 1 1 1 150 0 1 2 3 32 0 0 1 2 3 32 0
                                    7 1 3 0 0 0 56 102 103 3 0 0 0 23 0 82 3 0
                                    0 0 23 7 84 3 0 0 0 56 86 87 3 0 0 0 0 0 1
                                    3 0 0 0 102 102 1 2 0 0 0 166 1 2 0 0 0 167
                                    1 2 2 0 0 23 1 3 0 0 0 23 17 1 3 0 0 0 56
                                    55 1 2 0 0 0 23 54 2 0 0 0 56 1 2 0 17 0 23
                                    37 2 0 55 0 56 57 1 0 8 0 67 1 10 144 0 1 1
                                    8 145 0 1 1 9 146 0 1 2 20 0 0 23 1 1 20 7
                                    0 122 1 24 142 143 1 1 19 0 149 1 1 3 0 0 1
                                    1 0 0 23 31 1 0 0 7 83 1 0 0 45 1 1 0 129 0
                                    141 1 0 86 0 1 3 0 0 0 23 17 1 3 0 0 0 56
                                    55 1 2 0 7 0 8 1 1 25 32 0 1 0 0 17 1 3 2 0
                                    0 0 17 1 2 3 12 0 0 1 2 0 0 0 17 107 2 0 0
                                    0 22 1 0 0 0 16 0 0 0 25 3 0 0 0 23 17 1 3
                                    0 0 0 56 55 1 2 0 0 0 23 1 2 0 0 0 56 1 2 0
                                    12 0 0 1 2 18 0 0 7 65 2 0 0 0 0 1 1 0 0 0
                                    1 2 0 0 0 0 109 2 13 0 149 0 1 2 13 0 0 149
                                    1 2 0 0 7 0 64 2 0 0 0 7 1 2 0 0 0 0 29 2 0
                                    0 45 0 1 2 0 0 17 0 1 2 0 0 22 0 1)))))
           '|lookupComplete|)) 
