
(/VERSIONCHECK 2) 

(DEFUN |DPMM;*;R2$;1| (|r| |x| $)
  (PROG (#1=#:G666 |i| #2=#:G665 #3=#:G664)
    (RETURN
     (SEQ
      (PROGN
       (LETT #3# (GETREFV #4=(QREFELT $ 6)) . #5=(|DPMM;*;R2$;1|))
       (SEQ (LETT #2# 0 . #5#) (LETT |i| 1 . #5#) (LETT #1# #4# . #5#) G190
            (COND ((QSGREATERP |i| #1#) (GO G191)))
            (SEQ
             (EXIT
              (SETELT #3# #2#
                      (SPADCALL |r| (SPADCALL |x| |i| (QREFELT $ 12))
                                (QREFELT $ 13)))))
            (LETT |i| (PROG1 (QSADD1 |i|) (LETT #2# (QSADD1 #2#) . #5#)) . #5#)
            (GO G190) G191 (EXIT NIL))
       #3#))))) 

(DEFUN |DPMM;*;M2$;2| (|m| |x| $)
  (PROG (#1=#:G668 #2=#:G667 #3=#:G669 #4=#:G675 |j| #5=#:G674 |i| #6=#:G673
         #7=#:G672)
    (RETURN
     (SEQ
      (PROGN
       (LETT #7# (GETREFV #8=(QREFELT $ 6)) . #9=(|DPMM;*;M2$;2|))
       (SEQ (LETT #6# 0 . #9#) (LETT |i| 1 . #9#) (LETT #5# #8# . #9#) G190
            (COND ((QSGREATERP |i| #5#) #10=(GO G191)))
            (SEQ
             (EXIT
              (SETELT #7# #6#
                      (PROGN
                       (LETT #1# NIL . #9#)
                       (SEQ (LETT |j| 1 . #9#) (LETT #4# (QREFELT $ 6) . #9#)
                            G190 (COND ((QSGREATERP |j| #4#) #10#))
                            (SEQ
                             (EXIT
                              (PROGN
                               (LETT #3#
                                     (SPADCALL
                                      (SPADCALL |m| |i| |j| (QREFELT $ 15))
                                      (SPADCALL |x| |j| (QREFELT $ 12))
                                      (QREFELT $ 13))
                                     . #9#)
                               (COND
                                (#1#
                                 (LETT #2# (SPADCALL #2# #3# (QREFELT $ 16))
                                       . #9#))
                                ('T
                                 (PROGN
                                  (LETT #2# #3# . #9#)
                                  (LETT #1# 'T . #9#)))))))
                            (LETT |j| (QSADD1 |j|) . #9#) #11=(GO G190) G191
                            (EXIT NIL))
                       (COND (#1# #2#) ('T (|spadConstant| $ 17)))))))
            (LETT |i| (PROG1 (QSADD1 |i|) (LETT #6# (QSADD1 #6#) . #9#)) . #9#)
            #11# G191 (EXIT NIL))
       #7#))))) 

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

(DEFUN |DirectProductMatrixModule;| (|#1| |#2| |#3| |#4|)
  (PROG (|pv$| #1=#:G693 #2=#:G694 #3=#:G695 #4=#:G696 #5=#:G697 $ |dv$| DV$4
         DV$3 DV$2 DV$1)
    (RETURN
     (PROGN
      (LETT DV$1 (|devaluate| |#1|) . #6=(|DirectProductMatrixModule|))
      (LETT DV$2 (|devaluate| |#2|) . #6#)
      (LETT DV$3 (|devaluate| |#3|) . #6#)
      (LETT DV$4 (|devaluate| |#4|) . #6#)
      (LETT |dv$| (LIST '|DirectProductMatrixModule| DV$1 DV$2 DV$3 DV$4)
            . #6#)
      (LETT $ (GETREFV 49) . #6#)
      (QSETREFV $ 0 |dv$|)
      (QSETREFV $ 3
                (LETT |pv$|
                      (|buildPredVector| 0 0
                                         (LIST (|HasCategory| |#4| '(|Field|))
                                               (|HasCategory| |#4| '(|Ring|))
                                               (|HasCategory| |#4|
                                                              '(|OrderedAbelianMonoidSup|))
                                               (LETT #5#
                                                     (|HasCategory| |#4|
                                                                    '(|OrderedRing|))
                                                     . #6#)
                                               (OR
                                                (|HasCategory| |#4|
                                                               '(|OrderedAbelianMonoidSup|))
                                                #5#)
                                               (|HasCategory| |#4| '(|Monoid|))
                                               (|HasCategory| |#4|
                                                              '(|unitsKnown|))
                                               (LETT #4#
                                                     (|HasCategory| |#4|
                                                                    '(|CommutativeRing|))
                                                     . #6#)
                                               (OR #4#
                                                   (|HasCategory| |#4|
                                                                  '(|Field|))
                                                   (|HasCategory| |#4|
                                                                  '(|Ring|)))
                                               (OR #4#
                                                   (|HasCategory| |#4|
                                                                  '(|Field|)))
                                               (OR #4#
                                                   (|HasCategory| |#4|
                                                                  '(|Ring|)))
                                               (|HasCategory| |#4| '(|Finite|))
                                               (|HasCategory| |#4|
                                                              '(|LinearlyExplicitRingOver|
                                                                (|Integer|)))
                                               (|HasCategory| |#4|
                                                              '(|PartialDifferentialRing|
                                                                (|Symbol|)))
                                               (LETT #3#
                                                     (|HasCategory| |#4|
                                                                    '(|DifferentialRing|))
                                                     . #6#)
                                               (OR #4# #3#
                                                   (|HasCategory| |#4|
                                                                  '(|Ring|))
                                                   (|HasCategory| |#4|
                                                                  '(|LinearlyExplicitRingOver|
                                                                    (|Integer|)))
                                                   (|HasCategory| |#4|
                                                                  '(|PartialDifferentialRing|
                                                                    (|Symbol|))))
                                               (|HasCategory| |#4|
                                                              '(|SetCategory|))
                                               (|HasCategory| (|Integer|)
                                                              '(|OrderedSet|))
                                               (AND
                                                (|HasCategory| |#4| '(|Ring|))
                                                (|HasCategory| |#4|
                                                               '(|LinearlyExplicitRingOver|
                                                                 (|Integer|))))
                                               (AND #3#
                                                    (|HasCategory| |#4|
                                                                   '(|Ring|)))
                                               (AND
                                                (|HasCategory| |#4| '(|Ring|))
                                                (|HasCategory| |#4|
                                                               '(|PartialDifferentialRing|
                                                                 (|Symbol|))))
                                               (OR
                                                (AND #3#
                                                     (|HasCategory| |#4|
                                                                    '(|Ring|)))
                                                (AND
                                                 (|HasCategory| |#4| '(|Ring|))
                                                 (|HasCategory| |#4|
                                                                '(|LinearlyExplicitRingOver|
                                                                  (|Integer|))))
                                                (AND
                                                 (|HasCategory| |#4| '(|Ring|))
                                                 (|HasCategory| |#4|
                                                                '(|PartialDifferentialRing|
                                                                  (|Symbol|))))
                                                (|HasCategory| |#4|
                                                               '(|Monoid|)))
                                               (LETT #2#
                                                     (AND
                                                      (|HasCategory| |#4|
                                                                     '(|SetCategory|))
                                                      (|HasCategory| |#4|
                                                                     '(|RetractableTo|
                                                                       (|Integer|))))
                                                     . #6#)
                                               (OR
                                                (AND #4#
                                                     (|HasCategory| |#4|
                                                                    '(|RetractableTo|
                                                                      (|Integer|))))
                                                (AND #3#
                                                     (|HasCategory| |#4|
                                                                    '(|RetractableTo|
                                                                      (|Integer|))))
                                                (AND
                                                 (|HasCategory| |#4|
                                                                '(|Field|))
                                                 (|HasCategory| |#4|
                                                                '(|RetractableTo|
                                                                  (|Integer|))))
                                                (AND
                                                 (|HasCategory| |#4|
                                                                '(|Finite|))
                                                 (|HasCategory| |#4|
                                                                '(|RetractableTo|
                                                                  (|Integer|))))
                                                (AND
                                                 (|HasCategory| |#4|
                                                                '(|Monoid|))
                                                 (|HasCategory| |#4|
                                                                '(|RetractableTo|
                                                                  (|Integer|))))
                                                (AND
                                                 (|HasCategory| |#4|
                                                                '(|OrderedAbelianMonoidSup|))
                                                 (|HasCategory| |#4|
                                                                '(|RetractableTo|
                                                                  (|Integer|))))
                                                (AND #5#
                                                     (|HasCategory| |#4|
                                                                    '(|RetractableTo|
                                                                      (|Integer|))))
                                                (AND
                                                 (|HasCategory| |#4| '(|Ring|))
                                                 (|HasCategory| |#4|
                                                                '(|RetractableTo|
                                                                  (|Integer|))))
                                                #2#
                                                (AND
                                                 (|HasCategory| |#4|
                                                                '(|LinearlyExplicitRingOver|
                                                                  (|Integer|)))
                                                 (|HasCategory| |#4|
                                                                '(|RetractableTo|
                                                                  (|Integer|))))
                                                (AND
                                                 (|HasCategory| |#4|
                                                                '(|PartialDifferentialRing|
                                                                  (|Symbol|)))
                                                 (|HasCategory| |#4|
                                                                '(|RetractableTo|
                                                                  (|Integer|)))))
                                               (OR #2#
                                                   (|HasCategory| |#4|
                                                                  '(|Ring|)))
                                               (LETT #1#
                                                     (AND
                                                      (|HasCategory| |#4|
                                                                     '(|SetCategory|))
                                                      (|HasCategory| |#4|
                                                                     '(|RetractableTo|
                                                                       (|Fraction|
                                                                        (|Integer|)))))
                                                     . #6#)
                                               (OR
                                                (AND #4#
                                                     (|HasCategory| |#4|
                                                                    '(|RetractableTo|
                                                                      (|Fraction|
                                                                       (|Integer|)))))
                                                (AND #3#
                                                     (|HasCategory| |#4|
                                                                    '(|RetractableTo|
                                                                      (|Fraction|
                                                                       (|Integer|)))))
                                                (AND
                                                 (|HasCategory| |#4|
                                                                '(|Field|))
                                                 (|HasCategory| |#4|
                                                                '(|RetractableTo|
                                                                  (|Fraction|
                                                                   (|Integer|)))))
                                                (AND
                                                 (|HasCategory| |#4|
                                                                '(|Finite|))
                                                 (|HasCategory| |#4|
                                                                '(|RetractableTo|
                                                                  (|Fraction|
                                                                   (|Integer|)))))
                                                (AND
                                                 (|HasCategory| |#4|
                                                                '(|Monoid|))
                                                 (|HasCategory| |#4|
                                                                '(|RetractableTo|
                                                                  (|Fraction|
                                                                   (|Integer|)))))
                                                (AND
                                                 (|HasCategory| |#4|
                                                                '(|OrderedAbelianMonoidSup|))
                                                 (|HasCategory| |#4|
                                                                '(|RetractableTo|
                                                                  (|Fraction|
                                                                   (|Integer|)))))
                                                (AND #5#
                                                     (|HasCategory| |#4|
                                                                    '(|RetractableTo|
                                                                      (|Fraction|
                                                                       (|Integer|)))))
                                                (AND
                                                 (|HasCategory| |#4| '(|Ring|))
                                                 (|HasCategory| |#4|
                                                                '(|RetractableTo|
                                                                  (|Fraction|
                                                                   (|Integer|)))))
                                                #1#
                                                (AND
                                                 (|HasCategory| |#4|
                                                                '(|LinearlyExplicitRingOver|
                                                                  (|Integer|)))
                                                 (|HasCategory| |#4|
                                                                '(|RetractableTo|
                                                                  (|Fraction|
                                                                   (|Integer|)))))
                                                (AND
                                                 (|HasCategory| |#4|
                                                                '(|PartialDifferentialRing|
                                                                  (|Symbol|)))
                                                 (|HasCategory| |#4|
                                                                '(|RetractableTo|
                                                                  (|Fraction|
                                                                   (|Integer|))))))
                                               (|HasCategory| |#4|
                                                              '(|CancellationAbelianMonoid|))
                                               (|HasCategory| |#4|
                                                              '(|AbelianSemiGroup|))
                                               (AND
                                                (|HasCategory| |#4|
                                                               '(|SetCategory|))
                                                (|HasCategory| |#4|
                                                               (LIST
                                                                '|Evalable|
                                                                (|devaluate|
                                                                 |#4|))))
                                               (OR
                                                (AND #4#
                                                     (|HasCategory| |#4|
                                                                    (LIST
                                                                     '|Evalable|
                                                                     (|devaluate|
                                                                      |#4|))))
                                                (AND #3#
                                                     (|HasCategory| |#4|
                                                                    (LIST
                                                                     '|Evalable|
                                                                     (|devaluate|
                                                                      |#4|))))
                                                (AND
                                                 (|HasCategory| |#4|
                                                                '(|Field|))
                                                 (|HasCategory| |#4|
                                                                (LIST
                                                                 '|Evalable|
                                                                 (|devaluate|
                                                                  |#4|))))
                                                (AND
                                                 (|HasCategory| |#4|
                                                                '(|Finite|))
                                                 (|HasCategory| |#4|
                                                                (LIST
                                                                 '|Evalable|
                                                                 (|devaluate|
                                                                  |#4|))))
                                                (AND
                                                 (|HasCategory| |#4|
                                                                '(|Monoid|))
                                                 (|HasCategory| |#4|
                                                                (LIST
                                                                 '|Evalable|
                                                                 (|devaluate|
                                                                  |#4|))))
                                                (AND
                                                 (|HasCategory| |#4|
                                                                '(|OrderedAbelianMonoidSup|))
                                                 (|HasCategory| |#4|
                                                                (LIST
                                                                 '|Evalable|
                                                                 (|devaluate|
                                                                  |#4|))))
                                                (AND #5#
                                                     (|HasCategory| |#4|
                                                                    (LIST
                                                                     '|Evalable|
                                                                     (|devaluate|
                                                                      |#4|))))
                                                (AND
                                                 (|HasCategory| |#4| '(|Ring|))
                                                 (|HasCategory| |#4|
                                                                (LIST
                                                                 '|Evalable|
                                                                 (|devaluate|
                                                                  |#4|))))
                                                (AND
                                                 (|HasCategory| |#4|
                                                                '(|SetCategory|))
                                                 (|HasCategory| |#4|
                                                                (LIST
                                                                 '|Evalable|
                                                                 (|devaluate|
                                                                  |#4|))))
                                                (AND
                                                 (|HasCategory| |#4|
                                                                (LIST
                                                                 '|Evalable|
                                                                 (|devaluate|
                                                                  |#4|)))
                                                 (|HasCategory| |#4|
                                                                '(|LinearlyExplicitRingOver|
                                                                  (|Integer|))))
                                                (AND
                                                 (|HasCategory| |#4|
                                                                (LIST
                                                                 '|Evalable|
                                                                 (|devaluate|
                                                                  |#4|)))
                                                 (|HasCategory| |#4|
                                                                '(|PartialDifferentialRing|
                                                                  (|Symbol|)))))))
                      . #6#))
      (|haddProp| |$ConstructorCache| '|DirectProductMatrixModule|
                  (LIST DV$1 DV$2 DV$3 DV$4) (CONS 1 $))
      (|stuffDomainSlots| $)
      (QSETREFV $ 6 |#1|)
      (QSETREFV $ 7 |#2|)
      (QSETREFV $ 8 |#3|)
      (QSETREFV $ 9 |#4|)
      (AND (|HasCategory| $ '(|finiteAggregate|))
           (|augmentPredVector| $ 2147483648))
      (AND (|HasCategory| $ '(|finiteAggregate|))
           (|HasCategory| |#4| '(|SetCategory|))
           (|augmentPredVector| $ 4294967296))
      (AND (|HasCategory| $ '(|shallowlyMutable|))
           (|augmentPredVector| $ 8589934592))
      (QSETREFV $ 10 (|Vector| |#4|))
      $)))) 

(MAKEPROP '|DirectProductMatrixModule| '|infovec|
          (LIST
           '#(NIL NIL NIL NIL NIL (|DirectProduct| 6 9) (|local| |#1|)
              (|local| |#2|) (|local| |#3|) (|local| |#4|) '|Rep| (|Integer|)
              (0 . |elt|) (6 . *) |DPMM;*;R2$;1| (12 . |elt|) (19 . +)
              (25 . |Zero|) |DPMM;*;M2$;2| (|Boolean|) (|NonNegativeInteger|)
              (|List| 9) (|Equation| 9) (|List| 22) (|Matrix| 11) (|Matrix| $)
              (|Record| (|:| |mat| 24) (|:| |vec| (|Vector| 11))) (|Vector| $)
              (|Symbol|) (|List| 28) (|List| 20) (|Fraction| 11)
              (|Union| 31 '#1="failed") (|Union| 11 '#1#) (|PositiveInteger|)
              (|Union| $ '"failed") (|Mapping| 19 9) (|Void|) (|Mapping| 9 9)
              (|CardinalNumber|) (|List| $)
              (|Record| (|:| |mat| 42) (|:| |vec| 47)) (|Matrix| 9)
              (|Union| 9 '#1#) (|SingleInteger|) (|OutputForm|) (|String|)
              (|Vector| 9) (|List| 11))
           '#(|elt| 29 * 35) 'NIL
           (CONS
            (|makeByteWordVec2| 31
                                '(0 1 8 2 2 10 4 8 2 13 14 15 9 3 4 8 16 0 0 9
                                  2 5 11 8 16 0 5 0 5 2 0 0 5 2 6 0 0 5 6 12 0
                                  0 0 31 17 0 0 0 0 0 0 31 7 8 17 27 24))
            (CONS
             '#(|DirectProductCategory&| |VectorSpace&| |Algebra&|
                |FullyLinearlyExplicitRingOver&| |DifferentialExtension&|
                |Module&| |OrderedRing&| NIL NIL NIL |PartialDifferentialRing&|
                |DifferentialRing&| NIL NIL NIL NIL |Ring&| NIL NIL NIL NIL NIL
                NIL NIL NIL |AbelianGroup&| NIL NIL NIL NIL |IndexedAggregate&|
                |AbelianMonoid&| |OrderedSet&| NIL |Monoid&|
                |HomogeneousAggregate&| |AbelianSemiGroup&| NIL |SemiGroup&|
                |Finite&| |Aggregate&| |SetCategory&| |EltableAggregate&|
                |Evalable&| |FullyRetractableTo&| NIL |BasicType&| NIL NIL NIL
                NIL |InnerEvalable&| NIL NIL |RetractableTo&| |RetractableTo&|
                |RetractableTo&|)
             (CONS
              '#((|DirectProductCategory| 6 9) (|VectorSpace| 9) (|Algebra| 9)
                 (|FullyLinearlyExplicitRingOver| 9)
                 (|DifferentialExtension| 9) (|Module| 9) (|OrderedRing|)
                 (|CommutativeRing|) (|LinearlyExplicitRingOver| 9)
                 (|LinearlyExplicitRingOver| 11) (|PartialDifferentialRing| 28)
                 (|DifferentialRing|) (|BiModule| 9 9)
                 (|OrderedAbelianMonoidSup|) (|OrderedAbelianGroup|)
                 (|BiModule| $$ $$) (|Ring|) (|LeftModule| 8) (|LeftModule| 7)
                 (|LeftModule| 9) (|RightModule| 9)
                 (|OrderedCancellationAbelianMonoid|) (|LeftModule| $$)
                 (|RightModule| $$) (|Rng|) (|AbelianGroup|)
                 (|OrderedAbelianMonoid|) (|CancellationAbelianMonoid|)
                 (|OrderedAbelianSemiGroup|) (|SemiRing|)
                 (|IndexedAggregate| 11 9) (|AbelianMonoid|) (|OrderedSet|)
                 (|SemiRng|) (|Monoid|) (|HomogeneousAggregate| 9)
                 (|AbelianSemiGroup|) (|Comparable|) (|SemiGroup|) (|Finite|)
                 (|Aggregate|) (|SetCategory|) (|EltableAggregate| 11 9)
                 (|Evalable| 9) (|FullyRetractableTo| 9) (|Type|) (|BasicType|)
                 (|finiteAggregate|) (|CoercibleTo| (|Vector| 9))
                 (|Eltable| 11 9) (|CoercibleTo| 45) (|InnerEvalable| 9 9)
                 (|unitsKnown|) (|CommutativeStar|) (|RetractableTo| 9)
                 (|RetractableTo| 31) (|RetractableTo| 11))
              (|makeByteWordVec2| 18
                                  '(2 0 9 0 11 12 2 9 0 7 0 13 3 8 7 0 11 11 15
                                    2 9 0 0 0 16 0 9 0 17 2 0 9 0 11 12 2 0 0 8
                                    0 18 2 0 0 7 0 14)))))
           '|lookupIncomplete|)) 
