
(/VERSIONCHECK 2) 

(DEFUN |PR;One;$;1| ($)
  (LIST (CONS (|spadConstant| $ 10) (|spadConstant| $ 11)))) 

(DEFUN |PR;characteristic;Nni;2| ($) (SPADCALL (QREFELT $ 14))) 

(PUT '|PR;numberOfMonomials;$Nni;3| '|SPADreplace| 'LENGTH) 

(DEFUN |PR;numberOfMonomials;$Nni;3| (|x| $) (LENGTH |x|)) 

(DEFUN |PR;degree;$E;4| (|p| $)
  (COND ((NULL |p|) (|spadConstant| $ 10)) ('T (QCAR (|SPADfirst| |p|))))) 

(DEFUN |PR;minimumDegree;$E;5| (|p| $)
  (COND ((NULL |p|) (|spadConstant| $ 10))
        ('T (QCAR (SPADCALL |p| (QREFELT $ 19)))))) 

(DEFUN |PR;leadingCoefficient;$R;6| (|p| $)
  (COND ((NULL |p|) (|spadConstant| $ 21)) ('T (QCDR (|SPADfirst| |p|))))) 

(DEFUN |PR;leadingMonomial;2$;7| (|p| $)
  (COND ((NULL |p|) (|spadConstant| $ 23)) ('T (LIST (|SPADfirst| |p|))))) 

(DEFUN |PR;reductum;2$;8| (|p| $) (COND ((NULL |p|) |p|) ('T (CDR |p|)))) 

(DEFUN |PR;retractIfCan;$U;9| (|p| $)
  (COND ((NULL |p|) (CONS 0 (|spadConstant| $ 21)))
        ((NULL (NULL (CDR |p|))) (CONS 1 "failed"))
        ('T
         (COND
          ((SPADCALL (QCAR (|SPADfirst| |p|)) (QREFELT $ 27))
           (CONS 0 (QCDR (|SPADfirst| |p|))))
          ('T (CONS 1 "failed")))))) 

(DEFUN |PR;coefficient;$ER;10| (|p| |e| $)
  (PROG (#1=#:G1881 #2=#:G1886 #3=#:G1888 |tm| |ks| #4=#:G1887 |tms| |es| |ps|
         |degp|)
    (RETURN
     (SEQ
      (EXIT
       (COND ((NULL |p|) (|spadConstant| $ 21))
             (#5='T
              (SEQ
               (LETT |degp| (QCAR (|SPADfirst| |p|))
                     . #6=(|PR;coefficient;$ER;10|))
               (EXIT
                (COND
                 ((< |degp| MOST-POSITIVE-FIXNUM)
                  (COND
                   ((NULL (< |e| MOST-POSITIVE-FIXNUM)) (|spadConstant| $ 21))
                   ('T
                    (SEQ (LETT |ps| |p| . #6#) (LETT |es| |e| . #6#)
                         (SEQ (LETT |tms| NIL . #6#) (LETT #4# |ps| . #6#) G190
                              (COND
                               ((OR (ATOM #4#)
                                    (PROGN (LETT |tms| (CAR #4#) . #6#) NIL))
                                #7=(GO G191)))
                              (SEQ (LETT |ks| (QCAR |tms|) . #6#)
                                   (EXIT
                                    (COND
                                     ((EQL |ks| |es|)
                                      (PROGN
                                       (LETT #2# (QCDR |tms|) . #6#)
                                       (GO #2#)))
                                     ((QSLESSP |ks| |es|)
                                      (PROGN
                                       (LETT #2# (|spadConstant| $ 21) . #6#)
                                       (GO #2#))))))
                              (LETT #4# (CDR #4#) . #6#) #8=(GO G190) G191
                              (EXIT NIL))
                         (EXIT
                          (PROGN
                           (LETT #2# (|spadConstant| $ 21) . #6#)
                           (GO #2#)))))))
                 (#5#
                  (SEQ
                   (SEQ (LETT |tm| NIL . #6#) (LETT #3# |p| . #6#) G190
                        (COND
                         ((OR (ATOM #3#)
                              (PROGN (LETT |tm| (CAR #3#) . #6#) NIL))
                          #7#))
                        (SEQ
                         (EXIT
                          (COND
                           ((EQL (QCAR |tm|) |e|)
                            (PROGN (LETT #2# (QCDR |tm|) . #6#) (GO #2#)))
                           ('T
                            (SEQ
                             (EXIT
                              (COND
                               ((< (QCAR |tm|) |e|)
                                (PROGN
                                 (LETT #1#
                                       (PROGN
                                        (LETT #2# (|spadConstant| $ 21) . #6#)
                                        (GO #2#))
                                       . #6#)
                                 (GO #1#)))))
                             #1# (EXIT #1#))))))
                        (LETT #3# (CDR #3#) . #6#) #8# G191 (EXIT NIL))
                   (EXIT (|spadConstant| $ 21))))))))))
      #2# (EXIT #2#))))) 

(DEFUN |PR;coefficient;$ER;11| (|p| |e| $)
  (PROG (#1=#:G1890 #2=#:G1894 #3=#:G1895 |tm|)
    (RETURN
     (SEQ
      (EXIT
       (SEQ
        (SEQ (LETT |tm| NIL . #4=(|PR;coefficient;$ER;11|))
             (LETT #3# |p| . #4#) G190
             (COND
              ((OR (ATOM #3#) (PROGN (LETT |tm| (CAR #3#) . #4#) NIL))
               (GO G191)))
             (SEQ
              (EXIT
               (COND
                ((SPADCALL (QCAR |tm|) |e| (QREFELT $ 31))
                 (PROGN (LETT #2# (QCDR |tm|) . #4#) (GO #2#)))
                ('T
                 (SEQ
                  (EXIT
                   (COND
                    ((SPADCALL (QCAR |tm|) |e| (QREFELT $ 32))
                     (PROGN
                      (LETT #1#
                            (PROGN
                             (LETT #2# (|spadConstant| $ 21) . #4#)
                             (GO #2#))
                            . #4#)
                      (GO #1#)))))
                  #1# (EXIT #1#))))))
             (LETT #3# (CDR #3#) . #4#) (GO G190) G191 (EXIT NIL))
        (EXIT (|spadConstant| $ 21))))
      #2# (EXIT #2#))))) 

(DEFUN |PR;recip;$U;12| (|p| $)
  (PROG (|u|)
    (RETURN
     (SEQ
      (COND
       ((OR (NULL |p|)
            (SPADCALL (|spadConstant| $ 10) (QCAR (|SPADfirst| |p|))
                      (QREFELT $ 32)))
        (CONS 1 "failed"))
       ('T
        (SEQ
         (LETT |u| (SPADCALL (QCDR (|SPADfirst| |p|)) (QREFELT $ 34))
               |PR;recip;$U;12|)
         (EXIT
          (COND ((QEQCAR |u| 1) (CONS 1 "failed"))
                ('T (CONS 0 (SPADCALL (QCDR |u|) (QREFELT $ 35))))))))))))) 

(DEFUN |PR;coerce;R$;13| (|r| $)
  (COND ((SPADCALL |r| (QREFELT $ 37)) (|spadConstant| $ 23))
        ('T (LIST (CONS (|spadConstant| $ 10) |r|))))) 

(DEFUN |PR;coerce;I$;14| (|n| $)
  (SPADCALL (SPADCALL |n| (QREFELT $ 39)) (QREFELT $ 35))) 

(DEFUN |PR;ground?;$B;15| (|p| $)
  (COND ((NULL |p|) 'T)
        ((NULL (CDR |p|))
         (SPADCALL (SPADCALL |p| (QREFELT $ 17)) (QREFELT $ 27)))
        ('T 'NIL))) 

(DEFUN |PR;times!| (|r| |x| $)
  (PROG (|endcell| |res| |xx| |newend| |tx| #1=#:G1930)
    (RETURN
     (SEQ
      (COND
       ((QREFELT $ 42)
        (SEQ
         (SEQ (LETT |tx| NIL . #2=(|PR;times!|)) (LETT #1# |x| . #2#) G190
              (COND
               ((OR (ATOM #1#) (PROGN (LETT |tx| (CAR #1#) . #2#) NIL))
                #3=(GO G191)))
              (SEQ
               (EXIT
                (PROGN
                 (RPLACD |tx| (SPADCALL |r| (QCDR |tx|) (QREFELT $ 43)))
                 (QCDR |tx|))))
              (LETT #1# (CDR #1#) . #2#) #4=(GO G190) G191 (EXIT NIL))
         (EXIT |x|)))
       ('T
        (SEQ (LETT |xx| |x| . #2#) (LETT |res| NIL . #2#)
             (SEQ G190 (COND ((NULL (COND ((NULL |xx|) 'NIL) ('T 'T))) #3#))
                  (SEQ (LETT |tx| (|SPADfirst| |xx|) . #2#)
                       (PROGN
                        (RPLACD |tx| (SPADCALL |r| (QCDR |tx|) (QREFELT $ 43)))
                        (QCDR |tx|))
                       (EXIT
                        (COND
                         ((SPADCALL (QCDR |tx|) (QREFELT $ 37))
                          (LETT |xx| (CDR |xx|) . #2#))
                         ('T
                          (SEQ (LETT |newend| |xx| . #2#)
                               (LETT |xx| (CDR |xx|) . #2#)
                               (EXIT
                                (COND
                                 ((NULL |res|)
                                  (SEQ (LETT |res| |newend| . #2#)
                                       (EXIT (LETT |endcell| |res| . #2#))))
                                 ('T
                                  (SEQ (RPLACD |endcell| |newend|)
                                       (EXIT
                                        (LETT |endcell| |newend|
                                              . #2#)))))))))))
                  NIL #4# G191 (EXIT NIL))
             (EXIT |res|)))))))) 

(DEFUN |PR;termTimes| (|r| |e| |tx| $)
  (CONS (SPADCALL |e| (QCAR |tx|) (QREFELT $ 44))
        (SPADCALL |r| (QCDR |tx|) (QREFELT $ 43)))) 

(DEFUN |PR;times| (|tco| |tex| |rx| $)
  (PROG (|r| #1=#:G1939 |tx| #2=#:G1938)
    (RETURN
     (SEQ
      (COND
       ((QREFELT $ 42)
        (SPADCALL (CONS #'|PR;times!0| (VECTOR $ |tex| |tco|)) |rx|
                  (QREFELT $ 46)))
       (#3='T
        (PROGN
         (LETT #2# NIL . #4=(|PR;times|))
         (SEQ (LETT |tx| NIL . #4#) (LETT #1# |rx| . #4#) G190
              (COND
               ((OR (ATOM #1#) (PROGN (LETT |tx| (CAR #1#) . #4#) NIL))
                (GO G191)))
              (SEQ
               (EXIT
                (COND
                 ((COND
                   ((SPADCALL
                     (LETT |r| (SPADCALL |tco| (QCDR |tx|) (QREFELT $ 43))
                           . #4#)
                     (QREFELT $ 37))
                    'NIL)
                   (#3# 'T))
                  (LETT #2#
                        (CONS
                         (CONS (SPADCALL |tex| (QCAR |tx|) (QREFELT $ 44)) |r|)
                         #2#)
                        . #4#)))))
              (LETT #1# (CDR #1#) . #4#) (GO G190) G191
              (EXIT (NREVERSE0 #2#)))))))))) 

(DEFUN |PR;times!0| (|x1| $$)
  (PROG (|tco| |tex| $)
    (LETT |tco| (QREFELT $$ 2) . #1=(|PR;times|))
    (LETT |tex| (QREFELT $$ 1) . #1#)
    (LETT $ (QREFELT $$ 0) . #1#)
    (RETURN (PROGN (|PR;termTimes| |tco| |tex| |x1| $))))) 

(DEFUN |PR;addm!| (|p1| |coef| |exp| |p2| $)
  (PROG (|newcell| |endcell| |res| |ttt| |newcoef| |exy| |ty| |tx|)
    (RETURN
     (SEQ
      (SEQ (LETT |res| NIL . #1=(|PR;addm!|)) (LETT |endcell| NIL . #1#)
           (EXIT
            (SEQ G190
                 (COND
                  ((NULL (COND ((OR (NULL |p1|) (NULL |p2|)) 'NIL) ('T 'T)))
                   (GO G191)))
                 (SEQ (LETT |tx| (|SPADfirst| |p1|) . #1#)
                      (LETT |ty| (|SPADfirst| |p2|) . #1#)
                      (LETT |exy| (SPADCALL |exp| (QCAR |ty|) (QREFELT $ 44))
                            . #1#)
                      (LETT |newcell| NIL . #1#)
                      (COND
                       ((SPADCALL (QCAR |tx|) |exy| (QREFELT $ 31))
                        (SEQ
                         (LETT |newcoef|
                               (SPADCALL (QCDR |tx|)
                                         (SPADCALL |coef| (QCDR |ty|)
                                                   (QREFELT $ 43))
                                         (QREFELT $ 47))
                               . #1#)
                         (COND
                          ((NULL (SPADCALL |newcoef| (QREFELT $ 37)))
                           (SEQ (PROGN (RPLACD |tx| |newcoef|) (QCDR |tx|))
                                (EXIT (LETT |newcell| |p1| . #1#)))))
                         (LETT |p1| (CDR |p1|) . #1#)
                         (EXIT (LETT |p2| (CDR |p2|) . #1#))))
                       ((SPADCALL |exy| (QCAR |tx|) (QREFELT $ 32))
                        (SEQ (LETT |newcell| |p1| . #1#)
                             (EXIT (LETT |p1| (CDR |p1|) . #1#))))
                       ('T
                        (SEQ
                         (LETT |newcoef|
                               (SPADCALL |coef| (QCDR |ty|) (QREFELT $ 43))
                               . #1#)
                         (COND
                          ((OR (QREFELT $ 42)
                               (NULL (SPADCALL |newcoef| (QREFELT $ 37))))
                           (SEQ (LETT |ttt| (CONS |exy| |newcoef|) . #1#)
                                (EXIT
                                 (LETT |newcell| (CONS |ttt| NIL) . #1#))))
                          ('T (LETT |newcell| NIL . #1#)))
                         (EXIT (LETT |p2| (CDR |p2|) . #1#)))))
                      (EXIT
                       (COND
                        ((NULL (NULL |newcell|))
                         (COND
                          ((NULL |res|)
                           (SEQ (LETT |res| |newcell| . #1#)
                                (EXIT (LETT |endcell| |res| . #1#))))
                          ('T
                           (SEQ (RPLACD |endcell| |newcell|)
                                (EXIT (LETT |endcell| |newcell| . #1#)))))))))
                 NIL (GO G190) G191 (EXIT NIL))))
      (COND
       ((NULL |p1|) (LETT |newcell| (|PR;times| |coef| |exp| |p2| $) . #1#))
       (#2='T (LETT |newcell| |p1| . #1#)))
      (EXIT
       (COND ((NULL |res|) |newcell|)
             (#2# (SEQ (RPLACD |endcell| |newcell|) (EXIT |res|))))))))) 

(DEFUN |PR;pomopo!;$RE2$;20| (|p1| |r| |e| |p2| $)
  (|PR;addm!| |p1| |r| |e| |p2| $)) 

(DEFUN |PR;addms!| (|pp1| |coef| |exp1| |pp2| $)
  (PROG (|newcell| |endcell| |res| |p2| |ttt| |newcoef| |p1| |exy| |ty| |tx|
         |exp|)
    (RETURN
     (SEQ (LETT |p1| |pp1| . #1=(|PR;addms!|)) (LETT |p2| |pp2| . #1#)
          (LETT |exp| |exp1| . #1#)
          (SEQ (LETT |res| NIL . #1#) (LETT |endcell| NIL . #1#)
               (EXIT
                (SEQ G190
                     (COND
                      ((NULL
                        (COND ((OR (NULL |p1|) (NULL |p2|)) 'NIL) ('T 'T)))
                       (GO G191)))
                     (SEQ (LETT |tx| (|SPADfirst| |p1|) . #1#)
                          (LETT |ty| (|SPADfirst| |p2|) . #1#)
                          (LETT |exy| (QSPLUS |exp| (QCAR |ty|)) . #1#)
                          (LETT |newcell| NIL . #1#)
                          (COND
                           ((EQL (QCAR |tx|) |exy|)
                            (SEQ
                             (LETT |newcoef|
                                   (SPADCALL (QCDR |tx|)
                                             (SPADCALL |coef| (QCDR |ty|)
                                                       (QREFELT $ 43))
                                             (QREFELT $ 47))
                                   . #1#)
                             (COND
                              ((NULL (SPADCALL |newcoef| (QREFELT $ 37)))
                               (SEQ (PROGN (RPLACD |tx| |newcoef|) (QCDR |tx|))
                                    (EXIT (LETT |newcell| |p1| . #1#)))))
                             (LETT |p1| (CDR |p1|) . #1#)
                             (EXIT (LETT |p2| (CDR |p2|) . #1#))))
                           ((QSLESSP |exy| (QCAR |tx|))
                            (SEQ (LETT |newcell| |p1| . #1#)
                                 (EXIT (LETT |p1| (CDR |p1|) . #1#))))
                           ('T
                            (SEQ
                             (LETT |newcoef|
                                   (SPADCALL |coef| (QCDR |ty|) (QREFELT $ 43))
                                   . #1#)
                             (COND
                              ((OR (QREFELT $ 42)
                                   (NULL (SPADCALL |newcoef| (QREFELT $ 37))))
                               (SEQ (LETT |ttt| (CONS |exy| |newcoef|) . #1#)
                                    (EXIT
                                     (LETT |newcell| (CONS |ttt| NIL) . #1#))))
                              ('T (LETT |newcell| NIL . #1#)))
                             (EXIT (LETT |p2| (CDR |p2|) . #1#)))))
                          (EXIT
                           (COND
                            ((NULL (NULL |newcell|))
                             (COND
                              ((NULL |res|)
                               (SEQ (LETT |res| |newcell| . #1#)
                                    (EXIT (LETT |endcell| |res| . #1#))))
                              ('T
                               (SEQ (RPLACD |endcell| |newcell|)
                                    (EXIT
                                     (LETT |endcell| |newcell| . #1#)))))))))
                     NIL (GO G190) G191 (EXIT NIL))))
          (COND
           ((NULL |p1|)
            (LETT |newcell| (|PR;times| |coef| |exp| |p2| $) . #1#))
           (#2='T (LETT |newcell| |p1| . #1#)))
          (EXIT
           (COND ((NULL |res|) |newcell|)
                 (#2# (SEQ (RPLACD |endcell| |newcell|) (EXIT |res|))))))))) 

(DEFUN |PR;*;3$;22| (|p1| |p2| $)
  (PROG (|res| #1=#:G1998 |tx| #2=#:G1997 |xx| |degy| |degx| |#G68| |#G67| |yy|
         |#G66| |#G65| |ly| |lx|)
    (RETURN
     (SEQ (LETT |xx| |p1| . #3=(|PR;*;3$;22|))
          (EXIT
           (COND ((NULL |xx|) |p1|)
                 (#4='T
                  (SEQ (LETT |yy| |p2| . #3#)
                       (EXIT
                        (COND ((NULL |yy|) |p2|)
                              (#4#
                               (SEQ
                                (COND
                                 ((QREFELT $ 9)
                                  (SEQ (LETT |lx| (LENGTH |xx|) . #3#)
                                       (LETT |ly| (LENGTH |yy|) . #3#)
                                       (EXIT
                                        (COND
                                         ((< |ly| |lx|)
                                          (SEQ
                                           (PROGN
                                            (LETT |#G65| |yy| . #3#)
                                            (LETT |#G66| |xx| . #3#)
                                            (LETT |xx| |#G65| . #3#)
                                            (LETT |yy| |#G66| . #3#))
                                           (EXIT
                                            (PROGN
                                             (LETT |#G67| |p2| . #3#)
                                             (LETT |#G68| |p1| . #3#)
                                             (LETT |p1| |#G67| . #3#)
                                             (LETT |p2| |#G68| . #3#))))))))))
                                (LETT |degx| (QCAR (|SPADfirst| |xx|)) . #3#)
                                (LETT |degy| (QCAR (|SPADfirst| |yy|)) . #3#)
                                (EXIT
                                 (COND
                                  ((ZEROP |degx|)
                                   (SPADCALL (QCDR (|SPADfirst| |xx|)) |p2|
                                             (QREFELT $ 49)))
                                  ((ZEROP |degy|)
                                   (SPADCALL |p1| (QCDR (|SPADfirst| |yy|))
                                             (QREFELT $ 50)))
                                  (#4#
                                   (SEQ (LETT |xx| (REVERSE |xx|) . #3#)
                                        (LETT |res| NIL . #3#)
                                        (COND
                                         ((< (+ |degx| |degy|)
                                             MOST-POSITIVE-FIXNUM)
                                          (SEQ (LETT |tx| NIL . #3#)
                                               (LETT #2# |xx| . #3#) G190
                                               (COND
                                                ((OR (ATOM #2#)
                                                     (PROGN
                                                      (LETT |tx| (CAR #2#)
                                                            . #3#)
                                                      NIL))
                                                 #5=(GO G191)))
                                               (SEQ
                                                (EXIT
                                                 (LETT |res|
                                                       (|PR;addms!| |res|
                                                        (QCDR |tx|) (QCAR |tx|)
                                                        |yy| $)
                                                       . #3#)))
                                               (LETT #2# (CDR #2#) . #3#)
                                               #6=(GO G190) G191 (EXIT NIL)))
                                         (#4#
                                          (SEQ (LETT |tx| NIL . #3#)
                                               (LETT #1# |xx| . #3#) G190
                                               (COND
                                                ((OR (ATOM #1#)
                                                     (PROGN
                                                      (LETT |tx| (CAR #1#)
                                                            . #3#)
                                                      NIL))
                                                 #5#))
                                               (SEQ
                                                (EXIT
                                                 (LETT |res|
                                                       (|PR;addm!| |res|
                                                        (QCDR |tx|) (QCAR |tx|)
                                                        |yy| $)
                                                       . #3#)))
                                               (LETT #1# (CDR #1#) . #3#) #6#
                                               G191 (EXIT NIL))))
                                        (EXIT |res|))))))))))))))))) 

(DEFUN |PR;*;3$;23| (|p1| |p2| $)
  (PROG (|res| #1=#:G2006 |tx| |xx| |yy|)
    (RETURN
     (SEQ (LETT |xx| |p1| . #2=(|PR;*;3$;23|))
          (EXIT
           (COND ((NULL |xx|) |p1|)
                 (#3='T
                  (SEQ (LETT |yy| |p2| . #2#)
                       (EXIT
                        (COND ((NULL |yy|) |p2|)
                              ((SPADCALL (QCAR (|SPADfirst| |xx|))
                                         (QREFELT $ 27))
                               (SPADCALL (QCDR (|SPADfirst| |xx|)) |p2|
                                         (QREFELT $ 49)))
                              ((SPADCALL (QCAR (|SPADfirst| |yy|))
                                         (QREFELT $ 27))
                               (SPADCALL |p1| (QCDR (|SPADfirst| |yy|))
                                         (QREFELT $ 50)))
                              (#3#
                               (SEQ (LETT |xx| (REVERSE |xx|) . #2#)
                                    (LETT |res| NIL . #2#)
                                    (SEQ (LETT |tx| NIL . #2#)
                                         (LETT #1# |xx| . #2#) G190
                                         (COND
                                          ((OR (ATOM #1#)
                                               (PROGN
                                                (LETT |tx| (CAR #1#) . #2#)
                                                NIL))
                                           (GO G191)))
                                         (SEQ
                                          (EXIT
                                           (LETT |res|
                                                 (|PR;addm!| |res| (QCDR |tx|)
                                                  (QCAR |tx|) |yy| $)
                                                 . #2#)))
                                         (LETT #1# (CDR #1#) . #2#) (GO G190)
                                         G191 (EXIT NIL))
                                    (EXIT |res|))))))))))))) 

(DEFUN |PR;^;$Pi$;24| (|p| |np| $) (SPADCALL |p| |np| (QREFELT $ 52))) 

(DEFUN |PR;^;$Pi$;25| (|p| |np| $) (SPADCALL |p| |np| (QREFELT $ 52))) 

(DEFUN |PR;^;$Nni$;26| (|p| |nn| $) (SPADCALL |p| |nn| (QREFELT $ 52))) 

(DEFUN |PR;^;$Nni$;27| (|p| |nn| $)
  (PROG (|cc|)
    (RETURN
     (COND ((NULL |p|) (|spadConstant| $ 23))
           ((ZEROP |nn|) (|spadConstant| $ 12)) ((EQL |nn| 1) |p|)
           (#1='T
            (COND
             ((NULL (CDR |p|))
              (COND
               ((SPADCALL
                 (LETT |cc|
                       (SPADCALL (QCDR (|SPADfirst| |p|)) |nn| (QREFELT $ 55))
                       |PR;^;$Nni$;27|)
                 (QREFELT $ 37))
                (|spadConstant| $ 23))
               (#1#
                (LIST
                 (CONS (SPADCALL |nn| (QCAR (|SPADfirst| |p|)) (QREFELT $ 56))
                       |cc|)))))
             (#1#
              (SPADCALL (LIST (|SPADfirst| |p|)) (CDR |p|) |nn|
                        (QREFELT $ 57))))))))) 

(DEFUN |PR;unitNormal;$R;28| (|p| $)
  (PROG (|a| #1=#:G2016 |lcf| |#G1|)
    (RETURN
     (SEQ
      (EXIT
       (SEQ
        (COND
         ((NULL |p|)
          (EXIT (VECTOR (|spadConstant| $ 12) |p| (|spadConstant| $ 12))))
         ('T
          (SEQ
           (LETT |#G1| (QCDR (|SPADfirst| |p|)) . #2=(|PR;unitNormal;$R;28|))
           (LETT |lcf| |#G1| . #2#)
           (EXIT
            (COND
             ((SPADCALL |#G1| (|spadConstant| $ 11) (QREFELT $ 58))
              (PROGN
               (LETT #1#
                     (VECTOR (|spadConstant| $ 12) |p| (|spadConstant| $ 12))
                     . #2#)
               (GO #1#))))))))
        (LETT |a| (SPADCALL |lcf| (QREFELT $ 59)) . #2#)
        (EXIT
         (VECTOR (SPADCALL |lcf| (QREFELT $ 35))
                 (CONS (CONS (QCAR (|SPADfirst| |p|)) (|spadConstant| $ 11))
                       (SPADCALL |a| (CDR |p|) (QREFELT $ 49)))
                 (SPADCALL |a| (QREFELT $ 35))))))
      #1# (EXIT #1#))))) 

(DEFUN |PR;unitCanonical;2$;29| (|p| $)
  (PROG (|a| #1=#:G2020 |lcf| |#G2|)
    (RETURN
     (SEQ
      (EXIT
       (SEQ
        (COND ((NULL |p|) (EXIT |p|))
              ('T
               (SEQ
                (LETT |#G2| (QCDR (|SPADfirst| |p|))
                      . #2=(|PR;unitCanonical;2$;29|))
                (LETT |lcf| |#G2| . #2#)
                (EXIT
                 (COND
                  ((SPADCALL |#G2| (|spadConstant| $ 11) (QREFELT $ 58))
                   (PROGN (LETT #1# |p| . #2#) (GO #1#))))))))
        (LETT |a| (SPADCALL |lcf| (QREFELT $ 59)) . #2#)
        (EXIT
         (CONS (CONS (QCAR (|SPADfirst| |p|)) (|spadConstant| $ 11))
               (SPADCALL |a| (CDR |p|) (QREFELT $ 49))))))
      #1# (EXIT #1#))))) 

(DEFUN |PR;unitNormal;$R;30| (|p| $)
  (PROG (|a| |cf| |u| |#G88|)
    (RETURN
     (SEQ
      (COND
       ((OR (NULL |p|)
            (SPADCALL (QCDR (|SPADfirst| |p|)) (|spadConstant| $ 11)
                      (QREFELT $ 58)))
        (VECTOR (|spadConstant| $ 12) |p| (|spadConstant| $ 12)))
       ('T
        (SEQ
         (PROGN
          (LETT |#G88| (SPADCALL (QCDR (|SPADfirst| |p|)) (QREFELT $ 63))
                . #1=(|PR;unitNormal;$R;30|))
          (LETT |u| (QVELT |#G88| 0) . #1#)
          (LETT |cf| (QVELT |#G88| 1) . #1#)
          (LETT |a| (QVELT |#G88| 2) . #1#)
          |#G88|)
         (EXIT
          (VECTOR (SPADCALL |u| (QREFELT $ 35))
                  (CONS (CONS (QCAR (|SPADfirst| |p|)) |cf|)
                        (SPADCALL |a| (CDR |p|) (QREFELT $ 49)))
                  (SPADCALL |a| (QREFELT $ 35))))))))))) 

(DEFUN |PR;unitCanonical;2$;31| (|p| $)
  (PROG (|a| |cf| |u| |#G90|)
    (RETURN
     (SEQ
      (COND
       ((OR (NULL |p|)
            (SPADCALL (QCDR (|SPADfirst| |p|)) (|spadConstant| $ 11)
                      (QREFELT $ 58)))
        |p|)
       ('T
        (SEQ
         (PROGN
          (LETT |#G90| (SPADCALL (QCDR (|SPADfirst| |p|)) (QREFELT $ 63))
                . #1=(|PR;unitCanonical;2$;31|))
          (LETT |u| (QVELT |#G90| 0) . #1#)
          (LETT |cf| (QVELT |#G90| 1) . #1#)
          (LETT |a| (QVELT |#G90| 2) . #1#)
          |#G90|)
         (EXIT
          (CONS (CONS (QCAR (|SPADfirst| |p|)) |cf|)
                (SPADCALL |a| (CDR |p|) (QREFELT $ 49))))))))))) 

(DEFUN |PR;associates?;2$B;32| (|p1| |p2| $)
  (PROG (#1=#:G2032)
    (RETURN
     (COND ((NULL |p1|) (NULL |p2|)) ((NULL |p2|) 'NIL)
           (#2='T
            (COND
             ((SPADCALL (QCAR (|SPADfirst| |p1|)) (QCAR (|SPADfirst| |p2|))
                        (QREFELT $ 31))
              (COND
               ((SPADCALL (QCDR (|SPADfirst| |p1|)) (QCDR (|SPADfirst| |p2|))
                          (QREFELT $ 64))
                (SPADCALL
                 (SPADCALL
                  (PROG2
                      (LETT #1#
                            (SPADCALL (QCDR (|SPADfirst| |p2|))
                                      (QCDR (|SPADfirst| |p1|)) (QREFELT $ 65))
                            |PR;associates?;2$B;32|)
                      (QCDR #1#)
                    (|check-union| (QEQCAR #1# 0) (QREFELT $ 6) #1#))
                  (CDR |p1|) (QREFELT $ 49))
                 (CDR |p2|) (QREFELT $ 66)))
               (#2# 'NIL)))
             (#2# 'NIL))))))) 

(DEFUN |PR;exquo;$RU;33| (|p| |r| $)
  (PROG (#1=#:G2045 |a| #2=#:G2047 |tm| #3=#:G2046)
    (RETURN
     (SEQ
      (EXIT
       (CONS 0
             (PROGN
              (LETT #3# NIL . #4=(|PR;exquo;$RU;33|))
              (SEQ (LETT |tm| NIL . #4#) (LETT #2# |p| . #4#) G190
                   (COND
                    ((OR (ATOM #2#) (PROGN (LETT |tm| (CAR #2#) . #4#) NIL))
                     (GO G191)))
                   (SEQ
                    (EXIT
                     (LETT #3#
                           (CONS
                            (SEQ
                             (LETT |a|
                                   (SPADCALL (QCDR |tm|) |r| (QREFELT $ 65))
                                   . #4#)
                             (EXIT
                              (COND
                               ((QEQCAR |a| 1)
                                (PROGN
                                 (LETT #1# (CONS 1 "failed") . #4#)
                                 (GO #1#)))
                               ('T (CONS (QCAR |tm|) (QCDR |a|))))))
                            #3#)
                           . #4#)))
                   (LETT #2# (CDR #2#) . #4#) (GO G190) G191
                   (EXIT (NREVERSE0 #3#))))))
      #1# (EXIT #1#))))) 

(DEFUN |PR;fmecg;$ER2$;34| (|p1| |e| |r| |p2| $)
  (PROG (|rout| |u| |c2| |e2| #1=#:G2057 |tm|)
    (RETURN
     (SEQ (LETT |rout| NIL . #2=(|PR;fmecg;$ER2$;34|))
          (LETT |r| (SPADCALL |r| (QREFELT $ 69)) . #2#)
          (SEQ (LETT |tm| NIL . #2#) (LETT #1# |p2| . #2#) G190
               (COND
                ((OR (ATOM #1#) (PROGN (LETT |tm| (CAR #1#) . #2#) NIL))
                 #3=(GO G191)))
               (SEQ (LETT |e2| (SPADCALL |e| (QCAR |tm|) (QREFELT $ 44)) . #2#)
                    (LETT |c2| (SPADCALL |r| (QCDR |tm|) (QREFELT $ 43)) . #2#)
                    (EXIT
                     (COND
                      ((SPADCALL |c2| (|spadConstant| $ 21) (QREFELT $ 58))
                       "next term")
                      ('T
                       (SEQ
                        (SEQ G190
                             (COND
                              ((NULL
                                (COND ((NULL |p1|) 'NIL)
                                      ('T
                                       (SPADCALL |e2| (QCAR (|SPADfirst| |p1|))
                                                 (QREFELT $ 32)))))
                               #3#))
                             (SEQ
                              (LETT |rout| (CONS (|SPADfirst| |p1|) |rout|)
                                    . #2#)
                              (EXIT (LETT |p1| (CDR |p1|) . #2#)))
                             NIL #4=(GO G190) G191 (EXIT NIL))
                        (COND
                         ((OR (NULL |p1|)
                              (SPADCALL (QCAR (|SPADfirst| |p1|)) |e2|
                                        (QREFELT $ 32)))
                          (EXIT
                           (LETT |rout| (CONS (CONS |e2| |c2|) |rout|)
                                 . #2#))))
                        (SEQ
                         (LETT |u|
                               (SPADCALL (QCDR (|SPADfirst| |p1|)) |c2|
                                         (QREFELT $ 47))
                               . #2#)
                         (EXIT
                          (COND
                           ((NULL
                             (SPADCALL |u| (|spadConstant| $ 21)
                                       (QREFELT $ 58)))
                            (LETT |rout| (CONS (CONS |e2| |u|) |rout|)
                                  . #2#)))))
                        (EXIT (LETT |p1| (CDR |p1|) . #2#)))))))
               (LETT #1# (CDR #1#) . #2#) #4# G191 (EXIT NIL))
          (EXIT (NRECONC |rout| |p1|)))))) 

(DEFUN |PR;exquo;2$U;35| (|p1| |p2| $)
  (PROG (|rout| #1=#:G2072 |ee| |a|)
    (RETURN
     (SEQ
      (EXIT
       (COND ((NULL |p2|) (|error| "Division by 0"))
             ((SPADCALL |p2| (|spadConstant| $ 12) (QREFELT $ 66))
              (CONS 0 |p1|))
             ((SPADCALL |p1| |p2| (QREFELT $ 66))
              (CONS 0 (|spadConstant| $ 12)))
             (#2='T
              (SEQ (LETT |rout| NIL . #3=(|PR;exquo;2$U;35|))
                   (SEQ G190
                        (COND
                         ((NULL (COND ((NULL |p1|) 'NIL) ('T 'T))) (GO G191)))
                        (SEQ
                         (LETT |a|
                               (SPADCALL (QCDR (|SPADfirst| |p1|))
                                         (QCDR (|SPADfirst| |p2|))
                                         (QREFELT $ 65))
                               . #3#)
                         (EXIT
                          (COND
                           ((QEQCAR |a| 1)
                            (PROGN
                             (LETT #1# (CONS 1 "failed") . #3#)
                             (GO #1#)))
                           ('T
                            (SEQ
                             (LETT |ee|
                                   (SPADCALL (QCAR (|SPADfirst| |p1|))
                                             (QCAR (|SPADfirst| |p2|))
                                             (QREFELT $ 71))
                                   . #3#)
                             (EXIT
                              (COND
                               ((QEQCAR |ee| 1)
                                (PROGN
                                 (LETT #1# (CONS 1 "failed") . #3#)
                                 (GO #1#)))
                               ('T
                                (SEQ
                                 (LETT |p1|
                                       (SPADCALL (CDR |p1|) (QCDR |ee|)
                                                 (QCDR |a|) (CDR |p2|)
                                                 (QREFELT $ 70))
                                       . #3#)
                                 (EXIT
                                  (LETT |rout|
                                        (CONS (CONS (QCDR |ee|) (QCDR |a|))
                                              |rout|)
                                        . #3#)))))))))))
                        NIL (GO G190) G191 (EXIT NIL))
                   (EXIT
                    (COND ((NULL |p1|) (CONS 0 (REVERSE |rout|)))
                          (#2# (CONS 1 "failed"))))))))
      #1# (EXIT #1#))))) 

(DEFUN |PR;exquo;2$U;36| (|p1| |p2| $)
  (PROG (|rout| #1=#:G2087 |ee| |a|)
    (RETURN
     (SEQ
      (EXIT
       (COND ((NULL |p2|) (|error| "Division by 0"))
             ((SPADCALL |p2| (|spadConstant| $ 12) (QREFELT $ 66))
              (CONS 0 |p1|))
             (#2='T
              (SEQ (LETT |rout| NIL . #3=(|PR;exquo;2$U;36|))
                   (SEQ G190
                        (COND
                         ((NULL (COND ((NULL |p1|) 'NIL) ('T 'T))) (GO G191)))
                        (SEQ
                         (LETT |a|
                               (SPADCALL (QCDR (|SPADfirst| |p1|))
                                         (QCDR (|SPADfirst| |p2|))
                                         (QREFELT $ 65))
                               . #3#)
                         (EXIT
                          (COND
                           ((QEQCAR |a| 1)
                            (PROGN
                             (LETT #1# (CONS 1 "failed") . #3#)
                             (GO #1#)))
                           ('T
                            (SEQ
                             (LETT |ee|
                                   (SPADCALL (QCAR (|SPADfirst| |p1|))
                                             (QCAR (|SPADfirst| |p2|))
                                             (QREFELT $ 71))
                                   . #3#)
                             (EXIT
                              (COND
                               ((QEQCAR |ee| 1)
                                (PROGN
                                 (LETT #1# (CONS 1 "failed") . #3#)
                                 (GO #1#)))
                               ('T
                                (SEQ
                                 (LETT |p1|
                                       (SPADCALL (CDR |p1|) (QCDR |ee|)
                                                 (QCDR |a|) (CDR |p2|)
                                                 (QREFELT $ 70))
                                       . #3#)
                                 (EXIT
                                  (LETT |rout|
                                        (CONS (CONS (QCDR |ee|) (QCDR |a|))
                                              |rout|)
                                        . #3#)))))))))))
                        NIL (GO G190) G191 (EXIT NIL))
                   (EXIT
                    (COND ((NULL |p1|) (CONS 0 (REVERSE |rout|)))
                          (#2# (CONS 1 "failed"))))))))
      #1# (EXIT #1#))))) 

(DEFUN |PR;/;$R$;37| (|x| |r| $)
  (SPADCALL (SPADCALL |r| (QREFELT $ 59)) |x| (QREFELT $ 49))) 

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

(DEFUN |PolynomialRing;| (|#1| |#2|)
  (PROG (|pv$| $ |dv$| DV$2 DV$1)
    (RETURN
     (PROGN
      (LETT DV$1 (|devaluate| |#1|) . #1=(|PolynomialRing|))
      (LETT DV$2 (|devaluate| |#2|) . #1#)
      (LETT |dv$| (LIST '|PolynomialRing| DV$1 DV$2) . #1#)
      (LETT $ (GETREFV 83) . #1#)
      (QSETREFV $ 0 |dv$|)
      (QSETREFV $ 3
                (LETT |pv$|
                      (|buildPredVector| 0 0
                                         (LIST
                                          (|HasCategory| |#1|
                                                         '(|Algebra|
                                                           (|Fraction|
                                                            (|Integer|))))
                                          (|HasCategory| |#1|
                                                         '(|IntegralDomain|))
                                          (|HasCategory| |#1|
                                                         '(|CharacteristicNonZero|))
                                          (|HasCategory| |#1|
                                                         '(|CharacteristicZero|))
                                          (|HasCategory| |#1|
                                                         '(|RetractableTo|
                                                           (|Fraction|
                                                            (|Integer|))))
                                          (|HasCategory| |#1|
                                                         '(|RetractableTo|
                                                           (|Integer|)))
                                          (|HasCategory| |#1|
                                                         '(|canonicalUnitNormal|))
                                          (|HasCategory| |#1| '(|Field|))
                                          (|HasCategory| |#1| '(|GcdDomain|))
                                          (AND
                                           (|HasCategory| |#1|
                                                          '(|IntegralDomain|))
                                           (|HasCategory| |#2|
                                                          '(|CancellationAbelianMonoid|)))
                                          (OR
                                           (|HasCategory| |#1|
                                                          '(|Algebra|
                                                            (|Fraction|
                                                             (|Integer|))))
                                           (|HasCategory| |#1|
                                                          '(|RetractableTo|
                                                            (|Fraction|
                                                             (|Integer|)))))
                                          (|HasCategory| |#1|
                                                         '(|CommutativeRing|))))
                      . #1#))
      (|haddProp| |$ConstructorCache| '|PolynomialRing| (LIST DV$1 DV$2)
                  (CONS 1 $))
      (|stuffDomainSlots| $)
      (QSETREFV $ 6 |#1|)
      (QSETREFV $ 7 |#2|)
      (SETF |pv$| (QREFELT $ 3))
      (QSETREFV $ 8 (|List| (|Record| (|:| |k| |#2|) (|:| |c| |#1|))))
      (QSETREFV $ 9 (|HasCategory| |#1| '(|CommutativeRing|)))
      (COND
       ((|domainEqual| |#2| (|NonNegativeInteger|))
        (QSETREFV $ 30 (CONS (|dispatchFunction| |PR;coefficient;$ER;10|) $)))
       ('T
        (QSETREFV $ 30 (CONS (|dispatchFunction| |PR;coefficient;$ER;11|) $))))
      (QSETREFV $ 42 (|HasCategory| |#1| '(|EntireRing|)))
      (COND
       ((|domainEqual| |#2| (|NonNegativeInteger|))
        (PROGN (QSETREFV $ 51 (CONS (|dispatchFunction| |PR;*;3$;22|) $))))
       ('T (QSETREFV $ 51 (CONS (|dispatchFunction| |PR;*;3$;23|) $))))
      (COND
       ((|testBitVector| |pv$| 12)
        (PROGN
         (QSETREFV $ 54 (CONS (|dispatchFunction| |PR;^;$Pi$;24|) $))
         (QSETREFV $ 54 (CONS (|dispatchFunction| |PR;^;$Pi$;25|) $))
         (QSETREFV $ 52 (CONS (|dispatchFunction| |PR;^;$Nni$;26|) $))
         (QSETREFV $ 52 (CONS (|dispatchFunction| |PR;^;$Nni$;27|) $)))))
      (COND
       ((|testBitVector| |pv$| 8)
        (PROGN
         (QSETREFV $ 61 (CONS (|dispatchFunction| |PR;unitNormal;$R;28|) $))
         (QSETREFV $ 62
                   (CONS (|dispatchFunction| |PR;unitCanonical;2$;29|) $))))
       ((|testBitVector| |pv$| 2)
        (PROGN
         (QSETREFV $ 61 (CONS (|dispatchFunction| |PR;unitNormal;$R;30|) $))
         (QSETREFV $ 62
                   (CONS (|dispatchFunction| |PR;unitCanonical;2$;31|) $)))))
      (COND
       ((|testBitVector| |pv$| 2)
        (PROGN
         (QSETREFV $ 67 (CONS (|dispatchFunction| |PR;associates?;2$B;32|) $))
         (QSETREFV $ 68 (CONS (|dispatchFunction| |PR;exquo;$RU;33|) $))
         (COND
          ((|HasCategory| |#2| '(|CancellationAbelianMonoid|))
           (PROGN
            (QSETREFV $ 70 (CONS (|dispatchFunction| |PR;fmecg;$ER2$;34|) $))
            (COND
             ((|HasCategory| |#1| '(|Approximate|))
              (QSETREFV $ 72 (CONS (|dispatchFunction| |PR;exquo;2$U;35|) $)))
             ('T
              (QSETREFV $ 72
                        (CONS (|dispatchFunction| |PR;exquo;2$U;36|)
                              $))))))))))
      (COND
       ((|testBitVector| |pv$| 8)
        (QSETREFV $ 73 (CONS (|dispatchFunction| |PR;/;$R$;37|) $))))
      $)))) 

(MAKEPROP '|PolynomialRing| '|infovec|
          (LIST
           '#(NIL NIL NIL NIL NIL (|FreeModule| 6 7) (|local| |#1|)
              (|local| |#2|) '|Rep| '|commutative| (0 . |Zero|) (4 . |One|)
              (CONS IDENTITY (FUNCALL (|dispatchFunction| |PR;One;$;1|) $))
              (|NonNegativeInteger|) (8 . |characteristic|)
              |PR;characteristic;Nni;2| |PR;numberOfMonomials;$Nni;3|
              |PR;degree;$E;4| (|Record| (|:| |k| 7) (|:| |c| 6)) (12 . |last|)
              |PR;minimumDegree;$E;5| (17 . |Zero|)
              |PR;leadingCoefficient;$R;6| (21 . |Zero|)
              |PR;leadingMonomial;2$;7| |PR;reductum;2$;8| (|Boolean|)
              (25 . |zero?|) (|Union| 6 '"failed") |PR;retractIfCan;$U;9|
              (30 . |coefficient|) (36 . =) (42 . <) (|Union| $ '"failed")
              (48 . |recip|) |PR;coerce;R$;13| |PR;recip;$U;12| (53 . |zero?|)
              (|Integer|) (58 . |coerce|) |PR;coerce;I$;14| |PR;ground?;$B;15|
              '|entireRing?| (63 . *) (69 . +) (|Mapping| 18 18) (75 . |map|)
              (81 . +) |PR;pomopo!;$RE2$;20| (87 . *) (93 . *) (99 . *)
              (105 . ^) (|PositiveInteger|) (111 . ^) (117 . ^) (123 . *)
              (129 . |binomThmExpt|) (136 . =) (142 . |inv|)
              (|Record| (|:| |unit| $) (|:| |canonical| $) (|:| |associate| $))
              (147 . |unitNormal|) (152 . |unitCanonical|) (157 . |unitNormal|)
              (162 . |associates?|) (168 . |exquo|) (174 . =)
              (180 . |associates?|) (186 . |exquo|) (192 . -) (197 . |fmecg|)
              (205 . |subtractIfCan|) (211 . |exquo|) (217 . /) (|Fraction| 38)
              (|Union| 74 '#1="failed") (|Union| 38 '#1#) (|Mapping| 7 7)
              (|List| 6) (|Mapping| 6 6) (|String|) (|OutputForm|)
              (|SingleInteger|))
           '#(~= 223 |zero?| 229 |unitNormal| 234 |unitCanonical| 239 |unit?|
              244 |subtractIfCan| 249 |sample| 255 |retractIfCan| 259 |retract|
              274 |reductum| 289 |recip| 294 |primitivePart| 299 |pomopo!| 304
              |one?| 312 |numberOfMonomials| 317 |monomial?| 322 |monomial| 327
              |minimumDegree| 333 |mapExponents| 338 |map| 344
              |leadingMonomial| 350 |leadingCoefficient| 355 |latex| 360 |hash|
              365 |ground?| 370 |ground| 375 |fmecg| 380 |exquo| 388 |degree|
              400 |content| 405 |coerce| 410 |coefficients| 435 |coefficient|
              440 |charthRoot| 446 |characteristic| 451 |binomThmExpt| 455
              |associates?| 462 ^ 468 |Zero| 480 |One| 484 = 488 / 494 - 500 +
              511 * 517)
           'NIL
           (CONS
            (|makeByteWordVec2| 7
                                '(0 0 2 0 1 2 0 0 1 2 2 3 4 0 0 0 1 0 0 0 0 0 1
                                  1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 2 5 6 7))
            (CONS
             '#(|FiniteAbelianMonoidRing&| |AbelianMonoidRing&|
                |IntegralDomain&| |Algebra&| |Algebra&| |Algebra&| |Module&|
                NIL |Module&| |Module&| NIL NIL NIL NIL NIL |Ring&| NIL NIL NIL
                NIL NIL NIL NIL NIL |AbelianGroup&| NIL NIL |AbelianMonoid&|
                |Monoid&| NIL |SemiGroup&| |AbelianSemiGroup&|
                |FullyRetractableTo&| |SetCategory&| |RetractableTo&| NIL NIL
                |BasicType&| NIL NIL |RetractableTo&| |RetractableTo&| NIL)
             (CONS
              '#((|FiniteAbelianMonoidRing| 6 7) (|AbelianMonoidRing| 6 7)
                 (|IntegralDomain|) (|Algebra| 6) (|Algebra| 74) (|Algebra| $$)
                 (|Module| 6) (|CommutativeRing|) (|Module| 74) (|Module| $$)
                 (|EntireRing|) (|CharacteristicNonZero|)
                 (|CharacteristicZero|) (|BiModule| 6 6) (|BiModule| $$ $$)
                 (|Ring|) (|BiModule| 74 74) (|RightModule| 6) (|LeftModule| 6)
                 (|RightModule| $$) (|Rng|) (|LeftModule| $$) (|LeftModule| 74)
                 (|RightModule| 74) (|AbelianGroup|)
                 (|CancellationAbelianMonoid|) (|SemiRing|) (|AbelianMonoid|)
                 (|Monoid|) (|SemiRng|) (|SemiGroup|) (|AbelianSemiGroup|)
                 (|FullyRetractableTo| 6) (|SetCategory|) (|RetractableTo| 6)
                 (|CommutativeStar|) (|unitsKnown|) (|BasicType|)
                 (|CoercibleTo| 81) (|noZeroDivisors|) (|RetractableTo| 74)
                 (|RetractableTo| 38) (|canonicalUnitNormal|))
              (|makeByteWordVec2| 82
                                  '(0 7 0 10 0 6 0 11 0 6 13 14 1 8 18 0 19 0 6
                                    0 21 0 0 0 23 1 7 26 0 27 2 0 6 0 7 30 2 7
                                    26 0 0 31 2 7 26 0 0 32 1 6 33 0 34 1 6 26
                                    0 37 1 6 0 38 39 2 6 0 0 0 43 2 7 0 0 0 44
                                    2 8 0 45 0 46 2 6 0 0 0 47 2 0 0 6 0 49 2 0
                                    0 0 6 50 2 0 0 0 0 51 2 0 0 0 13 52 2 0 0 0
                                    53 54 2 6 0 0 13 55 2 7 0 13 0 56 3 0 0 0 0
                                    13 57 2 6 26 0 0 58 1 6 0 0 59 1 0 60 0 61
                                    1 0 0 0 62 1 6 60 0 63 2 6 26 0 0 64 2 6 33
                                    0 0 65 2 0 26 0 0 66 2 0 26 0 0 67 2 0 33 0
                                    6 68 1 6 0 0 69 4 0 0 0 7 6 0 70 2 7 33 0 0
                                    71 2 0 33 0 0 72 2 0 0 0 6 73 2 0 26 0 0 1
                                    1 0 26 0 1 1 2 60 0 61 1 2 0 0 62 1 2 26 0
                                    1 2 0 33 0 0 1 0 0 0 1 1 5 75 0 1 1 6 76 0
                                    1 1 0 28 0 29 1 5 74 0 1 1 6 38 0 1 1 0 6 0
                                    1 1 0 0 0 25 1 0 33 0 36 1 9 0 0 1 4 0 0 0
                                    6 7 0 48 1 0 26 0 1 1 0 13 0 16 1 0 26 0 1
                                    2 0 0 6 7 1 1 0 7 0 20 2 0 0 77 0 1 2 0 0
                                    79 0 1 1 0 0 0 24 1 0 6 0 22 1 0 80 0 1 1 0
                                    82 0 1 1 0 26 0 41 1 0 6 0 1 4 10 0 0 7 6 0
                                    70 2 2 33 0 6 68 2 2 33 0 0 72 1 0 7 0 17 1
                                    9 6 0 1 1 11 0 74 1 1 2 0 0 1 1 0 0 6 35 1
                                    0 0 38 40 1 0 81 0 1 1 0 78 0 1 2 0 6 0 7
                                    30 1 3 33 0 1 0 0 13 15 3 12 0 0 0 13 57 2
                                    2 26 0 0 67 2 0 0 0 13 52 2 0 0 0 53 54 0 0
                                    0 23 0 0 0 12 2 0 26 0 0 66 2 8 0 0 6 73 1
                                    0 0 0 1 2 0 0 0 0 1 2 0 0 0 0 1 2 1 0 74 0
                                    1 2 1 0 0 74 1 2 0 0 6 0 49 2 0 0 0 6 50 2
                                    0 0 38 0 1 2 0 0 0 0 51 2 0 0 13 0 1 2 0 0
                                    53 0 1)))))
           '|lookupComplete|)) 
