
(/VERSIONCHECK 2) 

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

(DEFUN |DPMM;*;M2$;2| (|m| |x| $)
  (PROG (#0=#:G1826 #1=#:G1827 |i| #2=#:G1828 |j| #3=#:G1829 #4=#:G1823
            #5=#:G1821 #6=#:G1822)
    (RETURN
      (SEQ (PRIMVEC2ARR
               (PROGN
                 (LETT #0# (GETREFV #7=(QREFELT $ 6))
                       . #8=(|DPMM;*;M2$;2|))
                 (SEQ (LETT #1# 0 . #8#) (LETT |i| 1 . #8#)
                      (LETT #2# #7# . #8#) G190
                      (COND ((QSGREATERP |i| #2#) #9=(GO G191)))
                      (SEQ (EXIT (SETELT #0# #1#
                                         (PROGN
                                           (LETT #6# NIL . #8#)
                                           (SEQ (LETT |j| 1 . #8#)
                                            (LETT #3#
                                             (QREFELT $ 6) . #8#)
                                            G190
                                            (COND
                                              ((QSGREATERP |j| #3#)
                                               #9#))
                                            (SEQ
                                             (EXIT
                                              (PROGN
                                                (LETT #4#
                                                 (SPADCALL
                                                  (SPADCALL |m| |i| |j|
                                                   (QREFELT $ 15))
                                                  (SPADCALL |x| |j|
                                                   (QREFELT $ 12))
                                                  (QREFELT $ 13)) . #8#)
                                                (COND
                                                  (#6#
                                                   (LETT #5#
                                                    (SPADCALL #5# #4#
                                                     (QREFELT $ 16)) . #8#))
                                                  ('T
                                                   (PROGN
                                                     (LETT #5#
                                                      #4# . #8#)
                                                     (LETT #6#
                                                      'T . #8#)))))))
                                            (LETT |j|
                                             (QSADD1 |j|) . #8#)
                                            #10=(GO G190) G191
                                            (EXIT NIL))
                                           (COND
                                             (#6# #5#)
                                             ('T (|spadConstant| $ 17)))))))
                      (LETT |i|
                            (PROG1 (QSADD1 |i|)
                              (LETT #1# (QSADD1 #1#) . #8#)) . #8#)
                      #10# G191 (EXIT NIL))
                 #0#)))))) 

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

(DEFUN |DirectProductMatrixModule;| (|#1| |#2| |#3| |#4|)
  (PROG (DV$1 DV$2 DV$3 DV$4 |dv$| $ #0=#:G1851 #1=#:G1850 #2=#:G1849
              #3=#:G1848 #4=#:G1847 |pv$|)
    (RETURN
      (PROGN
        (LETT DV$1 (|devaluate| |#1|)
              . #5=(|DirectProductMatrixModule|))
        (LETT DV$2 (|devaluate| |#2|) . #5#)
        (LETT DV$3 (|devaluate| |#3|) . #5#)
        (LETT DV$4 (|devaluate| |#4|) . #5#)
        (LETT |dv$|
              (LIST '|DirectProductMatrixModule| DV$1 DV$2 DV$3 DV$4) . #5#)
        (LETT $ (GETREFV 49) . #5#)
        (QSETREFV $ 0 |dv$|)
        (QSETREFV $ 3
            (LETT |pv$|
                  (|buildPredVector| 0 0
                      (LIST (|HasCategory| |#4| '(|Field|))
                            (|HasCategory| |#4| '(|Ring|))
                            (|HasCategory| |#4|
                                '(|OrderedAbelianMonoidSup|))
                            (LETT #0#
                                  (|HasCategory| |#4| '(|OrderedRing|)) . #5#)
                            (OR (|HasCategory| |#4|
                                    '(|OrderedAbelianMonoidSup|))
                                #0#)
                            (|HasCategory| |#4| '(|Monoid|))
                            (|HasCategory| |#4| '(|unitsKnown|))
                            (LETT #1#
                                  (|HasCategory| |#4|
                                      '(|CommutativeRing|)) . #5#)
                            (OR #1# (|HasCategory| |#4| '(|Field|))
                                (|HasCategory| |#4| '(|Ring|)))
                            (OR #1# (|HasCategory| |#4| '(|Field|)))
                            (OR #1# (|HasCategory| |#4| '(|Ring|)))
                            (|HasCategory| |#4| '(|Finite|))
                            (|HasCategory| |#4|
                                '(|LinearlyExplicitRingOver|
                                     (|Integer|)))
                            (|HasCategory| |#4|
                                '(|PartialDifferentialRing| (|Symbol|)))
                            (LETT #2#
                                  (|HasCategory| |#4|
                                      '(|DifferentialRing|)) . #5#)
                            (OR (|HasCategory| |#4|
                                    '(|LinearlyExplicitRingOver|
                                      (|Integer|)))
                                (|HasCategory| |#4|
                                    '(|PartialDifferentialRing|
                                      (|Symbol|)))
                                #1# #2# (|HasCategory| |#4| '(|Ring|)))
                            (|HasCategory| |#4| '(|SetCategory|))
                            (|HasCategory| (|Integer|) '(|OrderedSet|))
                            (AND (|HasCategory| |#4| '(|Ring|))
                                 (|HasCategory| |#4|
                                     '(|LinearlyExplicitRingOver|
                                       (|Integer|))))
                            (AND #2# (|HasCategory| |#4| '(|Ring|)))
                            (AND (|HasCategory| |#4| '(|Ring|))
                                 (|HasCategory| |#4|
                                     '(|PartialDifferentialRing|
                                       (|Symbol|))))
                            (OR (AND #2#
                                     (|HasCategory| |#4| '(|Ring|)))
                                (|HasCategory| |#4| '(|Monoid|))
                                (AND (|HasCategory| |#4| '(|Ring|))
                                     (|HasCategory| |#4|
                                      '(|LinearlyExplicitRingOver|
                                        (|Integer|))))
                                (AND (|HasCategory| |#4| '(|Ring|))
                                     (|HasCategory| |#4|
                                      '(|PartialDifferentialRing|
                                        (|Symbol|)))))
                            (LETT #3#
                                  (AND (|HasCategory| |#4|
                                        '(|SetCategory|))
                                       (|HasCategory| |#4|
                                        '(|RetractableTo| (|Integer|)))) . #5#)
                            (OR (AND (|HasCategory| |#4|
                                      '(|LinearlyExplicitRingOver|
                                        (|Integer|)))
                                     (|HasCategory| |#4|
                                      '(|RetractableTo| (|Integer|))))
                                (AND (|HasCategory| |#4|
                                      '(|PartialDifferentialRing|
                                        (|Symbol|)))
                                     (|HasCategory| |#4|
                                      '(|RetractableTo| (|Integer|))))
                                (AND #1#
                                     (|HasCategory| |#4|
                                      '(|RetractableTo| (|Integer|))))
                                (AND #2#
                                     (|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 #0#
                                     (|HasCategory| |#4|
                                      '(|RetractableTo| (|Integer|))))
                                (AND (|HasCategory| |#4| '(|Ring|))
                                     (|HasCategory| |#4|
                                      '(|RetractableTo| (|Integer|))))
                                #3#)
                            (OR (|HasCategory| |#4| '(|Ring|)) #3#)
                            (LETT #4#
                                  (AND (|HasCategory| |#4|
                                        '(|RetractableTo|
                                          (|Fraction| (|Integer|))))
                                       (|HasCategory| |#4|
                                        '(|SetCategory|))) . #5#)
                            (OR (AND (|HasCategory| |#4|
                                      '(|RetractableTo|
                                        (|Fraction| (|Integer|))))
                                     (|HasCategory| |#4|
                                      '(|LinearlyExplicitRingOver|
                                        (|Integer|))))
                                (AND (|HasCategory| |#4|
                                      '(|RetractableTo|
                                        (|Fraction| (|Integer|))))
                                     (|HasCategory| |#4|
                                      '(|PartialDifferentialRing|
                                        (|Symbol|))))
                                (AND (|HasCategory| |#4|
                                      '(|RetractableTo|
                                        (|Fraction| (|Integer|))))
                                     #1#)
                                (AND (|HasCategory| |#4|
                                      '(|RetractableTo|
                                        (|Fraction| (|Integer|))))
                                     #2#)
                                (AND (|HasCategory| |#4|
                                      '(|RetractableTo|
                                        (|Fraction| (|Integer|))))
                                     (|HasCategory| |#4| '(|Field|)))
                                (AND (|HasCategory| |#4|
                                      '(|RetractableTo|
                                        (|Fraction| (|Integer|))))
                                     (|HasCategory| |#4| '(|Finite|)))
                                (AND (|HasCategory| |#4|
                                      '(|RetractableTo|
                                        (|Fraction| (|Integer|))))
                                     (|HasCategory| |#4| '(|Monoid|)))
                                (AND (|HasCategory| |#4|
                                      '(|RetractableTo|
                                        (|Fraction| (|Integer|))))
                                     (|HasCategory| |#4|
                                      '(|OrderedAbelianMonoidSup|)))
                                (AND (|HasCategory| |#4|
                                      '(|RetractableTo|
                                        (|Fraction| (|Integer|))))
                                     #0#)
                                (AND (|HasCategory| |#4|
                                      '(|RetractableTo|
                                        (|Fraction| (|Integer|))))
                                     (|HasCategory| |#4| '(|Ring|)))
                                #4#)
                            (|HasCategory| |#4|
                                '(|CancellationAbelianMonoid|))
                            (|HasCategory| |#4| '(|AbelianSemiGroup|))
                            (AND (|HasCategory| |#4| '(|SetCategory|))
                                 (|HasCategory| |#4|
                                     (LIST '|Evalable|
                                      (|devaluate| |#4|))))
                            (OR (AND #1#
                                     (|HasCategory| |#4|
                                      (LIST '|Evalable|
                                       (|devaluate| |#4|))))
                                (AND #2#
                                     (|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 #0#
                                     (|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|))))))) . #5#))
        (|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| $) (|List| 29) (|Symbol|) (|List| 20)
             (|Fraction| 11) (|Union| 31 '"failed")
             (|Union| 11 '"failed") (|PositiveInteger|)
             (|Union| $ '"failed") (|Mapping| 19 9) (|Void|)
             (|Mapping| 9 9) (|CardinalNumber|) (|List| $)
             (|Record| (|:| |mat| 42) (|:| |vec| 47)) (|Matrix| 9)
             (|Union| 9 '"failed") (|OutputForm|) (|SingleInteger|)
             (|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 8 16 0 0 9 2 3 4 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 |Ring&| NIL NIL NIL NIL NIL NIL NIL
                         NIL NIL |AbelianGroup&| NIL NIL NIL NIL
                         |IndexedAggregate&| |AbelianMonoid&| NIL NIL
                         |Monoid&| |HomogeneousAggregate&|
                         |AbelianSemiGroup&| |OrderedSet&| |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| 29)
                               (|DifferentialRing|) (|BiModule| 9 9)
                               (|BiModule| $$ $$) (|Ring|)
                               (|LeftModule| 8) (|LeftModule| 7)
                               (|LeftModule| 9) (|RightModule| 9)
                               (|OrderedAbelianMonoidSup|)
                               (|OrderedAbelianGroup|)
                               (|LeftModule| $$) (|RightModule| $$)
                               (|Rng|) (|AbelianGroup|)
                               (|OrderedCancellationAbelianMonoid|)
                               (|CancellationAbelianMonoid|)
                               (|OrderedAbelianMonoid|) (|SemiRing|)
                               (|IndexedAggregate| 11 9)
                               (|AbelianMonoid|)
                               (|OrderedAbelianSemiGroup|) (|SemiRng|)
                               (|Monoid|) (|HomogeneousAggregate| 9)
                               (|AbelianSemiGroup|) (|OrderedSet|)
                               (|SemiGroup|) (|Finite|) (|Aggregate|)
                               (|SetCategory|)
                               (|EltableAggregate| 11 9) (|Evalable| 9)
                               (|FullyRetractableTo| 9) (|Type|)
                               (|BasicType|) (|finiteAggregate|)
                               (|CoercibleTo| (|Vector| 9))
                               (|Eltable| 11 9) (|CoercibleTo| 44)
                               (|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|)) 
