
(/VERSIONCHECK 2) 

(PUT '|MRING;coerce;L$;1| '|SPADreplace| '(XLAM (|x|) |x|)) 

(DEFUN |MRING;coerce;L$;1| (|x| $) |x|) 

(DEFUN |MRING;monomial;RM$;2| (|r| |m| $)
  (COND ((SPADCALL |r| (|spadConstant| $ 13) (QREFELT $ 15)) NIL)
        ('T (LIST (CONS |r| |m|))))) 

(DEFUN |MRING;size;Nni;3| ($)
  (EXPT (SPADCALL (QREFELT $ 18)) (SPADCALL (QREFELT $ 19)))) 

(DEFUN |MRING;index;Pi$;4| (|k| $)
  (PROG (|i| |ans| |m| #1=#:G1851 |c| #2=#:G1850 |h| |j| |n| |p|)
    (RETURN
     (SEQ
      (LETT |i| (REMAINDER2 |k| (SPADCALL (QREFELT $ 20)))
            . #3=(|MRING;index;Pi$;4|))
      (LETT |p| (SPADCALL (QREFELT $ 18)) . #3#)
      (LETT |n| (SPADCALL (QREFELT $ 19)) . #3#)
      (LETT |ans| (|spadConstant| $ 12) . #3#)
      (SEQ (LETT |j| 0 . #3#) G190 (COND ((NULL (< 0 |i|)) (GO G191)))
           (SEQ (LETT |h| (REMAINDER2 |i| |p|) . #3#)
                (COND
                 ((NULL (EQL |h| 0))
                  (SEQ
                   (LETT |c|
                         (SPADCALL
                          (PROG1 (LETT #2# |h| . #3#)
                            (|check-subtype| (> #2# 0) '(|PositiveInteger|)
                                             #2#))
                          (QREFELT $ 22))
                         . #3#)
                   (LETT |m|
                         (SPADCALL
                          (PROG1 (LETT #1# (+ |j| |n|) . #3#)
                            (|check-subtype| (> #1# 0) '(|PositiveInteger|)
                                             #1#))
                          (QREFELT $ 23))
                         . #3#)
                   (EXIT
                    (LETT |ans|
                          (SPADCALL |ans| (SPADCALL |c| |m| (QREFELT $ 16))
                                    (QREFELT $ 24))
                          . #3#)))))
                (EXIT (LETT |i| (QUOTIENT2 |i| |p|) . #3#)))
           (LETT |j| (QSADD1 |j|) . #3#) (GO G190) G191 (EXIT NIL))
      (EXIT |ans|))))) 

(DEFUN |MRING;lookup;$Pi;5| (|z| $)
  (PROG (|res| |co| |ex| |l| #1=#:G1863 |te| |n| |p| |liTe|)
    (RETURN
     (SEQ
      (COND ((SPADCALL |z| (QREFELT $ 26)) (SPADCALL (QREFELT $ 20)))
            ('T
             (SEQ
              (LETT |liTe| (SPADCALL |z| (QREFELT $ 27))
                    . #2=(|MRING;lookup;$Pi;5|))
              (LETT |p| (SPADCALL (QREFELT $ 18)) . #2#)
              (LETT |n| (SPADCALL (QREFELT $ 19)) . #2#) (LETT |res| 0 . #2#)
              (SEQ (LETT |te| NIL . #2#) (LETT #1# |liTe| . #2#) G190
                   (COND
                    ((OR (ATOM #1#) (PROGN (LETT |te| (CAR #1#) . #2#) NIL))
                     (GO G191)))
                   (SEQ (LETT |l| (SPADCALL (QCDR |te|) (QREFELT $ 28)) . #2#)
                        (LETT |ex| (COND ((EQL |n| |l|) 0) ('T |l|)) . #2#)
                        (LETT |co| (SPADCALL (QCAR |te|) (QREFELT $ 29)) . #2#)
                        (EXIT
                         (LETT |res| (+ |res| (* |co| (EXPT |p| |ex|)))
                               . #2#)))
                   (LETT #1# (CDR #1#) . #2#) (GO G190) G191 (EXIT NIL))
              (EXIT |res|)))))))) 

(PUT '|MRING;Zero;$;6| '|SPADreplace| '(XLAM NIL NIL)) 

(DEFUN |MRING;Zero;$;6| ($) NIL) 

(DEFUN |MRING;One;$;7| ($)
  (LIST (CONS (|spadConstant| $ 32) (|spadConstant| $ 33)))) 

(DEFUN |MRING;terms;$L;8| (|a| $) (SPADCALL |a| (QREFELT $ 34))) 

(DEFUN |MRING;monomials;$L;9| (|a| $)
  (PROG (#1=#:G1873 |t| #2=#:G1872)
    (RETURN
     (SEQ
      (PROGN
       (LETT #2# NIL . #3=(|MRING;monomials;$L;9|))
       (SEQ (LETT |t| NIL . #3#) (LETT #1# |a| . #3#) G190
            (COND
             ((OR (ATOM #1#) (PROGN (LETT |t| (CAR #1#) . #3#) NIL))
              (GO G191)))
            (SEQ (EXIT (LETT #2# (CONS (LIST |t|) #2#) . #3#)))
            (LETT #1# (CDR #1#) . #3#) (GO G190) G191
            (EXIT (NREVERSE0 #2#)))))))) 

(DEFUN |MRING;coefficients;$L;10| (|a| $)
  (PROG (#1=#:G1878 |t| #2=#:G1877)
    (RETURN
     (SEQ
      (PROGN
       (LETT #2# NIL . #3=(|MRING;coefficients;$L;10|))
       (SEQ (LETT |t| NIL . #3#) (LETT #1# |a| . #3#) G190
            (COND
             ((OR (ATOM #1#) (PROGN (LETT |t| (CAR #1#) . #3#) NIL))
              (GO G191)))
            (SEQ (EXIT (LETT #2# (CONS (QCAR |t|) #2#) . #3#)))
            (LETT #1# (CDR #1#) . #3#) (GO G190) G191
            (EXIT (NREVERSE0 #2#)))))))) 

(DEFUN |MRING;coerce;M$;11| (|m| $) (LIST (CONS (|spadConstant| $ 32) |m|))) 

(DEFUN |MRING;coerce;R$;12| (|r| $)
  (COND
   ((SPADCALL |r| (|spadConstant| $ 13) (QREFELT $ 15)) (|spadConstant| $ 12))
   ('T (LIST (CONS |r| (|spadConstant| $ 33)))))) 

(DEFUN |MRING;coerce;I$;13| (|n| $)
  (COND ((EQL |n| 0) (|spadConstant| $ 12))
        ('T (LIST (CONS (SPADCALL |n| (QREFELT $ 42)) (|spadConstant| $ 33)))))) 

(DEFUN |MRING;-;2$;14| (|a| $)
  (PROG (#1=#:G1889 |t| #2=#:G1888)
    (RETURN
     (SEQ
      (PROGN
       (LETT #2# NIL . #3=(|MRING;-;2$;14|))
       (SEQ (LETT |t| NIL . #3#) (LETT #1# |a| . #3#) G190
            (COND
             ((OR (ATOM #1#) (PROGN (LETT |t| (CAR #1#) . #3#) NIL))
              (GO G191)))
            (SEQ
             (EXIT
              (LETT #2#
                    (CONS
                     (CONS (SPADCALL (QCAR |t|) (QREFELT $ 44)) (QCDR |t|))
                     #2#)
                    . #3#)))
            (LETT #1# (CDR #1#) . #3#) (GO G190) G191
            (EXIT (NREVERSE0 #2#)))))))) 

(DEFUN |MRING;*;R2$;15| (|r| |a| $)
  (PROG (#1=#:G1894 |t| #2=#:G1893)
    (RETURN
     (SEQ
      (COND
       ((SPADCALL |r| (|spadConstant| $ 13) (QREFELT $ 15))
        (|spadConstant| $ 12))
       ('T
        (PROGN
         (LETT #2# NIL . #3=(|MRING;*;R2$;15|))
         (SEQ (LETT |t| NIL . #3#) (LETT #1# |a| . #3#) G190
              (COND
               ((OR (ATOM #1#) (PROGN (LETT |t| (CAR #1#) . #3#) NIL))
                (GO G191)))
              (SEQ
               (EXIT
                (LETT #2#
                      (CONS
                       (CONS (SPADCALL |r| (QCAR |t|) (QREFELT $ 46))
                             (QCDR |t|))
                       #2#)
                      . #3#)))
              (LETT #1# (CDR #1#) . #3#) (GO G190) G191
              (EXIT (NREVERSE0 #2#)))))))))) 

(DEFUN |MRING;*;R2$;16| (|r| |a| $)
  (PROG (|rt| #1=#:G1900 |t| #2=#:G1899)
    (RETURN
     (SEQ
      (COND
       ((SPADCALL |r| (|spadConstant| $ 13) (QREFELT $ 15))
        (|spadConstant| $ 12))
       (#3='T
        (PROGN
         (LETT #2# NIL . #4=(|MRING;*;R2$;16|))
         (SEQ (LETT |t| NIL . #4#) (LETT #1# |a| . #4#) G190
              (COND
               ((OR (ATOM #1#) (PROGN (LETT |t| (CAR #1#) . #4#) NIL))
                (GO G191)))
              (SEQ
               (EXIT
                (COND
                 ((SEQ
                   (LETT |rt| (SPADCALL |r| (QCAR |t|) (QREFELT $ 46)) . #4#)
                   (EXIT
                    (COND
                     ((SPADCALL |rt| (|spadConstant| $ 13) (QREFELT $ 15))
                      'NIL)
                     (#3# 'T))))
                  (LETT #2# (CONS (CONS |rt| (QCDR |t|)) #2#) . #4#)))))
              (LETT #1# (CDR #1#) . #4#) (GO G190) G191
              (EXIT (NREVERSE0 #2#)))))))))) 

(DEFUN |MRING;*;I2$;17| (|n| |a| $)
  (PROG (#1=#:G1905 |t| #2=#:G1904)
    (RETURN
     (SEQ
      (COND ((EQL |n| 0) (|spadConstant| $ 12))
            ('T
             (PROGN
              (LETT #2# NIL . #3=(|MRING;*;I2$;17|))
              (SEQ (LETT |t| NIL . #3#) (LETT #1# |a| . #3#) G190
                   (COND
                    ((OR (ATOM #1#) (PROGN (LETT |t| (CAR #1#) . #3#) NIL))
                     (GO G191)))
                   (SEQ
                    (EXIT
                     (LETT #2#
                           (CONS
                            (CONS (SPADCALL |n| (QCAR |t|) (QREFELT $ 48))
                                  (QCDR |t|))
                            #2#)
                           . #3#)))
                   (LETT #1# (CDR #1#) . #3#) (GO G190) G191
                   (EXIT (NREVERSE0 #2#)))))))))) 

(DEFUN |MRING;*;I2$;18| (|n| |a| $)
  (PROG (|nt| #1=#:G1911 |t| #2=#:G1910)
    (RETURN
     (SEQ
      (COND ((EQL |n| 0) (|spadConstant| $ 12))
            (#3='T
             (PROGN
              (LETT #2# NIL . #4=(|MRING;*;I2$;18|))
              (SEQ (LETT |t| NIL . #4#) (LETT #1# |a| . #4#) G190
                   (COND
                    ((OR (ATOM #1#) (PROGN (LETT |t| (CAR #1#) . #4#) NIL))
                     (GO G191)))
                   (SEQ
                    (EXIT
                     (COND
                      ((SEQ
                        (LETT |nt| (SPADCALL |n| (QCAR |t|) (QREFELT $ 48))
                              . #4#)
                        (EXIT
                         (COND
                          ((SPADCALL |nt| (|spadConstant| $ 13) (QREFELT $ 15))
                           'NIL)
                          (#3# 'T))))
                       (LETT #2# (CONS (CONS |nt| (QCDR |t|)) #2#) . #4#)))))
                   (LETT #1# (CDR #1#) . #4#) (GO G190) G191
                   (EXIT (NREVERSE0 #2#)))))))))) 

(DEFUN |MRING;map;M2$;19| (|f| |a| $)
  (PROG (|ft| #1=#:G1918 |t| #2=#:G1917)
    (RETURN
     (SEQ
      (PROGN
       (LETT #2# NIL . #3=(|MRING;map;M2$;19|))
       (SEQ (LETT |t| NIL . #3#) (LETT #1# |a| . #3#) G190
            (COND
             ((OR (ATOM #1#) (PROGN (LETT |t| (CAR #1#) . #3#) NIL))
              (GO G191)))
            (SEQ
             (EXIT
              (COND
               ((SEQ (LETT |ft| (SPADCALL (QCAR |t|) |f|) . #3#)
                     (EXIT
                      (COND
                       ((SPADCALL |ft| (|spadConstant| $ 13) (QREFELT $ 15))
                        'NIL)
                       ('T 'T))))
                (LETT #2# (CONS (CONS |ft| (QCDR |t|)) #2#) . #3#)))))
            (LETT #1# (CDR #1#) . #3#) (GO G190) G191
            (EXIT (NREVERSE0 #2#)))))))) 

(PUT '|MRING;numberOfMonomials;$Nni;20| '|SPADreplace| 'LENGTH) 

(DEFUN |MRING;numberOfMonomials;$Nni;20| (|a| $) (LENGTH |a|)) 

(DEFUN |MRING;retractIfCan;$U;21| (|a| $)
  (SEQ
   (COND
    ((EQL (LENGTH |a|) 1)
     (COND
      ((SPADCALL (QCAR (|SPADfirst| |a|)) (|spadConstant| $ 32) (QREFELT $ 15))
       (EXIT (CONS 0 (QCDR (|SPADfirst| |a|))))))))
   (EXIT (CONS 1 "failed")))) 

(DEFUN |MRING;retractIfCan;$U;22| (|a| $)
  (SEQ
   (COND
    ((EQL (LENGTH |a|) 1)
     (COND
      ((SPADCALL (QCDR (|SPADfirst| |a|)) (|spadConstant| $ 33) (QREFELT $ 55))
       (EXIT (CONS 0 (QCAR (|SPADfirst| |a|))))))))
   (EXIT (CONS 1 "failed")))) 

(DEFUN |MRING;recip;$U;23| (|a| $)
  (PROG (|u| |lt|)
    (RETURN
     (SEQ (LETT |lt| (SPADCALL |a| (QREFELT $ 27)) . #1=(|MRING;recip;$U;23|))
          (COND ((NULL (EQL (LENGTH |lt|) 1)) (EXIT (CONS 1 "failed"))))
          (LETT |u| (SPADCALL (QCAR (|SPADfirst| |lt|)) (QREFELT $ 59)) . #1#)
          (EXIT
           (COND ((QEQCAR |u| 1) (CONS 1 "failed"))
                 ('T
                  (CONS 0
                        (SPADCALL (QCDR |u|)
                                  (SPADCALL (QCDR (|SPADfirst| |lt|))
                                            (QREFELT $ 60))
                                  (QREFELT $ 16)))))))))) 

(DEFUN |MRING;recip;$U;24| (|a| $)
  (PROG (|u|)
    (RETURN
     (SEQ
      (COND
       ((EQL (LENGTH |a|) 1)
        (COND
         ((NULL
           (SPADCALL (QCDR (|SPADfirst| |a|)) (|spadConstant| $ 33)
                     (QREFELT $ 55)))
          (EXIT (CONS 1 #1="failed")))))
       (#2='T (EXIT (CONS 1 #1#))))
      (LETT |u| (SPADCALL (QCAR (|SPADfirst| |a|)) (QREFELT $ 59))
            |MRING;recip;$U;24|)
      (EXIT
       (COND ((QEQCAR |u| 1) (CONS 1 "failed"))
             (#2# (CONS 0 (SPADCALL (QCDR |u|) (QREFELT $ 40)))))))))) 

(DEFUN |MRING;mkTerm| (|r| |m| $)
  (COND
   ((SPADCALL |r| (|spadConstant| $ 32) (QREFELT $ 15))
    (SPADCALL |m| (QREFELT $ 63)))
   ((OR (SPADCALL |r| (|spadConstant| $ 13) (QREFELT $ 15))
        (SPADCALL |m| (|spadConstant| $ 33) (QREFELT $ 55)))
    (SPADCALL |r| (QREFELT $ 64)))
   ('T
    (SPADCALL (SPADCALL |r| (QREFELT $ 64)) (SPADCALL |m| (QREFELT $ 63))
              (QREFELT $ 65))))) 

(DEFUN |MRING;coerce;$Of;26| (|a| $)
  (PROG (#1=#:G1977 |t| #2=#:G1976)
    (RETURN
     (SEQ
      (COND ((NULL |a|) (SPADCALL 0 (QREFELT $ 66)))
            ((NULL (CDR |a|))
             (|MRING;mkTerm| (QCAR (|SPADfirst| |a|)) (QCDR (|SPADfirst| |a|))
              $))
            ('T
             (SPADCALL (ELT $ 67)
                       (PROGN
                        (LETT #2# NIL . #3=(|MRING;coerce;$Of;26|))
                        (SEQ (LETT |t| NIL . #3#) (LETT #1# |a| . #3#) G190
                             (COND
                              ((OR (ATOM #1#)
                                   (PROGN (LETT |t| (CAR #1#) . #3#) NIL))
                               (GO G191)))
                             (SEQ
                              (EXIT
                               (LETT #2#
                                     (CONS
                                      (|MRING;mkTerm| (QCAR |t|) (QCDR |t|) $)
                                      #2#)
                                     . #3#)))
                             (LETT #1# (CDR #1#) . #3#) (GO G190) G191
                             (EXIT (NREVERSE0 #2#))))
                       (QREFELT $ 70)))))))) 

(DEFUN |MRING;leadingCoefficient;$R;27| (|a| $)
  (COND ((NULL |a|) (|spadConstant| $ 13)) ('T (QCAR (|SPADfirst| |a|))))) 

(DEFUN |MRING;leadingMonomial;$M;28| (|a| $)
  (COND ((NULL |a|) (|spadConstant| $ 33)) ('T (QCDR (|SPADfirst| |a|))))) 

(DEFUN |MRING;reductum;2$;29| (|a| $) (COND ((NULL |a|) |a|) ('T (CDR |a|)))) 

(DEFUN |MRING;=;2$B;30| (|a| |b| $)
  (PROG (#1=#:G1990 #2=#:G1992 #3=#:G1993 |ta| #4=#:G1994 |tb|)
    (RETURN
     (SEQ
      (EXIT
       (COND ((NULL (EQL (LENGTH |a|) (LENGTH |b|))) 'NIL)
             ('T
              (SEQ
               (SEQ
                (EXIT
                 (SEQ (LETT |tb| NIL . #5=(|MRING;=;2$B;30|))
                      (LETT #4# |b| . #5#) (LETT |ta| NIL . #5#)
                      (LETT #3# |a| . #5#) G190
                      (COND
                       ((OR (ATOM #3#) (PROGN (LETT |ta| (CAR #3#) . #5#) NIL)
                            (ATOM #4#) (PROGN (LETT |tb| (CAR #4#) . #5#) NIL))
                        (GO G191)))
                      (SEQ
                       (EXIT
                        (COND
                         ((SPADCALL (QCAR |ta|) (QCAR |tb|) (QREFELT $ 15))
                          (COND
                           ((NULL
                             (SPADCALL (QCDR |ta|) (QCDR |tb|) (QREFELT $ 55)))
                            (PROGN
                             (LETT #1# (PROGN (LETT #2# 'NIL . #5#) (GO #2#))
                                   . #5#)
                             (GO #1#)))))
                         ('T
                          (PROGN
                           (LETT #1# (PROGN (LETT #2# 'NIL . #5#) (GO #2#))
                                 . #5#)
                           (GO #1#))))))
                      (LETT #3# (PROG1 (CDR #3#) (LETT #4# (CDR #4#) . #5#))
                            . #5#)
                      (GO G190) G191 (EXIT NIL)))
                #1# (EXIT #1#))
               (EXIT 'T)))))
      #2# (EXIT #2#))))) 

(DEFUN |MRING;+;3$;31| (|a| |b| $)
  (PROG (|c| |r| |rb| |ra| |tb| |ta|)
    (RETURN
     (SEQ (LETT |c| NIL . #1=(|MRING;+;3$;31|))
          (SEQ G190
               (COND
                ((NULL (COND ((OR (NULL |a|) (NULL |b|)) 'NIL) ('T 'T)))
                 (GO G191)))
               (SEQ (LETT |ta| (|SPADfirst| |a|) . #1#)
                    (LETT |tb| (|SPADfirst| |b|) . #1#)
                    (LETT |ra| (CDR |a|) . #1#) (LETT |rb| (CDR |b|) . #1#)
                    (EXIT
                     (LETT |c|
                           (COND
                            ((SPADCALL (QCDR |tb|) (QCDR |ta|) (QREFELT $ 76))
                             (SEQ (LETT |a| |ra| . #1#)
                                  (EXIT (SPADCALL |c| |ta| (QREFELT $ 77)))))
                            ((SPADCALL (QCDR |ta|) (QCDR |tb|) (QREFELT $ 76))
                             (SEQ (LETT |b| |rb| . #1#)
                                  (EXIT (SPADCALL |c| |tb| (QREFELT $ 77)))))
                            ('T
                             (SEQ (LETT |a| |ra| . #1#) (LETT |b| |rb| . #1#)
                                  (COND
                                   ((NULL
                                     (SPADCALL
                                      (LETT |r|
                                            (SPADCALL (QCAR |ta|) (QCAR |tb|)
                                                      (QREFELT $ 78))
                                            . #1#)
                                      (QREFELT $ 79)))
                                    (EXIT
                                     (SPADCALL |c| (CONS |r| (QCDR |ta|))
                                               (QREFELT $ 77)))))
                                  (EXIT |c|))))
                           . #1#)))
               NIL (GO G190) G191 (EXIT NIL))
          (EXIT
           (SPADCALL |c| (SPADCALL |a| |b| (QREFELT $ 80)) (QREFELT $ 81))))))) 

(DEFUN |MRING;coefficient;$MR;32| (|a| |m| $)
  (PROG (#1=#:G2021 #2=#:G2022 |t|)
    (RETURN
     (SEQ
      (EXIT
       (SEQ
        (SEQ (LETT |t| NIL . #3=(|MRING;coefficient;$MR;32|))
             (LETT #2# |a| . #3#) G190
             (COND
              ((OR (ATOM #2#) (PROGN (LETT |t| (CAR #2#) . #3#) NIL))
               (GO G191)))
             (SEQ
              (COND
               ((SPADCALL (QCDR |t|) |m| (QREFELT $ 55))
                (PROGN (LETT #1# (QCAR |t|) . #3#) (GO #1#))))
              (EXIT
               (COND
                ((SPADCALL (QCDR |t|) |m| (QREFELT $ 76))
                 (PROGN (LETT #1# (|spadConstant| $ 13) . #3#) (GO #1#))))))
             (LETT #2# (CDR #2#) . #3#) (GO G190) G191 (EXIT NIL))
        (EXIT (|spadConstant| $ 13))))
      #1# (EXIT #1#))))) 

(DEFUN |MRING;*;3$;33| (|a| |b| $)
  (PROG (#1=#:G2025 #2=#:G2024 #3=#:G2026 #4=#:G2031 |tb| #5=#:G2030 #6=#:G2029
         |ta|)
    (RETURN
     (SEQ
      (PROGN
       (LETT #1# NIL . #7=(|MRING;*;3$;33|))
       (SEQ (LETT |ta| NIL . #7#) (LETT #6# (REVERSE |a|) . #7#) G190
            (COND
             ((OR (ATOM #6#) (PROGN (LETT |ta| (CAR #6#) . #7#) NIL))
              #8=(GO G191)))
            (SEQ
             (EXIT
              (PROGN
               (LETT #3#
                     (PROGN
                      (LETT #5# NIL . #7#)
                      (SEQ (LETT |tb| NIL . #7#) (LETT #4# |b| . #7#) G190
                           (COND
                            ((OR (ATOM #4#)
                                 (PROGN (LETT |tb| (CAR #4#) . #7#) NIL))
                             #8#))
                           (SEQ
                            (EXIT
                             (LETT #5#
                                   (CONS
                                    (CONS
                                     (SPADCALL (QCAR |ta|) (QCAR |tb|)
                                               (QREFELT $ 46))
                                     (SPADCALL (QCDR |ta|) (QCDR |tb|)
                                               (QREFELT $ 83)))
                                    #5#)
                                   . #7#)))
                           (LETT #4# (CDR #4#) . #7#) #9=(GO G190) G191
                           (EXIT (NREVERSE0 #5#))))
                     . #7#)
               (COND (#1# (LETT #2# (SPADCALL #2# #3# (QREFELT $ 24)) . #7#))
                     ('T (PROGN (LETT #2# #3# . #7#) (LETT #1# 'T . #7#)))))))
            (LETT #6# (CDR #6#) . #7#) #9# G191 (EXIT NIL))
       (COND (#1# #2#) ('T (|spadConstant| $ 12)))))))) 

(DEFUN |MRING;*;3$;34| (|a| |b| $)
  (PROG (#1=#:G2034 #2=#:G2033 #3=#:G2035 |r| #4=#:G2041 |tb| #5=#:G2040
         #6=#:G2039 |ta|)
    (RETURN
     (SEQ
      (PROGN
       (LETT #1# NIL . #7=(|MRING;*;3$;34|))
       (SEQ (LETT |ta| NIL . #7#) (LETT #6# (REVERSE |a|) . #7#) G190
            (COND
             ((OR (ATOM #6#) (PROGN (LETT |ta| (CAR #6#) . #7#) NIL))
              #8=(GO G191)))
            (SEQ
             (EXIT
              (PROGN
               (LETT #3#
                     (PROGN
                      (LETT #5# NIL . #7#)
                      (SEQ (LETT |tb| NIL . #7#) (LETT #4# |b| . #7#) G190
                           (COND
                            ((OR (ATOM #4#)
                                 (PROGN (LETT |tb| (CAR #4#) . #7#) NIL))
                             #8#))
                           (SEQ
                            (EXIT
                             (COND
                              ((COND
                                ((SPADCALL
                                  (LETT |r|
                                        (SPADCALL (QCAR |ta|) (QCAR |tb|)
                                                  (QREFELT $ 46))
                                        . #7#)
                                  (QREFELT $ 79))
                                 'NIL)
                                ('T 'T))
                               (LETT #5#
                                     (CONS
                                      (CONS |r|
                                            (SPADCALL (QCDR |ta|) (QCDR |tb|)
                                                      (QREFELT $ 83)))
                                      #5#)
                                     . #7#)))))
                           (LETT #4# (CDR #4#) . #7#) #9=(GO G190) G191
                           (EXIT (NREVERSE0 #5#))))
                     . #7#)
               (COND (#1# (LETT #2# (SPADCALL #2# #3# (QREFELT $ 24)) . #7#))
                     ('T (PROGN (LETT #2# #3# . #7#) (LETT #1# 'T . #7#)))))))
            (LETT #6# (CDR #6#) . #7#) #9# G191 (EXIT NIL))
       (COND (#1# #2#) ('T (|spadConstant| $ 12)))))))) 

(DEFUN |MRING;ge| (|s| |t| $)
  (COND ((SPADCALL (QCDR |s|) (QCDR |t|) (QREFELT $ 76)) 'NIL) ('T 'T))) 

(DEFUN |MRING;sortAndAdd| (|liTe| $)
  (PROG (|res| |cf| |m| #1=#:G2056 |te|)
    (RETURN
     (SEQ
      (LETT |liTe|
            (SPADCALL (CONS (|function| |MRING;ge|) $) |liTe| (QREFELT $ 86))
            . #2=(|MRING;sortAndAdd|))
      (LETT |m| (QCDR (|SPADfirst| |liTe|)) . #2#)
      (LETT |cf| (QCAR (|SPADfirst| |liTe|)) . #2#) (LETT |res| NIL . #2#)
      (SEQ (LETT |te| NIL . #2#) (LETT #1# (CDR |liTe|) . #2#) G190
           (COND
            ((OR (ATOM #1#) (PROGN (LETT |te| (CAR #1#) . #2#) NIL))
             (GO G191)))
           (SEQ
            (EXIT
             (COND
              ((SPADCALL |m| (QCDR |te|) (QREFELT $ 55))
               (LETT |cf| (SPADCALL |cf| (QCAR |te|) (QREFELT $ 78)) . #2#))
              ('T
               (SEQ
                (COND
                 ((NULL (SPADCALL |cf| (QREFELT $ 79)))
                  (LETT |res| (CONS (CONS |cf| |m|) |res|) . #2#)))
                (LETT |m| (QCDR |te|) . #2#)
                (EXIT (LETT |cf| (QCAR |te|) . #2#)))))))
           (LETT #1# (CDR #1#) . #2#) (GO G190) G191 (EXIT NIL))
      (COND
       ((NULL (SPADCALL |cf| (QREFELT $ 79)))
        (LETT |res| (CONS (CONS |cf| |m|) |res|) . #2#)))
      (EXIT (REVERSE |res|)))))) 

(DEFUN |MRING;*;3$;37| (|a| |b| $)
  (PROG (#1=#:G2059 #2=#:G2058 #3=#:G2060 #4=#:G2071 |tb| #5=#:G2070 #6=#:G2069
         |ta|)
    (RETURN
     (SEQ
      (COND ((SPADCALL |a| (QREFELT $ 26)) |a|)
            ((SPADCALL |b| (QREFELT $ 26)) |b|)
            (#7='T
             (PROGN
              (LETT #1# NIL . #8=(|MRING;*;3$;37|))
              (SEQ (LETT |ta| NIL . #8#) (LETT #6# (REVERSE |a|) . #8#) G190
                   (COND
                    ((OR (ATOM #6#) (PROGN (LETT |ta| (CAR #6#) . #8#) NIL))
                     #9=(GO G191)))
                   (SEQ
                    (EXIT
                     (PROGN
                      (LETT #3#
                            (|MRING;sortAndAdd|
                             (PROGN
                              (LETT #5# NIL . #8#)
                              (SEQ (LETT |tb| NIL . #8#) (LETT #4# |b| . #8#)
                                   G190
                                   (COND
                                    ((OR (ATOM #4#)
                                         (PROGN
                                          (LETT |tb| (CAR #4#) . #8#)
                                          NIL))
                                     #9#))
                                   (SEQ
                                    (EXIT
                                     (LETT #5#
                                           (CONS
                                            (CONS
                                             (SPADCALL (QCAR |ta|) (QCAR |tb|)
                                                       (QREFELT $ 46))
                                             (SPADCALL (QCDR |ta|) (QCDR |tb|)
                                                       (QREFELT $ 83)))
                                            #5#)
                                           . #8#)))
                                   (LETT #4# (CDR #4#) . #8#) #10=(GO G190)
                                   G191 (EXIT (NREVERSE0 #5#))))
                             $)
                            . #8#)
                      (COND
                       (#1# (LETT #2# (SPADCALL #2# #3# (QREFELT $ 24)) . #8#))
                       ('T
                        (PROGN (LETT #2# #3# . #8#) (LETT #1# 'T . #8#)))))))
                   (LETT #6# (CDR #6#) . #8#) #10# G191 (EXIT NIL))
              (COND (#1# #2#) (#7# (|spadConstant| $ 12)))))))))) 

(DEFUN |MRING;*;3$;38| (|a| |b| $)
  (PROG (#1=#:G2074 #2=#:G2073 #3=#:G2075 |r| #4=#:G2091 |tb| #5=#:G2090
         #6=#:G2089 |ta|)
    (RETURN
     (SEQ
      (COND ((SPADCALL |a| (QREFELT $ 26)) |a|)
            ((SPADCALL |b| (QREFELT $ 26)) |b|)
            (#7='T
             (PROGN
              (LETT #1# NIL . #8=(|MRING;*;3$;38|))
              (SEQ (LETT |ta| NIL . #8#) (LETT #6# (REVERSE |a|) . #8#) G190
                   (COND
                    ((OR (ATOM #6#) (PROGN (LETT |ta| (CAR #6#) . #8#) NIL))
                     #9=(GO G191)))
                   (SEQ
                    (EXIT
                     (PROGN
                      (LETT #3#
                            (|MRING;sortAndAdd|
                             (PROGN
                              (LETT #5# NIL . #8#)
                              (SEQ (LETT |tb| NIL . #8#) (LETT #4# |b| . #8#)
                                   G190
                                   (COND
                                    ((OR (ATOM #4#)
                                         (PROGN
                                          (LETT |tb| (CAR #4#) . #8#)
                                          NIL))
                                     #9#))
                                   (SEQ
                                    (EXIT
                                     (COND
                                      ((COND
                                        ((SPADCALL
                                          (LETT |r|
                                                (SPADCALL (QCAR |ta|)
                                                          (QCAR |tb|)
                                                          (QREFELT $ 46))
                                                . #8#)
                                          (QREFELT $ 79))
                                         'NIL)
                                        ('T 'T))
                                       (LETT #5#
                                             (CONS
                                              (CONS |r|
                                                    (SPADCALL (QCDR |ta|)
                                                              (QCDR |tb|)
                                                              (QREFELT $ 83)))
                                              #5#)
                                             . #8#)))))
                                   (LETT #4# (CDR #4#) . #8#) #10=(GO G190)
                                   G191 (EXIT (NREVERSE0 #5#))))
                             $)
                            . #8#)
                      (COND
                       (#1# (LETT #2# (SPADCALL #2# #3# (QREFELT $ 24)) . #8#))
                       ('T
                        (PROGN (LETT #2# #3# . #8#) (LETT #1# 'T . #8#)))))))
                   (LETT #6# (CDR #6#) . #8#) #10# G191 (EXIT NIL))
              (COND (#1# #2#) (#7# (|spadConstant| $ 12)))))))))) 

(DEFUN |MRING;=;2$B;39| (|a| |b| $)
  (COND ((NULL (EQL (LENGTH |a|) (LENGTH |b|))) 'NIL)
        ('T
         (SPADCALL (SPADCALL |a| (QREFELT $ 88)) (SPADCALL |b| (QREFELT $ 88))
                   (QREFELT $ 89))))) 

(DEFUN |MRING;coefficient;$MR;40| (|a| |m| $)
  (PROG (#1=#:G2099 #2=#:G2101 #3=#:G2102 |t|)
    (RETURN
     (SEQ
      (EXIT
       (SEQ
        (SEQ
         (EXIT
          (SEQ (LETT |t| NIL . #4=(|MRING;coefficient;$MR;40|))
               (LETT #3# |a| . #4#) G190
               (COND
                ((OR (ATOM #3#) (PROGN (LETT |t| (CAR #3#) . #4#) NIL))
                 (GO G191)))
               (SEQ
                (EXIT
                 (COND
                  ((SPADCALL (QCDR |t|) |m| (QREFELT $ 55))
                   (PROGN
                    (LETT #1# (PROGN (LETT #2# (QCAR |t|) . #4#) (GO #2#))
                          . #4#)
                    (GO #1#))))))
               (LETT #3# (CDR #3#) . #4#) (GO G190) G191 (EXIT NIL)))
         #1# (EXIT #1#))
        (EXIT (|spadConstant| $ 13))))
      #2# (EXIT #2#))))) 

(DEFUN |MRING;addterm| (|Tabl| |r| |m| $)
  (PROG (|u|)
    (RETURN
     (SEQ
      (LETT |u| (SPADCALL |m| |Tabl| (QREFELT $ 91)) . #1=(|MRING;addterm|))
      (EXIT
       (COND
        ((OR (QEQCAR |u| 1)
             (NULL
              (SPADCALL
               (LETT |r| (SPADCALL |r| (QCDR |u|) (QREFELT $ 78)) . #1#)
               (QREFELT $ 79))))
         (SPADCALL |Tabl| |m| |r| (QREFELT $ 92)))
        ('T
         (SEQ (SPADCALL |m| |Tabl| (QREFELT $ 93))
              (EXIT (|spadConstant| $ 13)))))))))) 

(DEFUN |MRING;+;3$;42| (|a| |b| $)
  (PROG (#1=#:G2126 |m| #2=#:G2125 #3=#:G2124 |t| #4=#:G2123 |Tabl|)
    (RETURN
     (SEQ (LETT |Tabl| (SPADCALL (QREFELT $ 94)) . #5=(|MRING;+;3$;42|))
          (SEQ (LETT |t| NIL . #5#) (LETT #4# |a| . #5#) G190
               (COND
                ((OR (ATOM #4#) (PROGN (LETT |t| (CAR #4#) . #5#) NIL))
                 #6=(GO G191)))
               (SEQ
                (EXIT (SPADCALL |Tabl| (QCDR |t|) (QCAR |t|) (QREFELT $ 92))))
               (LETT #4# (CDR #4#) . #5#) #7=(GO G190) G191 (EXIT NIL))
          (SEQ (LETT |t| NIL . #5#) (LETT #3# |b| . #5#) G190
               (COND
                ((OR (ATOM #3#) (PROGN (LETT |t| (CAR #3#) . #5#) NIL)) #6#))
               (SEQ (EXIT (|MRING;addterm| |Tabl| (QCAR |t|) (QCDR |t|) $)))
               (LETT #3# (CDR #3#) . #5#) #7# G191 (EXIT NIL))
          (EXIT
           (PROGN
            (LETT #2# NIL . #5#)
            (SEQ (LETT |m| NIL . #5#)
                 (LETT #1# (SPADCALL |Tabl| (QREFELT $ 96)) . #5#) G190
                 (COND
                  ((OR (ATOM #1#) (PROGN (LETT |m| (CAR #1#) . #5#) NIL)) #6#))
                 (SEQ
                  (EXIT
                   (LETT #2#
                         (CONS (CONS (SPADCALL |Tabl| |m| (QREFELT $ 97)) |m|)
                               #2#)
                         . #5#)))
                 (LETT #1# (CDR #1#) . #5#) #7# G191
                 (EXIT (NREVERSE0 #2#))))))))) 

(DEFUN |MRING;*;3$;43| (|a| |b| $)
  (PROG (#1=#:G2136 |m| #2=#:G2135 #3=#:G2134 |tb| #4=#:G2133 |ta| |Tabl|)
    (RETURN
     (SEQ (LETT |Tabl| (SPADCALL (QREFELT $ 94)) . #5=(|MRING;*;3$;43|))
          (SEQ (LETT |ta| NIL . #5#) (LETT #4# |a| . #5#) G190
               (COND
                ((OR (ATOM #4#) (PROGN (LETT |ta| (CAR #4#) . #5#) NIL))
                 #6=(GO G191)))
               (SEQ
                (EXIT
                 (SEQ (LETT |tb| NIL . #5#) (LETT #3# |b| . #5#) G190
                      (COND
                       ((OR (ATOM #3#) (PROGN (LETT |tb| (CAR #3#) . #5#) NIL))
                        #6#))
                      (SEQ
                       (EXIT
                        (|MRING;addterm| |Tabl|
                         (SPADCALL (QCAR |ta|) (QCAR |tb|) (QREFELT $ 46))
                         (SPADCALL (QCDR |ta|) (QCDR |tb|) (QREFELT $ 83)) $)))
                      (LETT #3# (CDR #3#) . #5#) #7=(GO G190) G191
                      (EXIT NIL))))
               (LETT #4# (CDR #4#) . #5#) #7# G191 (EXIT NIL))
          (EXIT
           (PROGN
            (LETT #2# NIL . #5#)
            (SEQ (LETT |m| NIL . #5#)
                 (LETT #1# (SPADCALL |Tabl| (QREFELT $ 96)) . #5#) G190
                 (COND
                  ((OR (ATOM #1#) (PROGN (LETT |m| (CAR #1#) . #5#) NIL)) #6#))
                 (SEQ
                  (EXIT
                   (LETT #2#
                         (CONS (CONS (SPADCALL |Tabl| |m| (QREFELT $ 97)) |m|)
                               #2#)
                         . #5#)))
                 (LETT #1# (CDR #1#) . #5#) #7# G191
                 (EXIT (NREVERSE0 #2#))))))))) 

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

(DEFUN |MonoidRing;| (|#1| |#2|)
  (PROG (|pv$| $ |dv$| DV$2 DV$1)
    (RETURN
     (PROGN
      (LETT DV$1 (|devaluate| |#1|) . #1=(|MonoidRing|))
      (LETT DV$2 (|devaluate| |#2|) . #1#)
      (LETT |dv$| (LIST '|MonoidRing| DV$1 DV$2) . #1#)
      (LETT $ (GETREFV 101) . #1#)
      (QSETREFV $ 0 |dv$|)
      (QSETREFV $ 3
                (LETT |pv$|
                      (|buildPredVector| 0 0
                                         (LIST
                                          (AND (|HasCategory| |#1| '(|Finite|))
                                               (|HasCategory| |#2|
                                                              '(|Finite|)))
                                          (|HasCategory| |#1|
                                                         '(|CommutativeRing|))
                                          (|HasCategory| |#1|
                                                         '(|CharacteristicNonZero|))
                                          (|HasCategory| |#1|
                                                         '(|CharacteristicZero|))
                                          (|HasCategory| |#2|
                                                         '(|OrderedSet|))))
                      . #1#))
      (|haddProp| |$ConstructorCache| '|MonoidRing| (LIST DV$1 DV$2)
                  (CONS 1 $))
      (|stuffDomainSlots| $)
      (QSETREFV $ 6 |#1|)
      (QSETREFV $ 7 |#2|)
      (SETF |pv$| (QREFELT $ 3))
      (QSETREFV $ 8 (|List| (|Record| (|:| |coef| |#1|) (|:| |monom| |#2|))))
      (COND
       ((|HasCategory| |#1| '(|Finite|))
        (COND
         ((|HasCategory| |#2| '(|Finite|))
          (PROGN
           (QSETREFV $ 20 (CONS (|dispatchFunction| |MRING;size;Nni;3|) $))
           (QSETREFV $ 25 (CONS (|dispatchFunction| |MRING;index;Pi$;4|) $))
           (QSETREFV $ 30
                     (CONS (|dispatchFunction| |MRING;lookup;$Pi;5|) $)))))))
      (COND
       ((|HasCategory| |#1| '(|noZeroDivisors|))
        (QSETREFV $ 47 (CONS (|dispatchFunction| |MRING;*;R2$;15|) $)))
       ('T (QSETREFV $ 47 (CONS (|dispatchFunction| |MRING;*;R2$;16|) $))))
      (COND
       ((|HasCategory| |#1| '(|noZeroDivisors|))
        (QSETREFV $ 49 (CONS (|dispatchFunction| |MRING;*;I2$;17|) $)))
       ('T (QSETREFV $ 49 (CONS (|dispatchFunction| |MRING;*;I2$;18|) $))))
      (COND
       ((|HasCategory| |#1| '(|noZeroDivisors|))
        (COND
         ((|HasCategory| |#2| '(|Group|))
          (QSETREFV $ 61 (CONS (|dispatchFunction| |MRING;recip;$U;23|) $)))
         ('T
          (QSETREFV $ 61 (CONS (|dispatchFunction| |MRING;recip;$U;24|) $))))))
      (COND
       ((|testBitVector| |pv$| 5)
        (PROGN
         (QSETREFV $ 72
                   (CONS (|dispatchFunction| |MRING;leadingCoefficient;$R;27|)
                         $))
         (QSETREFV $ 73
                   (CONS (|dispatchFunction| |MRING;leadingMonomial;$M;28|) $))
         (QSETREFV $ 74 (CONS (|dispatchFunction| |MRING;reductum;2$;29|) $))
         (QSETREFV $ 75 (CONS (|dispatchFunction| |MRING;=;2$B;30|) $))
         (QSETREFV $ 24 (CONS (|dispatchFunction| |MRING;+;3$;31|) $))
         (QSETREFV $ 82
                   (CONS (|dispatchFunction| |MRING;coefficient;$MR;32|) $))
         (COND
          ((|HasCategory| |#2| '(|OrderedMonoid|))
           (COND
            ((|HasCategory| |#1| '(|noZeroDivisors|))
             (QSETREFV $ 84 (CONS (|dispatchFunction| |MRING;*;3$;33|) $)))
            ('T
             (QSETREFV $ 84 (CONS (|dispatchFunction| |MRING;*;3$;34|) $)))))
          ('T
           (PROGN
            (COND
             ((|HasCategory| |#1| '(|noZeroDivisors|))
              (QSETREFV $ 84 (CONS (|dispatchFunction| |MRING;*;3$;37|) $)))
             ('T
              (QSETREFV $ 84
                        (CONS (|dispatchFunction| |MRING;*;3$;38|) $)))))))))
       ('T
        (PROGN
         (QSETREFV $ 75 (CONS (|dispatchFunction| |MRING;=;2$B;39|) $))
         (QSETREFV $ 82
                   (CONS (|dispatchFunction| |MRING;coefficient;$MR;40|) $))
         (QSETREFV $ 24 (CONS (|dispatchFunction| |MRING;+;3$;42|) $))
         (QSETREFV $ 84 (CONS (|dispatchFunction| |MRING;*;3$;43|) $)))))
      $)))) 

(MAKEPROP '|MonoidRing| '|infovec|
          (LIST
           '#(NIL NIL NIL NIL NIL NIL (|local| |#1|) (|local| |#2|) '|Rep|
              (|Record| (|:| |coef| 6) (|:| |monom| 7)) (|List| 9)
              |MRING;coerce;L$;1|
              (CONS IDENTITY (FUNCALL (|dispatchFunction| |MRING;Zero;$;6|) $))
              (0 . |Zero|) (|Boolean|) (4 . =) |MRING;monomial;RM$;2|
              (|NonNegativeInteger|) (10 . |size|) (14 . |size|) (18 . |size|)
              (|PositiveInteger|) (22 . |index|) (27 . |index|) (32 . +)
              (38 . |index|) (43 . |zero?|) |MRING;terms;$L;8| (48 . |lookup|)
              (53 . |lookup|) (58 . |lookup|)
              (CONS IDENTITY (FUNCALL (|dispatchFunction| |MRING;One;$;7|) $))
              (63 . |One|) (67 . |One|) (71 . |copy|) (|List| $)
              |MRING;monomials;$L;9| (|List| 6) |MRING;coefficients;$L;10|
              |MRING;coerce;M$;11| |MRING;coerce;R$;12| (|Integer|)
              (76 . |coerce|) |MRING;coerce;I$;13| (81 . -) |MRING;-;2$;14|
              (86 . *) (92 . *) (98 . *) (104 . *) (|Mapping| 6 6)
              |MRING;map;M2$;19| |MRING;numberOfMonomials;$Nni;20|
              (|Union| 7 '"failed") |MRING;retractIfCan;$U;21| (110 . =)
              (|Union| 6 '"failed") |MRING;retractIfCan;$U;22|
              (|Union| $ '"failed") (116 . |recip|) (121 . |inv|)
              (126 . |recip|) (|OutputForm|) (131 . |coerce|) (136 . |coerce|)
              (141 . *) (147 . |coerce|) (152 . +) (|Mapping| 62 62 62)
              (|List| 62) (158 . |reduce|) |MRING;coerce;$Of;26|
              (164 . |leadingCoefficient|) (169 . |leadingMonomial|)
              (174 . |reductum|) (179 . =) (185 . <) (191 . |concat!|)
              (197 . +) (203 . |zero?|) (208 . |concat|) (214 . |concat!|)
              (220 . |coefficient|) (226 . *) (232 . *) (|Mapping| 14 9 9)
              (238 . |sort|) (|Set| 9) (244 . |brace|) (249 . =)
              (|AssociationList| 7 6) (255 . |search|) (261 . |setelt|)
              (268 . |remove!|) (274 . |table|) (|List| 7) (278 . |keys|)
              (283 . |elt|) (|InputForm|) (|String|) (|SingleInteger|))
           '#(~= 289 |zero?| 295 |terms| 300 |subtractIfCan| 305 |size| 311
              |sample| 315 |retractIfCan| 319 |retract| 329 |reductum| 339
              |recip| 344 |random| 349 |one?| 353 |numberOfMonomials| 358
              |monomials| 363 |monomial?| 368 |monomial| 373 |map| 379 |lookup|
              385 |leadingMonomial| 390 |leadingCoefficient| 395 |latex| 400
              |index| 405 |hash| 410 |enumerate| 415 |convert| 419 |coerce| 424
              |coefficients| 449 |coefficient| 454 |charthRoot| 460
              |characteristic| 465 ^ 469 |Zero| 481 |One| 485 = 489 - 495 + 506
              * 512)
           'NIL
           (CONS
            (|makeByteWordVec2| 4
                                '(0 2 2 3 4 0 2 0 0 2 2 0 0 0 0 0 0 0 0 1 0 0 0
                                  0 0 0 1))
            (CONS
             '#(NIL |Algebra&| |Module&| NIL NIL |Ring&| NIL NIL NIL NIL NIL
                |AbelianGroup&| NIL NIL |AbelianMonoid&| |Monoid&| NIL
                |SemiGroup&| |AbelianSemiGroup&| |Finite&| |SetCategory&|
                |RetractableTo&| |RetractableTo&| NIL |BasicType&| NIL NIL)
             (CONS
              '#((|MonoidRingCategory| 6 7) (|Algebra| 6) (|Module| 6)
                 (|CharacteristicNonZero|) (|CharacteristicZero|) (|Ring|)
                 (|BiModule| 6 6) (|Rng|) (|LeftModule| $$) (|LeftModule| 6)
                 (|RightModule| 6) (|AbelianGroup|)
                 (|CancellationAbelianMonoid|) (|SemiRing|) (|AbelianMonoid|)
                 (|Monoid|) (|SemiRng|) (|SemiGroup|) (|AbelianSemiGroup|)
                 (|Finite|) (|SetCategory|) (|RetractableTo| 6)
                 (|RetractableTo| 7) (|unitsKnown|) (|BasicType|)
                 (|CoercibleTo| 62) (|ConvertibleTo| 98))
              (|makeByteWordVec2| 100
                                  '(0 6 0 13 2 6 14 0 0 15 0 6 17 18 0 7 17 19
                                    0 0 17 20 1 6 0 21 22 1 7 0 21 23 2 0 0 0 0
                                    24 1 0 0 21 25 1 0 14 0 26 1 7 21 0 28 1 6
                                    21 0 29 1 0 21 0 30 0 6 0 32 0 7 0 33 1 8 0
                                    0 34 1 6 0 41 42 1 6 0 0 44 2 6 0 0 0 46 2
                                    0 0 6 0 47 2 6 0 41 0 48 2 0 0 41 0 49 2 7
                                    14 0 0 55 1 6 58 0 59 1 7 0 0 60 1 0 58 0
                                    61 1 7 62 0 63 1 6 62 0 64 2 62 0 0 0 65 1
                                    41 62 0 66 2 62 0 0 0 67 2 69 62 68 0 70 1
                                    0 6 0 72 1 0 7 0 73 1 0 0 0 74 2 0 14 0 0
                                    75 2 7 14 0 0 76 2 8 0 0 9 77 2 6 0 0 0 78
                                    1 6 14 0 79 2 8 0 0 0 80 2 8 0 0 0 81 2 0 6
                                    0 7 82 2 7 0 0 0 83 2 0 0 0 0 84 2 10 0 85
                                    0 86 1 87 0 10 88 2 87 14 0 0 89 2 90 56 7
                                    0 91 3 90 6 0 7 6 92 2 90 56 7 0 93 0 90 0
                                    94 1 90 95 0 96 2 90 6 0 7 97 2 0 14 0 0 1
                                    1 0 14 0 26 1 0 10 0 27 2 0 58 0 0 1 0 1 17
                                    20 0 0 0 1 1 0 56 0 57 1 0 53 0 54 1 0 6 0
                                    1 1 0 7 0 1 1 5 0 0 74 1 0 58 0 61 0 1 0 1
                                    1 0 14 0 1 1 0 17 0 52 1 0 35 0 36 1 0 14 0
                                    1 2 0 0 6 7 16 2 0 0 50 0 51 1 1 21 0 30 1
                                    5 7 0 73 1 5 6 0 72 1 0 99 0 1 1 1 0 21 25
                                    1 0 100 0 1 0 1 35 1 1 1 98 0 1 1 0 0 10 11
                                    1 0 0 6 40 1 0 0 41 43 1 0 0 7 39 1 0 62 0
                                    71 1 0 37 0 38 2 0 6 0 7 82 1 3 58 0 1 0 0
                                    17 1 2 0 0 0 17 1 2 0 0 0 21 1 0 0 0 12 0 0
                                    0 31 2 0 14 0 0 75 2 0 0 0 0 1 1 0 0 0 45 2
                                    0 0 0 0 24 2 2 0 6 0 47 2 2 0 0 6 1 2 0 0 0
                                    0 84 2 0 0 41 0 49 2 0 0 17 0 1 2 0 0 21 0
                                    1)))))
           '|lookupComplete|)) 
