
(SDEFUN |SHDP;lessThanRlex|
        ((|v1| (%)) (|v2| (%)) (|low| (|NonNegativeInteger|))
         (|high| (|NonNegativeInteger|)) (% (|Boolean|)))
        (SPROG
         ((#1=#:G22 NIL) (#2=#:G24 NIL) (|i| NIL) (|n2| (S)) (|n1| (S))
          (#3=#:G23 NIL))
         (SEQ
          (EXIT
           (SEQ (LETT |n1| (|spadConstant| % 10))
                (LETT |n2| (|spadConstant| % 10))
                (SEQ (LETT |i| |low|) (LETT #3# |high|) G190
                     (COND ((> |i| #3#) (GO G191)))
                     (SEQ
                      (LETT |n1|
                            (SPADCALL |n1| (SPADCALL |v1| |i| (QREFELT % 12))
                                      (QREFELT % 13)))
                      (EXIT
                       (LETT |n2|
                             (SPADCALL |n2| (SPADCALL |v2| |i| (QREFELT % 12))
                                       (QREFELT % 13)))))
                     (LETT |i| (+ |i| 1)) (GO G190) G191 (EXIT NIL))
                (EXIT
                 (COND ((SPADCALL |n1| |n2| (QREFELT % 15)) 'T)
                       ((SPADCALL |n2| |n1| (QREFELT % 15)) NIL)
                       ('T
                        (SEQ
                         (SEQ (LETT |i| |high|) (LETT #2# |low|) G190
                              (COND ((< |i| #2#) (GO G191)))
                              (SEQ
                               (COND
                                ((SPADCALL (SPADCALL |v2| |i| (QREFELT % 12))
                                           (SPADCALL |v1| |i| (QREFELT % 12))
                                           (QREFELT % 15))
                                 (PROGN (LETT #1# 'T) (GO #4=#:G21))))
                               (EXIT
                                (COND
                                 ((SPADCALL (SPADCALL |v1| |i| (QREFELT % 12))
                                            (SPADCALL |v2| |i| (QREFELT % 12))
                                            (QREFELT % 15))
                                  (PROGN (LETT #1# NIL) (GO #4#))))))
                              (LETT |i| (+ |i| -1)) (GO G190) G191 (EXIT NIL))
                         (EXIT NIL)))))))
          #4# (EXIT #1#)))) 

(SDEFUN |SHDP;<;2%B;2| ((|v1| (%)) (|v2| (%)) (% (|Boolean|)))
        (SPROG ((#1=#:G31 NIL) (#2=#:G32 NIL) (|i| NIL))
               (SEQ
                (EXIT
                 (COND ((|SHDP;lessThanRlex| |v1| |v2| 1 (QREFELT % 7) %) 'T)
                       ('T
                        (SEQ
                         (SEQ (LETT |i| 1) (LETT #2# (QREFELT % 7)) G190
                              (COND ((|greater_SI| |i| #2#) (GO G191)))
                              (SEQ
                               (EXIT
                                (COND
                                 ((SPADCALL (SPADCALL |v1| |i| (QREFELT % 12))
                                            (SPADCALL |v2| |i| (QREFELT % 12))
                                            (QREFELT % 16))
                                  (PROGN (LETT #1# NIL) (GO #3=#:G30))))))
                              (LETT |i| (|inc_SI| |i|)) (GO G190) G191
                              (EXIT NIL))
                         (EXIT
                          (|SHDP;lessThanRlex| |v1| |v2| (+ (QREFELT % 7) 1)
                           (QREFELT % 6) %))))))
                #3# (EXIT #1#)))) 

(DECLAIM (NOTINLINE |SplitHomogeneousDirectProduct;|)) 

(DEFUN |SplitHomogeneousDirectProduct| (&REST #1=#:G70)
  (SPROG NIL
         (PROG (#2=#:G71)
           (RETURN
            (COND
             ((LETT #2#
                    (|lassocShiftWithFunction|
                     (|devaluate_sig| #1# '(NIL NIL T))
                     (HGET |$ConstructorCache|
                           '|SplitHomogeneousDirectProduct|)
                     '|domainEqualList|))
              (|CDRwithIncrement| #2#))
             ('T
              (UNWIND-PROTECT
                  (PROG1
                      (APPLY (|function| |SplitHomogeneousDirectProduct;|) #1#)
                    (LETT #2# T))
                (COND
                 ((NOT #2#)
                  (HREM |$ConstructorCache|
                        '|SplitHomogeneousDirectProduct|)))))))))) 

(DEFUN |SplitHomogeneousDirectProduct;| (|#1| |#2| |#3|)
  (SPROG
   ((|pv$| NIL) (#1=#:G60 NIL) (#2=#:G61 NIL) (#3=#:G62 NIL) (#4=#:G63 NIL)
    (#5=#:G64 NIL) (#6=#:G66 NIL) (#7=#:G65 NIL) (#8=#:G67 NIL) (#9=#:G68 NIL)
    (#10=#:G69 NIL) (% NIL) (|dv$| NIL) (DV$3 NIL) (DV$2 NIL) (DV$1 NIL))
   (PROGN
    (LETT DV$1 |#1|)
    (LETT DV$2 |#2|)
    (LETT DV$3 (|devaluate| |#3|))
    (LETT |dv$| (LIST '|SplitHomogeneousDirectProduct| DV$1 DV$2 DV$3))
    (LETT % (GETREFV 49))
    (QSETREFV % 0 |dv$|)
    (QSETREFV % 3
              (LETT |pv$|
                    (|buildPredVector| 0 0
                                       (LIST
                                        (|HasCategory| |#3|
                                                       '(|OrderedAbelianMonoidSup|))
                                        (OR
                                         (|HasCategory| |#3|
                                                        '(|OrderedAbelianMonoid|))
                                         (|HasCategory| |#3|
                                                        '(|OrderedAbelianMonoidSup|)))
                                        (LETT #10#
                                              (|HasCategory| |#3|
                                                             '(|OrderedSet|)))
                                        (OR
                                         (|HasCategory| |#3|
                                                        '(|OrderedAbelianMonoid|))
                                         (|HasCategory| |#3|
                                                        '(|OrderedAbelianMonoidSup|))
                                         #10#)
                                        (|HasCategory| |#3| '(|unitsKnown|))
                                        (|HasCategory| |#3|
                                                       '(|CommutativeRing|))
                                        (|HasCategory| |#3| '(|AbelianGroup|))
                                        (|HasCategory| |#3| '(|SemiRng|))
                                        (|HasCategory| |#3| '(|Ring|))
                                        (|HasCategory| |#3| '(|Monoid|))
                                        (OR
                                         (|HasCategory| |#3|
                                                        '(|CommutativeRing|))
                                         (|HasCategory| |#3| '(|SemiRng|)))
                                        (LETT #9#
                                              (|HasCategory| |#3| '(|Finite|)))
                                        (OR #9#
                                            (|HasCategory| |#3|
                                                           '(|OrderedAbelianMonoid|))
                                            (|HasCategory| |#3|
                                                           '(|OrderedAbelianMonoidSup|))
                                            #10#)
                                        (OR (|HasCategory| |#3| '(|Ring|))
                                            (|HasCategory| |#3| '(|SemiRng|)))
                                        (|HasCategory| |#3|
                                                       '(|PartialDifferentialRing|
                                                         (|Symbol|)))
                                        (LETT #8#
                                              (|HasCategory| |#3|
                                                             '(|DifferentialRing|)))
                                        (OR
                                         (|HasCategory| |#3|
                                                        '(|PartialDifferentialRing|
                                                          (|Symbol|)))
                                         (|HasCategory| |#3|
                                                        '(|CommutativeRing|))
                                         #8# (|HasCategory| |#3| '(|Ring|))
                                         (|HasCategory| |#3| '(|SemiRng|)))
                                        (OR
                                         (|HasCategory| |#3|
                                                        '(|PartialDifferentialRing|
                                                          (|Symbol|)))
                                         (|HasCategory| |#3|
                                                        '(|CommutativeRing|))
                                         #8# (|HasCategory| |#3| '(|Ring|)))
                                        (|HasCategory| |#3| '(|SetCategory|))
                                        (AND
                                         (|HasCategory| |#3|
                                                        (LIST '|Evalable|
                                                              (|devaluate|
                                                               |#3|)))
                                         (|HasCategory| |#3| '(|SetCategory|)))
                                        (|HasCategory| |#3| '(|BasicType|))
                                        (|HasCategory| (|Integer|)
                                                       '(|OrderedSet|))
                                        (OR #9# #10#)
                                        (AND #8#
                                             (|HasCategory| |#3| '(|Ring|)))
                                        (AND
                                         (|HasCategory| |#3|
                                                        '(|PartialDifferentialRing|
                                                          (|Symbol|)))
                                         (|HasCategory| |#3| '(|Ring|)))
                                        (LETT #7#
                                              (|HasCategory| |#3|
                                                             '(|LinearlyExplicitOver|
                                                               (|Integer|))))
                                        (LETT #6#
                                              (AND
                                               (|HasCategory| |#3|
                                                              '(|LinearlyExplicitOver|
                                                                (|Integer|)))
                                               (|HasCategory| |#3| '(|Ring|))))
                                        (OR
                                         (AND #7#
                                              (|HasCategory| |#3|
                                                             '(|PartialDifferentialRing|
                                                               (|Symbol|))))
                                         (AND #7#
                                              (|HasCategory| |#3|
                                                             '(|CommutativeRing|)))
                                         (AND #7# #8#) #6#)
                                        (|HasCategory| (|Integer|)
                                                       '(|AbelianMonoid|))
                                        (LETT #5#
                                              (|HasCategory| |#3|
                                                             '(|AbelianMonoid|)))
                                        (AND #5#
                                             (|HasCategory| |#3| '(|Monoid|)))
                                        (AND #5#
                                             (|HasCategory| |#3| '(|SemiRng|)))
                                        (|HasCategory| (|Integer|)
                                                       '(|AbelianGroup|))
                                        (LETT #4#
                                              (|HasCategory| |#3|
                                                             '(|CancellationAbelianMonoid|)))
                                        (OR
                                         (|HasCategory| |#3| '(|AbelianGroup|))
                                         #5# #4#)
                                        (OR
                                         (|HasCategory| |#3| '(|AbelianGroup|))
                                         #4#)
                                        (OR
                                         (|HasCategory| |#3|
                                                        '(|PartialDifferentialRing|
                                                          (|Symbol|)))
                                         (|HasCategory| |#3| '(|AbelianGroup|))
                                         #5# #4#
                                         (|HasCategory| |#3|
                                                        '(|CommutativeRing|))
                                         #8# (|HasCategory| |#3| '(|Ring|))
                                         (|HasCategory| |#3| '(|SemiRng|)))
                                        (LETT #3#
                                              (|HasCategory| |#3|
                                                             '(|SemiGroup|)))
                                        (OR
                                         (AND
                                          (|HasCategory| |#3|
                                                         (LIST '|Evalable|
                                                               (|devaluate|
                                                                |#3|)))
                                          (|HasCategory| |#3|
                                                         '(|PartialDifferentialRing|
                                                           (|Symbol|))))
                                         (AND
                                          (|HasCategory| |#3|
                                                         (LIST '|Evalable|
                                                               (|devaluate|
                                                                |#3|)))
                                          #4#)
                                         (AND
                                          (|HasCategory| |#3|
                                                         (LIST '|Evalable|
                                                               (|devaluate|
                                                                |#3|)))
                                          (|HasCategory| |#3|
                                                         '(|CommutativeRing|)))
                                         (AND
                                          (|HasCategory| |#3|
                                                         (LIST '|Evalable|
                                                               (|devaluate|
                                                                |#3|)))
                                          #8#)
                                         (AND
                                          (|HasCategory| |#3|
                                                         (LIST '|Evalable|
                                                               (|devaluate|
                                                                |#3|)))
                                          #9#)
                                         (AND
                                          (|HasCategory| |#3|
                                                         (LIST '|Evalable|
                                                               (|devaluate|
                                                                |#3|)))
                                          (|HasCategory| |#3| '(|Monoid|)))
                                         (AND
                                          (|HasCategory| |#3|
                                                         (LIST '|Evalable|
                                                               (|devaluate|
                                                                |#3|)))
                                          (|HasCategory| |#3|
                                                         '(|OrderedAbelianMonoid|)))
                                         (AND
                                          (|HasCategory| |#3|
                                                         (LIST '|Evalable|
                                                               (|devaluate|
                                                                |#3|)))
                                          (|HasCategory| |#3|
                                                         '(|OrderedAbelianMonoidSup|)))
                                         (AND
                                          (|HasCategory| |#3|
                                                         (LIST '|Evalable|
                                                               (|devaluate|
                                                                |#3|)))
                                          #10#)
                                         (AND
                                          (|HasCategory| |#3|
                                                         (LIST '|Evalable|
                                                               (|devaluate|
                                                                |#3|)))
                                          (|HasCategory| |#3| '(|Ring|)))
                                         (AND
                                          (|HasCategory| |#3|
                                                         (LIST '|Evalable|
                                                               (|devaluate|
                                                                |#3|)))
                                          #3#)
                                         (AND
                                          (|HasCategory| |#3|
                                                         (LIST '|Evalable|
                                                               (|devaluate|
                                                                |#3|)))
                                          (|HasCategory| |#3| '(|SemiRng|)))
                                         (AND
                                          (|HasCategory| |#3|
                                                         (LIST '|Evalable|
                                                               (|devaluate|
                                                                |#3|)))
                                          (|HasCategory| |#3|
                                                         '(|SetCategory|))))
                                        (OR (|HasCategory| |#3| '(|Monoid|))
                                            #3#)
                                        (OR
                                         (|HasCategory| |#3|
                                                        '(|PartialDifferentialRing|
                                                          (|Symbol|)))
                                         (|HasCategory| |#3| '(|AbelianGroup|))
                                         #5#
                                         (|HasCategory| |#3| '(|BasicType|))
                                         #4#
                                         (|HasCategory| |#3|
                                                        '(|CommutativeRing|))
                                         #8# #9#
                                         (|HasCategory| |#3| '(|Monoid|))
                                         (|HasCategory| |#3|
                                                        '(|OrderedAbelianMonoid|))
                                         (|HasCategory| |#3|
                                                        '(|OrderedAbelianMonoidSup|))
                                         #10# (|HasCategory| |#3| '(|Ring|))
                                         #3# (|HasCategory| |#3| '(|SemiRng|))
                                         (|HasCategory| |#3| '(|SetCategory|)))
                                        (OR
                                         (|HasCategory| |#3|
                                                        '(|PartialDifferentialRing|
                                                          (|Symbol|)))
                                         (|HasCategory| |#3| '(|AbelianGroup|))
                                         #5# #4#
                                         (|HasCategory| |#3|
                                                        '(|CommutativeRing|))
                                         #8# #9#
                                         (|HasCategory| |#3| '(|Monoid|))
                                         (|HasCategory| |#3|
                                                        '(|OrderedAbelianMonoid|))
                                         (|HasCategory| |#3|
                                                        '(|OrderedAbelianMonoidSup|))
                                         #10# (|HasCategory| |#3| '(|Ring|))
                                         #3# (|HasCategory| |#3| '(|SemiRng|))
                                         (|HasCategory| |#3| '(|SetCategory|)))
                                        (OR #5#
                                            (|HasCategory| |#3| '(|SemiRng|)))
                                        (|HasCategory| |#3|
                                                       '(|CoercibleTo|
                                                         (|OutputForm|)))
                                        (LETT #2#
                                              (AND
                                               (|HasCategory| |#3|
                                                              '(|RetractableTo|
                                                                (|Integer|)))
                                               (|HasCategory| |#3|
                                                              '(|SetCategory|))))
                                        (OR
                                         (AND
                                          (|HasCategory| |#3|
                                                         '(|PartialDifferentialRing|
                                                           (|Symbol|)))
                                          (|HasCategory| |#3|
                                                         '(|RetractableTo|
                                                           (|Integer|))))
                                         (AND
                                          (|HasCategory| |#3|
                                                         '(|RetractableTo|
                                                           (|Integer|)))
                                          #4#)
                                         (AND
                                          (|HasCategory| |#3|
                                                         '(|RetractableTo|
                                                           (|Integer|)))
                                          (|HasCategory| |#3|
                                                         '(|CommutativeRing|)))
                                         (AND
                                          (|HasCategory| |#3|
                                                         '(|RetractableTo|
                                                           (|Integer|)))
                                          #8#)
                                         (AND
                                          (|HasCategory| |#3|
                                                         '(|RetractableTo|
                                                           (|Integer|)))
                                          #9#)
                                         (AND
                                          (|HasCategory| |#3|
                                                         '(|RetractableTo|
                                                           (|Integer|)))
                                          (|HasCategory| |#3| '(|Monoid|)))
                                         (AND
                                          (|HasCategory| |#3|
                                                         '(|RetractableTo|
                                                           (|Integer|)))
                                          (|HasCategory| |#3|
                                                         '(|OrderedAbelianMonoid|)))
                                         (AND
                                          (|HasCategory| |#3|
                                                         '(|RetractableTo|
                                                           (|Integer|)))
                                          (|HasCategory| |#3|
                                                         '(|OrderedAbelianMonoidSup|)))
                                         (AND
                                          (|HasCategory| |#3|
                                                         '(|RetractableTo|
                                                           (|Integer|)))
                                          #10#)
                                         (AND
                                          (|HasCategory| |#3|
                                                         '(|RetractableTo|
                                                           (|Integer|)))
                                          (|HasCategory| |#3| '(|Ring|)))
                                         (AND
                                          (|HasCategory| |#3|
                                                         '(|RetractableTo|
                                                           (|Integer|)))
                                          #3#)
                                         (AND
                                          (|HasCategory| |#3|
                                                         '(|RetractableTo|
                                                           (|Integer|)))
                                          (|HasCategory| |#3| '(|SemiRng|)))
                                         #2#)
                                        (OR #2# (|HasCategory| |#3| '(|Ring|)))
                                        (LETT #1#
                                              (AND
                                               (|HasCategory| |#3|
                                                              '(|RetractableTo|
                                                                (|Fraction|
                                                                 (|Integer|))))
                                               (|HasCategory| |#3|
                                                              '(|SetCategory|))))
                                        (OR
                                         (|HasCategory| |#3|
                                                        '(|CoercibleTo|
                                                          (|OutputForm|)))
                                         (AND
                                          (|HasCategory| |#3|
                                                         (LIST '|Evalable|
                                                               (|devaluate|
                                                                |#3|)))
                                          (|HasCategory| |#3|
                                                         '(|SetCategory|)))
                                         #6# #1# #2#
                                         (AND
                                          (|HasCategory| |#3|
                                                         '(|AbelianGroup|))
                                          (|HasCategory| |#3| '(|Ring|)))
                                         (AND
                                          (|HasCategory| |#3|
                                                         '(|AbelianGroup|))
                                          (|HasCategory| |#3| '(|SemiRng|)))
                                         (AND #5#
                                              (|HasCategory| |#3| '(|Ring|)))
                                         (AND #5#
                                              (|HasCategory| |#3|
                                                             '(|SemiRng|))))
                                        (OR
                                         (AND
                                          (|HasCategory| |#3|
                                                         '(|PartialDifferentialRing|
                                                           (|Symbol|)))
                                          (|HasCategory| |#3|
                                                         '(|RetractableTo|
                                                           (|Fraction|
                                                            (|Integer|)))))
                                         (AND
                                          (|HasCategory| |#3|
                                                         '(|RetractableTo|
                                                           (|Fraction|
                                                            (|Integer|))))
                                          #4#)
                                         (AND
                                          (|HasCategory| |#3|
                                                         '(|RetractableTo|
                                                           (|Fraction|
                                                            (|Integer|))))
                                          (|HasCategory| |#3|
                                                         '(|CommutativeRing|)))
                                         (AND
                                          (|HasCategory| |#3|
                                                         '(|RetractableTo|
                                                           (|Fraction|
                                                            (|Integer|))))
                                          #8#)
                                         (AND
                                          (|HasCategory| |#3|
                                                         '(|RetractableTo|
                                                           (|Fraction|
                                                            (|Integer|))))
                                          #9#)
                                         (AND
                                          (|HasCategory| |#3|
                                                         '(|RetractableTo|
                                                           (|Fraction|
                                                            (|Integer|))))
                                          (|HasCategory| |#3| '(|Monoid|)))
                                         (AND
                                          (|HasCategory| |#3|
                                                         '(|RetractableTo|
                                                           (|Fraction|
                                                            (|Integer|))))
                                          (|HasCategory| |#3|
                                                         '(|OrderedAbelianMonoid|)))
                                         (AND
                                          (|HasCategory| |#3|
                                                         '(|RetractableTo|
                                                           (|Fraction|
                                                            (|Integer|))))
                                          (|HasCategory| |#3|
                                                         '(|OrderedAbelianMonoidSup|)))
                                         (AND
                                          (|HasCategory| |#3|
                                                         '(|RetractableTo|
                                                           (|Fraction|
                                                            (|Integer|))))
                                          #10#)
                                         (AND
                                          (|HasCategory| |#3|
                                                         '(|RetractableTo|
                                                           (|Fraction|
                                                            (|Integer|))))
                                          (|HasCategory| |#3| '(|Ring|)))
                                         (AND
                                          (|HasCategory| |#3|
                                                         '(|RetractableTo|
                                                           (|Fraction|
                                                            (|Integer|))))
                                          #3#)
                                         (AND
                                          (|HasCategory| |#3|
                                                         '(|RetractableTo|
                                                           (|Fraction|
                                                            (|Integer|))))
                                          (|HasCategory| |#3| '(|SemiRng|)))
                                         #1#)))))
    (|haddProp| |$ConstructorCache| '|SplitHomogeneousDirectProduct|
                (LIST DV$1 DV$2 DV$3) (CONS 1 %))
    (|stuffDomainSlots| %)
    (QSETREFV % 6 |#1|)
    (QSETREFV % 7 |#2|)
    (QSETREFV % 8 |#3|)
    (AND (|HasCategory| % '(|finiteAggregate|))
         (|augmentPredVector| % 1125899906842624))
    (AND #10# (|HasCategory| % '(|finiteAggregate|))
         (|augmentPredVector| % 2251799813685248))
    (AND (|HasCategory| |#3| '(|BasicType|))
         (|HasCategory| % '(|finiteAggregate|))
         (|augmentPredVector| % 4503599627370496))
    (AND (|HasCategory| % '(|shallowlyMutable|))
         (|augmentPredVector| % 9007199254740992))
    (AND
     (OR
      (AND #7# (|HasCategory| |#3| '(|Ring|))
           (|HasCategory| (|Integer|) '(|AbelianMonoid|)))
      #5#
      (AND (|HasCategory| |#3| '(|SemiRng|))
           (|HasCategory| % '(|AbelianMonoid|))))
     (|augmentPredVector| % 18014398509481984))
    (AND
     (OR
      (AND #7# (|HasCategory| |#3| '(|Ring|))
           (|HasCategory| (|Integer|) '(|AbelianGroup|)))
      (AND (|HasCategory| |#3| '(|AbelianGroup|))
           (|HasCategory| |#3| '(|Ring|)))
      (AND (|HasCategory| |#3| '(|AbelianGroup|))
           (|HasCategory| |#3| '(|SemiRng|)))
      #4#
      (AND (|HasCategory| |#3| '(|SemiRng|))
           (|HasCategory| % '(|AbelianGroup|))))
     (|augmentPredVector| % 36028797018963968))
    (AND
     (OR
      (AND #7# (|HasCategory| |#3| '(|Ring|))
           (|HasCategory| (|Integer|) '(|AbelianGroup|)))
      (|HasCategory| |#3| '(|AbelianGroup|))
      (AND (|HasCategory| |#3| '(|SemiRng|))
           (|HasCategory| % '(|AbelianGroup|))))
     (|augmentPredVector| % 72057594037927936))
    (AND
     (OR
      (AND (|HasCategory| |#3| '(|BasicType|))
           (|HasCategory| % '(|finiteAggregate|)))
      (|HasCategory| |#3| '(|SetCategory|)))
     (|augmentPredVector| % 144115188075855872))
    (SETF |pv$| (QREFELT % 3))
    (QSETREFV % 9 (|Vector| |#3|))
    %))) 

(MAKEPROP '|SplitHomogeneousDirectProduct| '|infovec|
          (LIST
           '#(NIL NIL NIL NIL NIL (|DirectProduct| (NRTEVAL (QREFELT % 6)) 8)
              (|local| |#1|) (|local| |#2|) (|local| |#3|) '|Rep| (0 . |Zero|)
              (|Integer|) (4 . |qelt|) (10 . +) (|Boolean|) (16 . <) (22 . ~=)
              |SHDP;<;2%B;2| (|NonNegativeInteger|) (|Mapping| 8 8) (|List| 8)
              (|List| 11) (|Vector| 8) (|PositiveInteger|) (|List| 25)
              (|Equation| 8) (|Matrix| 11) (|Matrix| %)
              (|Record| (|:| |mat| 26) (|:| |vec| (|Vector| 11))) (|Vector| %)
              (|List| 31) (|Symbol|) (|List| 18) (|Fraction| 11)
              (|Union| 33 '#1="failed") (|Union| 11 '#1#) (|Union| % '"failed")
              (|Mapping| 14 8) (|Mapping| 14 8 8) (|Void|) (|OutputForm|)
              (|List| %) (|HashState|) (|SingleInteger|) (|InputForm|)
              (|Record| (|:| |mat| 46) (|:| |vec| 22)) (|Matrix| 8) (|String|)
              (|Union| 8 '#1#))
           '#(~= 28 |zero?| 34 |unitVector| 39 |swap!| 44 |sup| 51
              |subtractIfCan| 57 |smaller?| 63 |size?| 69 |size| 75 |setelt!|
              79 |sample| 86 |rightRecip| 90 |rightPower| 95 |retractIfCan| 107
              |retract| 122 |reducedSystem| 137 |recip| 159 |random| 164
              |qsetelt!| 168 |qelt| 175 |plenaryPower| 181 |parts| 187
              |opposite?| 192 |one?| 198 |more?| 203 |minIndex| 209 |min| 214
              |members| 225 |member?| 230 |maxIndex| 236 |max| 241 |map!| 258
              |map| 264 |lookup| 270 |less?| 275 |leftRecip| 281 |leftPower|
              286 |latex| 298 |inf| 303 |indices| 309 |index?| 314 |index| 320
              |hashUpdate!| 325 |hash| 331 |first| 336 |fill!| 341 |every?| 347
              |eval| 353 |eq?| 379 |enumerate| 385 |entry?| 389 |entries| 395
              |empty?| 400 |empty| 405 |elt| 409 |dot| 422 |directProduct| 428
              |differentiate| 433 |count| 483 |copy| 495 |convert| 500
              |commutator| 505 |coerce| 511 |characteristic| 541 |associator|
              545 |any?| 552 |antiCommutator| 558 |annihilate?| 564 ^ 570
              |Zero| 582 |One| 586 D 590 >= 640 > 646 = 652 <= 658 < 664 - 670
              + 681 * 687 |#| 729)
           'NIL
           (CONS
            (|makeByteWordVec2| 50
                                '(0 9 6 16 15 6 6 18 18 6 6 9 9 6 6 8 28 9 11
                                  11 9 1 18 28 14 11 11 8 1 0 7 2 10 9 36 2 17
                                  40 12 10 35 4 0 19 37 40 13 0 46 50 19 42 12
                                  6 39 0 0 46 50 19 41 12 6 5 3 49 39 0 0 0 0))
            (CONS
             '#(|DirectProductCategory&| |DifferentialExtension&| NIL
                |DifferentialRing&| |PartialDifferentialRing&| |Algebra&|
                |Algebra&| NIL |Rng&| |NonAssociativeAlgebra&|
                |NonAssociativeAlgebra&| NIL |FullyLinearlyExplicitOver&|
                |Module&| |Module&| NIL NIL NIL NIL NIL |NonAssociativeRing&|
                NIL |NonAssociativeRng&| NIL NIL NIL NIL NIL NIL NIL
                |AbelianGroup&| NIL NIL NIL NIL NIL |NonAssociativeSemiRng&|
                NIL |Finite&| |MagmaWithUnit&| |AbelianMonoid&| |OrderedSet&|
                |IndexedAggregate&| |FullyRetractableTo&| |AbelianSemiGroup&|
                |Magma&| NIL |HomogeneousAggregate&| |RetractableTo&|
                |RetractableTo&| |RetractableTo&| |SetCategory&| |Hashable&|
                NIL |Evalable&| |EltableAggregate&| |Aggregate&| NIL NIL NIL
                |BasicType&| NIL NIL NIL |PartialOrder&| NIL |InnerEvalable&|
                NIL NIL NIL NIL)
             (CONS
              '#((|DirectProductCategory| 6 8) (|DifferentialExtension| 8)
                 (|CommutativeRing|) (|DifferentialRing|)
                 (|PartialDifferentialRing| 31) (|Algebra| 8) (|Algebra| $$)
                 (|Ring|) (|Rng|) (|NonAssociativeAlgebra| 8)
                 (|NonAssociativeAlgebra| $$) (|SemiRing|)
                 (|FullyLinearlyExplicitOver| 8) (|Module| 8) (|Module| $$)
                 (|SemiRng|) (|LinearlyExplicitOver| 11)
                 (|LinearlyExplicitOver| 8) (|BiModule| 8 8) (|BiModule| $$ $$)
                 (|NonAssociativeRing|) (|OrderedAbelianMonoidSup|)
                 (|NonAssociativeRng|) (|RightModule| 11) (|RightModule| 8)
                 (|LeftModule| 8) (|LeftModule| $$) (|RightModule| $$)
                 (|OrderedCancellationAbelianMonoid|)
                 (|AbelianProductCategory| 8) (|AbelianGroup|)
                 (|OrderedAbelianMonoid|) (|Monoid|) (|NonAssociativeSemiRing|)
                 (|CancellationAbelianMonoid|) (|OrderedAbelianSemiGroup|)
                 (|NonAssociativeSemiRng|) (|SemiGroup|) (|Finite|)
                 (|MagmaWithUnit|) (|AbelianMonoid|) (|OrderedSet|)
                 (|IndexedAggregate| 11 8) (|FullyRetractableTo| 8)
                 (|AbelianSemiGroup|) (|Magma|) (|Comparable|)
                 (|HomogeneousAggregate| 8) (|RetractableTo| 11)
                 (|RetractableTo| 33) (|RetractableTo| 8) (|SetCategory|)
                 (|Hashable|) (|CommutativeStar|) (|Evalable| 8)
                 (|EltableAggregate| 11 8) (|Aggregate|) (|CoercibleFrom| 11)
                 (|CoercibleFrom| 33) (|CoercibleFrom| 8) (|BasicType|)
                 (|ConvertibleTo| 44) (|TwoSidedRecip|) (|unitsKnown|)
                 (|PartialOrder|) (|CoercibleTo| 40) (|InnerEvalable| 8 8)
                 (|Eltable| 11 8) (|CoercibleTo| (|Vector| 8))
                 (|finiteAggregate|) (|Type|))
              (|makeByteWordVec2| 58
                                  '(0 8 0 10 2 0 8 0 11 12 2 8 0 0 0 13 2 8 14
                                    0 0 15 2 8 14 0 0 16 2 58 14 0 0 1 1 55 14
                                    0 1 1 31 0 23 1 3 54 39 0 11 11 1 2 1 0 0 0
                                    1 2 56 36 0 0 1 2 23 14 0 0 1 2 0 14 0 18 1
                                    0 12 18 1 3 54 8 0 11 8 1 0 0 0 1 1 10 36 0
                                    1 2 10 0 0 18 1 2 38 0 0 23 1 1 48 34 0 1 1
                                    45 35 0 1 1 19 48 0 1 1 48 33 0 1 1 45 11 0
                                    1 1 19 8 0 1 1 27 26 27 1 2 27 28 27 29 1 2
                                    9 45 27 29 1 1 9 46 27 1 1 10 36 0 1 0 12 0
                                    1 3 54 8 0 11 8 1 2 0 8 0 11 12 2 6 0 0 23
                                    1 1 51 20 0 1 2 55 14 0 0 1 1 10 14 0 1 2 0
                                    14 0 18 1 1 22 11 0 1 1 52 8 0 1 2 3 0 0 0
                                    1 1 51 20 0 1 2 53 14 8 0 1 1 22 11 0 1 1
                                    52 8 0 1 2 51 8 38 0 1 2 3 0 0 0 1 2 54 0
                                    19 0 1 2 0 0 19 0 1 1 12 23 0 1 2 0 14 0 18
                                    1 1 10 36 0 1 2 10 0 0 18 1 2 38 0 0 23 1 1
                                    19 47 0 1 2 1 0 0 0 1 1 0 21 0 1 2 0 14 11
                                    0 1 1 12 0 23 1 2 12 42 42 0 1 1 12 43 0 1
                                    1 22 8 0 1 2 54 0 0 8 1 2 51 14 37 0 1 2 20
                                    0 0 24 1 3 20 0 0 8 8 1 2 20 0 0 25 1 3 20
                                    0 0 20 20 1 2 0 14 0 0 1 0 12 41 1 2 53 14
                                    8 0 1 1 0 20 0 1 1 0 14 0 1 0 0 0 1 2 0 8 0
                                    11 1 3 0 8 0 11 8 1 2 32 8 0 0 1 1 0 0 22 1
                                    1 24 0 0 1 2 24 0 0 18 1 2 25 0 0 30 1 2 25
                                    0 0 31 1 3 25 0 0 30 32 1 3 25 0 0 31 18 1
                                    2 9 0 0 19 1 3 9 0 0 19 18 1 2 53 18 8 0 1
                                    2 51 18 37 0 1 1 0 0 0 1 1 12 44 0 1 2 9 0
                                    0 0 1 1 0 22 0 1 1 48 0 33 1 1 47 0 11 1 1
                                    44 40 0 1 1 6 0 0 1 1 19 0 8 1 0 9 18 1 3 9
                                    0 0 0 0 1 2 51 14 37 0 1 2 8 0 0 0 1 2 9 14
                                    0 0 1 2 10 0 0 18 1 2 38 0 0 23 1 0 55 0 1
                                    0 10 0 1 1 24 0 0 1 2 24 0 0 18 1 2 25 0 0
                                    30 1 2 25 0 0 31 1 3 25 0 0 30 32 1 3 25 0
                                    0 31 18 1 2 9 0 0 19 1 3 9 0 0 19 18 1 2 3
                                    14 0 0 1 2 3 14 0 0 1 2 58 14 0 0 1 2 3 14
                                    0 0 1 2 3 14 0 0 17 2 57 0 0 0 1 1 57 0 0 1
                                    2 43 0 0 0 1 2 27 0 0 11 1 2 57 0 11 0 1 2
                                    55 0 18 0 1 2 43 0 23 0 1 2 38 0 8 0 1 2 38
                                    0 0 8 1 2 38 0 0 0 1 1 51 18 0 1)))))
           '|lookupComplete|)) 
