
(/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=#:G1850 |c| #2=#:G1849 |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=#:G1862 |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|)))))))) 

(DEFUN |MRING;random;$;6| ($)
  (PROG (#1=#:G1864)
    (RETURN
     (SPADCALL
      (PROG1
          (LETT #1# (+ (RANDOM (SPADCALL (QREFELT $ 20))) 1)
                |MRING;random;$;6|)
        (|check-subtype| (> #1# 0) '(|PositiveInteger|) #1#))
      (QREFELT $ 25))))) 

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

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

(DEFUN |MRING;One;$;8| ($)
  (LIST (CONS (|spadConstant| $ 33) (|spadConstant| $ 34)))) 

(DEFUN |MRING;terms;$L;9| (|a| $) (SPADCALL |a| (QREFELT $ 35))) 

(DEFUN |MRING;monomials;$L;10| (|a| $)
  (PROG (#1=#:G1875 |t| #2=#:G1874)
    (RETURN
     (SEQ
      (PROGN
       (LETT #2# NIL . #3=(|MRING;monomials;$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 (LIST |t|) #2#) . #3#)))
            (LETT #1# (CDR #1#) . #3#) (GO G190) G191
            (EXIT (NREVERSE0 #2#)))))))) 

(DEFUN |MRING;coefficients;$L;11| (|a| $)
  (PROG (#1=#:G1880 |t| #2=#:G1879)
    (RETURN
     (SEQ
      (PROGN
       (LETT #2# NIL . #3=(|MRING;coefficients;$L;11|))
       (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$;12| (|m| $) (LIST (CONS (|spadConstant| $ 33) |m|))) 

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

(DEFUN |MRING;coerce;I$;14| (|n| $)
  (COND ((EQL |n| 0) (|spadConstant| $ 12))
        ('T (LIST (CONS (SPADCALL |n| (QREFELT $ 43)) (|spadConstant| $ 34)))))) 

(DEFUN |MRING;-;2$;15| (|a| $)
  (PROG (#1=#:G1891 |t| #2=#:G1890)
    (RETURN
     (SEQ
      (PROGN
       (LETT #2# NIL . #3=(|MRING;-;2$;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 (QCAR |t|) (QREFELT $ 45)) (QCDR |t|))
                     #2#)
                    . #3#)))
            (LETT #1# (CDR #1#) . #3#) (GO G190) G191
            (EXIT (NREVERSE0 #2#)))))))) 

(DEFUN |MRING;*;R2$;16| (|r| |a| $)
  (PROG (#1=#:G1896 |t| #2=#:G1895)
    (RETURN
     (SEQ
      (COND
       ((SPADCALL |r| (|spadConstant| $ 13) (QREFELT $ 15))
        (|spadConstant| $ 12))
       ('T
        (PROGN
         (LETT #2# NIL . #3=(|MRING;*;R2$;16|))
         (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 $ 47))
                             (QCDR |t|))
                       #2#)
                      . #3#)))
              (LETT #1# (CDR #1#) . #3#) (GO G190) G191
              (EXIT (NREVERSE0 #2#)))))))))) 

(DEFUN |MRING;*;R2$;17| (|r| |a| $)
  (PROG (|rt| #1=#:G1902 |t| #2=#:G1901)
    (RETURN
     (SEQ
      (COND
       ((SPADCALL |r| (|spadConstant| $ 13) (QREFELT $ 15))
        (|spadConstant| $ 12))
       (#3='T
        (PROGN
         (LETT #2# NIL . #4=(|MRING;*;R2$;17|))
         (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 $ 47)) . #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$;18| (|n| |a| $)
  (PROG (#1=#:G1907 |t| #2=#:G1906)
    (RETURN
     (SEQ
      (COND ((EQL |n| 0) (|spadConstant| $ 12))
            ('T
             (PROGN
              (LETT #2# NIL . #3=(|MRING;*;I2$;18|))
              (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 $ 49))
                                  (QCDR |t|))
                            #2#)
                           . #3#)))
                   (LETT #1# (CDR #1#) . #3#) (GO G190) G191
                   (EXIT (NREVERSE0 #2#)))))))))) 

(DEFUN |MRING;*;I2$;19| (|n| |a| $)
  (PROG (|nt| #1=#:G1913 |t| #2=#:G1912)
    (RETURN
     (SEQ
      (COND ((EQL |n| 0) (|spadConstant| $ 12))
            (#3='T
             (PROGN
              (LETT #2# NIL . #4=(|MRING;*;I2$;19|))
              (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 $ 49))
                              . #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$;20| (|f| |a| $)
  (PROG (|ft| #1=#:G1920 |t| #2=#:G1919)
    (RETURN
     (SEQ
      (PROGN
       (LETT #2# NIL . #3=(|MRING;map;M2$;20|))
       (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;21| '|SPADreplace| 'LENGTH) 

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

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

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

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

(DEFUN |MRING;recip;$U;25| (|a| $)
  (PROG (|u|)
    (RETURN
     (SEQ
      (COND
       ((EQL (LENGTH |a|) 1)
        (COND
         ((NULL
           (SPADCALL (QCDR (|SPADfirst| |a|)) (|spadConstant| $ 34)
                     (QREFELT $ 56)))
          (EXIT (CONS 1 #1="failed")))))
       (#2='T (EXIT (CONS 1 #1#))))
      (LETT |u| (SPADCALL (QCAR (|SPADfirst| |a|)) (QREFELT $ 60))
            |MRING;recip;$U;25|)
      (EXIT
       (COND ((QEQCAR |u| 1) (CONS 1 "failed"))
             (#2# (CONS 0 (SPADCALL (QCDR |u|) (QREFELT $ 41)))))))))) 

(DEFUN |MRING;mkTerm| (|r| |m| $)
  (COND
   ((SPADCALL |r| (|spadConstant| $ 33) (QREFELT $ 15))
    (SPADCALL |m| (QREFELT $ 64)))
   ((OR (SPADCALL |r| (|spadConstant| $ 13) (QREFELT $ 15))
        (SPADCALL |m| (|spadConstant| $ 34) (QREFELT $ 56)))
    (SPADCALL |r| (QREFELT $ 65)))
   ('T
    (SPADCALL (SPADCALL |r| (QREFELT $ 65)) (SPADCALL |m| (QREFELT $ 64))
              (QREFELT $ 66))))) 

(DEFUN |MRING;coerce;$Of;27| (|a| $)
  (PROG (#1=#:G1979 |t| #2=#:G1978)
    (RETURN
     (SEQ
      (COND ((NULL |a|) (SPADCALL 0 (QREFELT $ 67)))
            ((NULL (CDR |a|))
             (|MRING;mkTerm| (QCAR (|SPADfirst| |a|)) (QCDR (|SPADfirst| |a|))
              $))
            ('T
             (SPADCALL (ELT $ 68)
                       (PROGN
                        (LETT #2# NIL . #3=(|MRING;coerce;$Of;27|))
                        (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 $ 71)))))))) 

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

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

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

(DEFUN |MRING;=;2$B;31| (|a| |b| $)
  (PROG (#1=#:G1992 #2=#:G1994 #3=#:G1995 |ta| #4=#:G1996 |tb|)
    (RETURN
     (SEQ
      (EXIT
       (COND ((NULL (EQL (LENGTH |a|) (LENGTH |b|))) 'NIL)
             ('T
              (SEQ
               (SEQ
                (EXIT
                 (SEQ (LETT |tb| NIL . #5=(|MRING;=;2$B;31|))
                      (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 $ 56)))
                            (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$;32| (|a| |b| $)
  (PROG (|c| |r| |rb| |ra| |tb| |ta|)
    (RETURN
     (SEQ (LETT |c| NIL . #1=(|MRING;+;3$;32|))
          (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 $ 77))
                             (SEQ (LETT |a| |ra| . #1#)
                                  (EXIT (SPADCALL |c| |ta| (QREFELT $ 78)))))
                            ((SPADCALL (QCDR |ta|) (QCDR |tb|) (QREFELT $ 77))
                             (SEQ (LETT |b| |rb| . #1#)
                                  (EXIT (SPADCALL |c| |tb| (QREFELT $ 78)))))
                            ('T
                             (SEQ (LETT |a| |ra| . #1#) (LETT |b| |rb| . #1#)
                                  (COND
                                   ((NULL
                                     (SPADCALL
                                      (LETT |r|
                                            (SPADCALL (QCAR |ta|) (QCAR |tb|)
                                                      (QREFELT $ 79))
                                            . #1#)
                                      (QREFELT $ 80)))
                                    (EXIT
                                     (SPADCALL |c| (CONS |r| (QCDR |ta|))
                                               (QREFELT $ 78)))))
                                  (EXIT |c|))))
                           . #1#)))
               NIL (GO G190) G191 (EXIT NIL))
          (EXIT
           (SPADCALL |c| (SPADCALL |a| |b| (QREFELT $ 81)) (QREFELT $ 82))))))) 

(DEFUN |MRING;coefficient;$MR;33| (|a| |m| $)
  (PROG (#1=#:G2023 #2=#:G2024 |t|)
    (RETURN
     (SEQ
      (EXIT
       (SEQ
        (SEQ (LETT |t| NIL . #3=(|MRING;coefficient;$MR;33|))
             (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 $ 56))
                (PROGN (LETT #1# (QCAR |t|) . #3#) (GO #1#))))
              (EXIT
               (COND
                ((SPADCALL (QCDR |t|) |m| (QREFELT $ 77))
                 (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$;34| (|a| |b| $)
  (PROG (#1=#:G2027 #2=#:G2026 #3=#:G2028 #4=#:G2033 |tb| #5=#:G2032 #6=#:G2031
         |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
                             (LETT #5#
                                   (CONS
                                    (CONS
                                     (SPADCALL (QCAR |ta|) (QCAR |tb|)
                                               (QREFELT $ 47))
                                     (SPADCALL (QCDR |ta|) (QCDR |tb|)
                                               (QREFELT $ 84)))
                                    #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$;35| (|a| |b| $)
  (PROG (#1=#:G2036 #2=#:G2035 #3=#:G2037 |r| #4=#:G2043 |tb| #5=#:G2042
         #6=#:G2041 |ta|)
    (RETURN
     (SEQ
      (PROGN
       (LETT #1# NIL . #7=(|MRING;*;3$;35|))
       (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 $ 47))
                                        . #7#)
                                  (QREFELT $ 80))
                                 'NIL)
                                ('T 'T))
                               (LETT #5#
                                     (CONS
                                      (CONS |r|
                                            (SPADCALL (QCDR |ta|) (QCDR |tb|)
                                                      (QREFELT $ 84)))
                                      #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 $ 77)) 'NIL) ('T 'T))) 

(DEFUN |MRING;sortAndAdd| (|liTe| $)
  (PROG (|res| |cf| |m| #1=#:G2058 |te|)
    (RETURN
     (SEQ
      (LETT |liTe|
            (SPADCALL (CONS (|function| |MRING;ge|) $) |liTe| (QREFELT $ 87))
            . #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 $ 56))
               (LETT |cf| (SPADCALL |cf| (QCAR |te|) (QREFELT $ 79)) . #2#))
              ('T
               (SEQ
                (COND
                 ((NULL (SPADCALL |cf| (QREFELT $ 80)))
                  (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 $ 80)))
        (LETT |res| (CONS (CONS |cf| |m|) |res|) . #2#)))
      (EXIT (REVERSE |res|)))))) 

(DEFUN |MRING;*;3$;38| (|a| |b| $)
  (PROG (#1=#:G2061 #2=#:G2060 #3=#:G2062 #4=#:G2073 |tb| #5=#:G2072 #6=#:G2071
         |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
                                     (LETT #5#
                                           (CONS
                                            (CONS
                                             (SPADCALL (QCAR |ta|) (QCAR |tb|)
                                                       (QREFELT $ 47))
                                             (SPADCALL (QCDR |ta|) (QCDR |tb|)
                                                       (QREFELT $ 84)))
                                            #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$;39| (|a| |b| $)
  (PROG (#1=#:G2076 #2=#:G2075 #3=#:G2077 |r| #4=#:G2093 |tb| #5=#:G2092
         #6=#:G2091 |ta|)
    (RETURN
     (SEQ
      (COND ((SPADCALL |a| (QREFELT $ 26)) |a|)
            ((SPADCALL |b| (QREFELT $ 26)) |b|)
            (#7='T
             (PROGN
              (LETT #1# NIL . #8=(|MRING;*;3$;39|))
              (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 $ 47))
                                                . #8#)
                                          (QREFELT $ 80))
                                         'NIL)
                                        ('T 'T))
                                       (LETT #5#
                                             (CONS
                                              (CONS |r|
                                                    (SPADCALL (QCDR |ta|)
                                                              (QCDR |tb|)
                                                              (QREFELT $ 84)))
                                              #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;40| (|a| |b| $)
  (COND ((NULL (EQL (LENGTH |a|) (LENGTH |b|))) 'NIL)
        ('T
         (SPADCALL (SPADCALL |a| (QREFELT $ 89)) (SPADCALL |b| (QREFELT $ 89))
                   (QREFELT $ 90))))) 

(DEFUN |MRING;coefficient;$MR;41| (|a| |m| $)
  (PROG (#1=#:G2101 #2=#:G2103 #3=#:G2104 |t|)
    (RETURN
     (SEQ
      (EXIT
       (SEQ
        (SEQ
         (EXIT
          (SEQ (LETT |t| NIL . #4=(|MRING;coefficient;$MR;41|))
               (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 $ 56))
                   (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 $ 92)) . #1=(|MRING;addterm|))
      (EXIT
       (COND
        ((OR (QEQCAR |u| 1)
             (NULL
              (SPADCALL
               (LETT |r| (SPADCALL |r| (QCDR |u|) (QREFELT $ 79)) . #1#)
               (QREFELT $ 80))))
         (SPADCALL |Tabl| |m| |r| (QREFELT $ 93)))
        ('T
         (SEQ (SPADCALL |m| |Tabl| (QREFELT $ 94))
              (EXIT (|spadConstant| $ 13)))))))))) 

(DEFUN |MRING;+;3$;43| (|a| |b| $)
  (PROG (#1=#:G2128 |m| #2=#:G2127 #3=#:G2126 |t| #4=#:G2125 |Tabl|)
    (RETURN
     (SEQ (LETT |Tabl| (SPADCALL (QREFELT $ 95)) . #5=(|MRING;+;3$;43|))
          (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 $ 93))))
               (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 $ 97)) . #5#) G190
                 (COND
                  ((OR (ATOM #1#) (PROGN (LETT |m| (CAR #1#) . #5#) NIL)) #6#))
                 (SEQ
                  (EXIT
                   (LETT #2#
                         (CONS (CONS (SPADCALL |Tabl| |m| (QREFELT $ 98)) |m|)
                               #2#)
                         . #5#)))
                 (LETT #1# (CDR #1#) . #5#) #7# G191
                 (EXIT (NREVERSE0 #2#))))))))) 

(DEFUN |MRING;*;3$;44| (|a| |b| $)
  (PROG (#1=#:G2138 |m| #2=#:G2137 #3=#:G2136 |tb| #4=#:G2135 |ta| |Tabl|)
    (RETURN
     (SEQ (LETT |Tabl| (SPADCALL (QREFELT $ 95)) . #5=(|MRING;*;3$;44|))
          (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 $ 47))
                         (SPADCALL (QCDR |ta|) (QCDR |tb|) (QREFELT $ 84)) $)))
                      (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 $ 97)) . #5#) G190
                 (COND
                  ((OR (ATOM #1#) (PROGN (LETT |m| (CAR #1#) . #5#) NIL)) #6#))
                 (SEQ
                  (EXIT
                   (LETT #2#
                         (CONS (CONS (SPADCALL |Tabl| |m| (QREFELT $ 98)) |m|)
                               #2#)
                         . #5#)))
                 (LETT #1# (CDR #1#) . #5#) #7# G191
                 (EXIT (NREVERSE0 #2#))))))))) 

(DEFUN |MonoidRing| (&REST #1=#:G2139)
  (PROG ()
    (RETURN
     (PROG (#2=#:G2140)
       (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|)
      (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|) $))
           (QSETREFV $ 32
                     (CONS (|dispatchFunction| |MRING;random;$;6|) $)))))))
      (COND
       ((|HasCategory| |#1| '(|noZeroDivisors|))
        (QSETREFV $ 48 (CONS (|dispatchFunction| |MRING;*;R2$;16|) $)))
       ('T (QSETREFV $ 48 (CONS (|dispatchFunction| |MRING;*;R2$;17|) $))))
      (COND
       ((|HasCategory| |#1| '(|noZeroDivisors|))
        (QSETREFV $ 50 (CONS (|dispatchFunction| |MRING;*;I2$;18|) $)))
       ('T (QSETREFV $ 50 (CONS (|dispatchFunction| |MRING;*;I2$;19|) $))))
      (COND
       ((|HasCategory| |#1| '(|noZeroDivisors|))
        (COND
         ((|HasCategory| |#2| '(|Group|))
          (QSETREFV $ 62 (CONS (|dispatchFunction| |MRING;recip;$U;24|) $)))
         ('T
          (QSETREFV $ 62 (CONS (|dispatchFunction| |MRING;recip;$U;25|) $))))))
      (COND
       ((|testBitVector| |pv$| 5)
        (PROGN
         (QSETREFV $ 73
                   (CONS (|dispatchFunction| |MRING;leadingCoefficient;$R;28|)
                         $))
         (QSETREFV $ 74
                   (CONS (|dispatchFunction| |MRING;leadingMonomial;$M;29|) $))
         (QSETREFV $ 75 (CONS (|dispatchFunction| |MRING;reductum;2$;30|) $))
         (QSETREFV $ 76 (CONS (|dispatchFunction| |MRING;=;2$B;31|) $))
         (QSETREFV $ 24 (CONS (|dispatchFunction| |MRING;+;3$;32|) $))
         (QSETREFV $ 83
                   (CONS (|dispatchFunction| |MRING;coefficient;$MR;33|) $))
         (COND
          ((|HasCategory| |#2| '(|OrderedMonoid|))
           (COND
            ((|HasCategory| |#1| '(|noZeroDivisors|))
             (QSETREFV $ 85 (CONS (|dispatchFunction| |MRING;*;3$;34|) $)))
            ('T
             (QSETREFV $ 85 (CONS (|dispatchFunction| |MRING;*;3$;35|) $)))))
          ('T
           (PROGN
            (COND
             ((|HasCategory| |#1| '(|noZeroDivisors|))
              (QSETREFV $ 85 (CONS (|dispatchFunction| |MRING;*;3$;38|) $)))
             ('T
              (QSETREFV $ 85
                        (CONS (|dispatchFunction| |MRING;*;3$;39|) $)))))))))
       ('T
        (PROGN
         (QSETREFV $ 76 (CONS (|dispatchFunction| |MRING;=;2$B;40|) $))
         (QSETREFV $ 83
                   (CONS (|dispatchFunction| |MRING;coefficient;$MR;41|) $))
         (QSETREFV $ 24 (CONS (|dispatchFunction| |MRING;+;3$;43|) $))
         (QSETREFV $ 85 (CONS (|dispatchFunction| |MRING;*;3$;44|) $)))))
      $)))) 

(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;$;7|) $))
              (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;9| (48 . |lookup|)
              (53 . |lookup|) (58 . |lookup|)
              (CONS IDENTITY (FUNCALL (|dispatchFunction| |MRING;One;$;8|) $))
              (63 . |random|) (67 . |One|) (71 . |One|) (75 . |copy|)
              (|List| $) |MRING;monomials;$L;10| (|List| 6)
              |MRING;coefficients;$L;11| |MRING;coerce;M$;12|
              |MRING;coerce;R$;13| (|Integer|) (80 . |coerce|)
              |MRING;coerce;I$;14| (85 . -) |MRING;-;2$;15| (90 . *) (96 . *)
              (102 . *) (108 . *) (|Mapping| 6 6) |MRING;map;M2$;20|
              |MRING;numberOfMonomials;$Nni;21| (|Union| 7 '"failed")
              |MRING;retractIfCan;$U;22| (114 . =) (|Union| 6 '"failed")
              |MRING;retractIfCan;$U;23| (|Union| $ '"failed") (120 . |recip|)
              (125 . |inv|) (130 . |recip|) (|OutputForm|) (135 . |coerce|)
              (140 . |coerce|) (145 . *) (151 . |coerce|) (156 . +)
              (|Mapping| 63 63 63) (|List| 63) (162 . |reduce|)
              |MRING;coerce;$Of;27| (168 . |leadingCoefficient|)
              (173 . |leadingMonomial|) (178 . |reductum|) (183 . =) (189 . <)
              (195 . |concat!|) (201 . +) (207 . |zero?|) (212 . |concat|)
              (218 . |concat!|) (224 . |coefficient|) (230 . *) (236 . *)
              (|Mapping| 14 9 9) (242 . |sort|) (|Set| 9) (248 . |brace|)
              (253 . =) (|AssociationList| 7 6) (259 . |search|)
              (265 . |setelt|) (272 . |remove!|) (278 . |table|) (|List| 7)
              (282 . |keys|) (287 . |elt|) (|String|) (|SingleInteger|))
           '#(~= 293 |zero?| 299 |terms| 304 |subtractIfCan| 309 |size| 315
              |sample| 319 |retractIfCan| 323 |retract| 333 |reductum| 343
              |recip| 348 |random| 353 |one?| 357 |numberOfMonomials| 362
              |monomials| 367 |monomial?| 372 |monomial| 377 |map| 383 |lookup|
              389 |leadingMonomial| 394 |leadingCoefficient| 399 |latex| 404
              |index| 409 |hash| 414 |enumerate| 419 |coerce| 423
              |coefficients| 448 |coefficient| 453 |charthRoot| 459
              |characteristic| 464 ^ 468 |Zero| 480 |One| 484 = 488 - 494 + 505
              * 511)
           '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))
            (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)
             (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| 63))
              (|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 0 0 32 0 6 0 33 0 7 0
                                    34 1 8 0 0 35 1 6 0 42 43 1 6 0 0 45 2 6 0
                                    0 0 47 2 0 0 6 0 48 2 6 0 42 0 49 2 0 0 42
                                    0 50 2 7 14 0 0 56 1 6 59 0 60 1 7 0 0 61 1
                                    0 59 0 62 1 7 63 0 64 1 6 63 0 65 2 63 0 0
                                    0 66 1 42 63 0 67 2 63 0 0 0 68 2 70 63 69
                                    0 71 1 0 6 0 73 1 0 7 0 74 1 0 0 0 75 2 0
                                    14 0 0 76 2 7 14 0 0 77 2 8 0 0 9 78 2 6 0
                                    0 0 79 1 6 14 0 80 2 8 0 0 0 81 2 8 0 0 0
                                    82 2 0 6 0 7 83 2 7 0 0 0 84 2 0 0 0 0 85 2
                                    10 0 86 0 87 1 88 0 10 89 2 88 14 0 0 90 2
                                    91 57 7 0 92 3 91 6 0 7 6 93 2 91 57 7 0 94
                                    0 91 0 95 1 91 96 0 97 2 91 6 0 7 98 2 0 14
                                    0 0 1 1 0 14 0 26 1 0 10 0 27 2 0 59 0 0 1
                                    0 1 17 20 0 0 0 1 1 0 57 0 58 1 0 54 0 55 1
                                    0 6 0 1 1 0 7 0 1 1 5 0 0 75 1 0 59 0 62 0
                                    1 0 32 1 0 14 0 1 1 0 17 0 53 1 0 36 0 37 1
                                    0 14 0 1 2 0 0 6 7 16 2 0 0 51 0 52 1 1 21
                                    0 30 1 5 7 0 74 1 5 6 0 73 1 0 99 0 1 1 1 0
                                    21 25 1 0 100 0 1 0 1 36 1 1 0 0 10 11 1 0
                                    0 6 41 1 0 0 42 44 1 0 0 7 40 1 0 63 0 72 1
                                    0 38 0 39 2 0 6 0 7 83 1 3 59 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 76 2 0 0 0 0 1 1 0 0 0 46 2 0 0
                                    0 0 24 2 2 0 6 0 48 2 2 0 0 6 1 2 0 0 0 0
                                    85 2 0 0 42 0 50 2 0 0 17 0 1 2 0 0 21 0
                                    1)))))
           '|lookupComplete|)) 
