
(/VERSIONCHECK 2) 

(DEFUN |ODP;<;2$B;1| (|x| |y| $) (SPADCALL |x| |y| (QREFELT $ 8))) 

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

(DEFUN |OrderedDirectProduct;| (|#1| |#2| |#3|)
  (PROG (|pv$| #1=#:G680 #2=#:G681 #3=#:G682 #4=#:G683 #5=#:G684 $ |dv$| DV$3
         DV$2 DV$1)
    (RETURN
     (PROGN
      (LETT DV$1 (|devaluate| |#1|) . #6=(|OrderedDirectProduct|))
      (LETT DV$2 (|devaluate| |#2|) . #6#)
      (LETT DV$3 (|devaluate| |#3|) . #6#)
      (LETT |dv$| (LIST '|OrderedDirectProduct| DV$1 DV$2 DV$3) . #6#)
      (LETT $ (GETREFV 42) . #6#)
      (QSETREFV $ 0 |dv$|)
      (QSETREFV $ 3
                (LETT |pv$|
                      (|buildPredVector| 0 0
                                         (LIST
                                          (|HasCategory| |#2| '(|SetCategory|))
                                          (|HasCategory| |#2| '(|Field|))
                                          (|HasCategory| |#2| '(|Ring|))
                                          (|HasCategory| |#2|
                                                         '(|OrderedAbelianMonoidSup|))
                                          (LETT #5#
                                                (|HasCategory| |#2|
                                                               '(|OrderedRing|))
                                                . #6#)
                                          (OR
                                           (|HasCategory| |#2|
                                                          '(|OrderedAbelianMonoidSup|))
                                           #5#)
                                          (|HasCategory| |#2| '(|Monoid|))
                                          (|HasCategory| |#2| '(|unitsKnown|))
                                          (LETT #4#
                                                (|HasCategory| |#2|
                                                               '(|CommutativeRing|))
                                                . #6#)
                                          (OR #4#
                                              (|HasCategory| |#2| '(|Field|))
                                              (|HasCategory| |#2| '(|Ring|)))
                                          (OR #4#
                                              (|HasCategory| |#2| '(|Field|)))
                                          (OR #4#
                                              (|HasCategory| |#2| '(|Ring|)))
                                          (|HasCategory| |#2| '(|Finite|))
                                          (|HasCategory| |#2|
                                                         '(|LinearlyExplicitRingOver|
                                                           (|Integer|)))
                                          (|HasCategory| |#2|
                                                         '(|PartialDifferentialRing|
                                                           (|Symbol|)))
                                          (LETT #3#
                                                (|HasCategory| |#2|
                                                               '(|DifferentialRing|))
                                                . #6#)
                                          (OR #4# #3#
                                              (|HasCategory| |#2| '(|Field|))
                                              (|HasCategory| |#2| '(|Ring|))
                                              (|HasCategory| |#2|
                                                             '(|LinearlyExplicitRingOver|
                                                               (|Integer|)))
                                              (|HasCategory| |#2|
                                                             '(|PartialDifferentialRing|
                                                               (|Symbol|))))
                                          (OR #4# #3#
                                              (|HasCategory| |#2| '(|Ring|))
                                              (|HasCategory| |#2|
                                                             '(|LinearlyExplicitRingOver|
                                                               (|Integer|)))
                                              (|HasCategory| |#2|
                                                             '(|PartialDifferentialRing|
                                                               (|Symbol|))))
                                          (|HasCategory| (|Integer|)
                                                         '(|OrderedSet|))
                                          (AND (|HasCategory| |#2| '(|Ring|))
                                               (|HasCategory| |#2|
                                                              '(|LinearlyExplicitRingOver|
                                                                (|Integer|))))
                                          (AND #3#
                                               (|HasCategory| |#2| '(|Ring|)))
                                          (AND (|HasCategory| |#2| '(|Ring|))
                                               (|HasCategory| |#2|
                                                              '(|PartialDifferentialRing|
                                                                (|Symbol|))))
                                          (AND
                                           (|HasCategory| |#2|
                                                          '(|SetCategory|))
                                           (|HasCategory| |#2|
                                                          '(|RetractableTo|
                                                            (|Integer|))))
                                          (OR
                                           (AND
                                            (|HasCategory| |#2|
                                                           '(|SetCategory|))
                                            (|HasCategory| |#2|
                                                           '(|RetractableTo|
                                                             (|Integer|))))
                                           (|HasCategory| |#2| '(|Ring|)))
                                          (AND
                                           (|HasCategory| |#2|
                                                          '(|SetCategory|))
                                           (|HasCategory| |#2|
                                                          '(|RetractableTo|
                                                            (|Fraction|
                                                             (|Integer|)))))
                                          (LETT #2#
                                                (|HasCategory| |#2|
                                                               '(|CancellationAbelianMonoid|))
                                                . #6#)
                                          (OR #2# #4# #3#
                                              (|HasCategory| |#2| '(|Field|))
                                              (|HasCategory| |#2| '(|Ring|))
                                              (|HasCategory| |#2|
                                                             '(|LinearlyExplicitRingOver|
                                                               (|Integer|)))
                                              (|HasCategory| |#2|
                                                             '(|PartialDifferentialRing|
                                                               (|Symbol|))))
                                          (LETT #1#
                                                (|HasCategory| |#2|
                                                               '(|AbelianSemiGroup|))
                                                . #6#)
                                          (OR #1# #2# #4# #3#
                                              (|HasCategory| |#2| '(|Field|))
                                              (|HasCategory| |#2| '(|Finite|))
                                              (|HasCategory| |#2| '(|Monoid|))
                                              (|HasCategory| |#2|
                                                             '(|OrderedAbelianMonoidSup|))
                                              #5#
                                              (|HasCategory| |#2| '(|Ring|))
                                              (|HasCategory| |#2|
                                                             '(|SetCategory|))
                                              (|HasCategory| |#2|
                                                             '(|LinearlyExplicitRingOver|
                                                               (|Integer|)))
                                              (|HasCategory| |#2|
                                                             '(|PartialDifferentialRing|
                                                               (|Symbol|))))
                                          (OR #1# #2# #4# #3#
                                              (|HasCategory| |#2| '(|Field|))
                                              (|HasCategory| |#2| '(|Ring|))
                                              (|HasCategory| |#2|
                                                             '(|LinearlyExplicitRingOver|
                                                               (|Integer|)))
                                              (|HasCategory| |#2|
                                                             '(|PartialDifferentialRing|
                                                               (|Symbol|))))
                                          (OR
                                           (AND #1#
                                                (|HasCategory| |#2|
                                                               '(|RetractableTo|
                                                                 (|Fraction|
                                                                  (|Integer|)))))
                                           (AND #2#
                                                (|HasCategory| |#2|
                                                               '(|RetractableTo|
                                                                 (|Fraction|
                                                                  (|Integer|)))))
                                           (AND #4#
                                                (|HasCategory| |#2|
                                                               '(|RetractableTo|
                                                                 (|Fraction|
                                                                  (|Integer|)))))
                                           (AND #3#
                                                (|HasCategory| |#2|
                                                               '(|RetractableTo|
                                                                 (|Fraction|
                                                                  (|Integer|)))))
                                           (AND (|HasCategory| |#2| '(|Field|))
                                                (|HasCategory| |#2|
                                                               '(|RetractableTo|
                                                                 (|Fraction|
                                                                  (|Integer|)))))
                                           (AND
                                            (|HasCategory| |#2| '(|Finite|))
                                            (|HasCategory| |#2|
                                                           '(|RetractableTo|
                                                             (|Fraction|
                                                              (|Integer|)))))
                                           (AND
                                            (|HasCategory| |#2| '(|Monoid|))
                                            (|HasCategory| |#2|
                                                           '(|RetractableTo|
                                                             (|Fraction|
                                                              (|Integer|)))))
                                           (AND
                                            (|HasCategory| |#2|
                                                           '(|OrderedAbelianMonoidSup|))
                                            (|HasCategory| |#2|
                                                           '(|RetractableTo|
                                                             (|Fraction|
                                                              (|Integer|)))))
                                           (AND #5#
                                                (|HasCategory| |#2|
                                                               '(|RetractableTo|
                                                                 (|Fraction|
                                                                  (|Integer|)))))
                                           (AND (|HasCategory| |#2| '(|Ring|))
                                                (|HasCategory| |#2|
                                                               '(|RetractableTo|
                                                                 (|Fraction|
                                                                  (|Integer|)))))
                                           (AND
                                            (|HasCategory| |#2|
                                                           '(|SetCategory|))
                                            (|HasCategory| |#2|
                                                           '(|RetractableTo|
                                                             (|Fraction|
                                                              (|Integer|)))))
                                           (AND
                                            (|HasCategory| |#2|
                                                           '(|LinearlyExplicitRingOver|
                                                             (|Integer|)))
                                            (|HasCategory| |#2|
                                                           '(|RetractableTo|
                                                             (|Fraction|
                                                              (|Integer|)))))
                                           (AND
                                            (|HasCategory| |#2|
                                                           '(|PartialDifferentialRing|
                                                             (|Symbol|)))
                                            (|HasCategory| |#2|
                                                           '(|RetractableTo|
                                                             (|Fraction|
                                                              (|Integer|))))))
                                          (OR
                                           (AND #1#
                                                (|HasCategory| |#2|
                                                               '(|RetractableTo|
                                                                 (|Integer|))))
                                           (AND #2#
                                                (|HasCategory| |#2|
                                                               '(|RetractableTo|
                                                                 (|Integer|))))
                                           (AND #4#
                                                (|HasCategory| |#2|
                                                               '(|RetractableTo|
                                                                 (|Integer|))))
                                           (AND #3#
                                                (|HasCategory| |#2|
                                                               '(|RetractableTo|
                                                                 (|Integer|))))
                                           (AND (|HasCategory| |#2| '(|Field|))
                                                (|HasCategory| |#2|
                                                               '(|RetractableTo|
                                                                 (|Integer|))))
                                           (AND
                                            (|HasCategory| |#2| '(|Finite|))
                                            (|HasCategory| |#2|
                                                           '(|RetractableTo|
                                                             (|Integer|))))
                                           (AND
                                            (|HasCategory| |#2| '(|Monoid|))
                                            (|HasCategory| |#2|
                                                           '(|RetractableTo|
                                                             (|Integer|))))
                                           (AND
                                            (|HasCategory| |#2|
                                                           '(|OrderedAbelianMonoidSup|))
                                            (|HasCategory| |#2|
                                                           '(|RetractableTo|
                                                             (|Integer|))))
                                           (AND #5#
                                                (|HasCategory| |#2|
                                                               '(|RetractableTo|
                                                                 (|Integer|))))
                                           (AND (|HasCategory| |#2| '(|Ring|))
                                                (|HasCategory| |#2|
                                                               '(|RetractableTo|
                                                                 (|Integer|))))
                                           (AND
                                            (|HasCategory| |#2|
                                                           '(|SetCategory|))
                                            (|HasCategory| |#2|
                                                           '(|RetractableTo|
                                                             (|Integer|))))
                                           (AND
                                            (|HasCategory| |#2|
                                                           '(|LinearlyExplicitRingOver|
                                                             (|Integer|)))
                                            (|HasCategory| |#2|
                                                           '(|RetractableTo|
                                                             (|Integer|))))
                                           (AND
                                            (|HasCategory| |#2|
                                                           '(|PartialDifferentialRing|
                                                             (|Symbol|)))
                                            (|HasCategory| |#2|
                                                           '(|RetractableTo|
                                                             (|Integer|)))))
                                          (AND
                                           (|HasCategory| |#2|
                                                          '(|SetCategory|))
                                           (|HasCategory| |#2|
                                                          (LIST '|Evalable|
                                                                (|devaluate|
                                                                 |#2|))))
                                          (OR
                                           (AND #1#
                                                (|HasCategory| |#2|
                                                               (LIST
                                                                '|Evalable|
                                                                (|devaluate|
                                                                 |#2|))))
                                           (AND #2#
                                                (|HasCategory| |#2|
                                                               (LIST
                                                                '|Evalable|
                                                                (|devaluate|
                                                                 |#2|))))
                                           (AND #4#
                                                (|HasCategory| |#2|
                                                               (LIST
                                                                '|Evalable|
                                                                (|devaluate|
                                                                 |#2|))))
                                           (AND #3#
                                                (|HasCategory| |#2|
                                                               (LIST
                                                                '|Evalable|
                                                                (|devaluate|
                                                                 |#2|))))
                                           (AND (|HasCategory| |#2| '(|Field|))
                                                (|HasCategory| |#2|
                                                               (LIST
                                                                '|Evalable|
                                                                (|devaluate|
                                                                 |#2|))))
                                           (AND
                                            (|HasCategory| |#2| '(|Finite|))
                                            (|HasCategory| |#2|
                                                           (LIST '|Evalable|
                                                                 (|devaluate|
                                                                  |#2|))))
                                           (AND
                                            (|HasCategory| |#2| '(|Monoid|))
                                            (|HasCategory| |#2|
                                                           (LIST '|Evalable|
                                                                 (|devaluate|
                                                                  |#2|))))
                                           (AND
                                            (|HasCategory| |#2|
                                                           '(|OrderedAbelianMonoidSup|))
                                            (|HasCategory| |#2|
                                                           (LIST '|Evalable|
                                                                 (|devaluate|
                                                                  |#2|))))
                                           (AND #5#
                                                (|HasCategory| |#2|
                                                               (LIST
                                                                '|Evalable|
                                                                (|devaluate|
                                                                 |#2|))))
                                           (AND (|HasCategory| |#2| '(|Ring|))
                                                (|HasCategory| |#2|
                                                               (LIST
                                                                '|Evalable|
                                                                (|devaluate|
                                                                 |#2|))))
                                           (AND
                                            (|HasCategory| |#2|
                                                           '(|SetCategory|))
                                            (|HasCategory| |#2|
                                                           (LIST '|Evalable|
                                                                 (|devaluate|
                                                                  |#2|))))
                                           (AND
                                            (|HasCategory| |#2|
                                                           (LIST '|Evalable|
                                                                 (|devaluate|
                                                                  |#2|)))
                                            (|HasCategory| |#2|
                                                           '(|LinearlyExplicitRingOver|
                                                             (|Integer|))))
                                           (AND
                                            (|HasCategory| |#2|
                                                           (LIST '|Evalable|
                                                                 (|devaluate|
                                                                  |#2|)))
                                            (|HasCategory| |#2|
                                                           '(|PartialDifferentialRing|
                                                             (|Symbol|)))))))
                      . #6#))
      (|haddProp| |$ConstructorCache| '|OrderedDirectProduct|
                  (LIST DV$1 DV$2 DV$3) (CONS 1 $))
      (|stuffDomainSlots| $)
      (QSETREFV $ 6 |#1|)
      (QSETREFV $ 7 |#2|)
      (QSETREFV $ 8 |#3|)
      (AND (|HasCategory| $ '(|finiteAggregate|))
           (|augmentPredVector| $ 17179869184))
      (AND (|HasCategory| $ '(|finiteAggregate|))
           (|HasCategory| |#2| '(|SetCategory|))
           (|augmentPredVector| $ 34359738368))
      (AND (|HasCategory| $ '(|shallowlyMutable|))
           (|augmentPredVector| $ 68719476736))
      (QSETREFV $ 9 (|Vector| |#2|))
      $)))) 

(MAKEPROP '|OrderedDirectProduct| '|infovec|
          (LIST
           '#(NIL NIL NIL NIL NIL (|DirectProduct| 6 7) (|local| |#1|)
              (|local| |#2|) (|local| |#3|) '|Rep| (|Boolean|) |ODP;<;2$B;1|
              (|NonNegativeInteger|) (|List| 7) (|List| 15) (|Equation| 7)
              (|Record| (|:| |mat| 19) (|:| |vec| (|Vector| 25))) (|Matrix| $)
              (|Vector| $) (|Matrix| 25) (|Symbol|) (|List| 20) (|List| 12)
              (|Fraction| 25) (|Union| 23 '#1="failed") (|Integer|)
              (|Union| 25 '#1#) (|Mapping| 10 7) (|Void|) (|Mapping| 7 7)
              (|PositiveInteger|) (|Union| $ '"failed") (|CardinalNumber|)
              (|List| $) (|Matrix| 7) (|Record| (|:| |mat| 34) (|:| |vec| 40))
              (|Union| 7 '#1#) (|SingleInteger|) (|OutputForm|) (|String|)
              (|Vector| 7) (|List| 25))
           '#(< 0) 'NIL
           (CONS
            (|makeByteWordVec2| 34
                                '(0 2 9 3 3 11 5 9 3 14 15 16 10 4 5 9 18 10 3
                                  6 12 9 18 6 17 6 3 27 0 6 3 7 27 0 6 7 13 30
                                  0 0 34 29 1 0 0 0 0 34 1 8 9 29 1 31 32))
            (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 |AbelianGroup&| NIL NIL NIL |IndexedAggregate&|
                |OrderedSet&| NIL |Monoid&| |AbelianMonoid&|
                |HomogeneousAggregate&| NIL |SemiGroup&| |Finite&|
                |AbelianSemiGroup&| |Aggregate&| |EltableAggregate&|
                |Evalable&| |SetCategory&| |FullyRetractableTo&| NIL NIL NIL
                NIL |InnerEvalable&| NIL NIL NIL |BasicType&| |RetractableTo&|
                |RetractableTo&| |RetractableTo&|)
             (CONS
              '#((|DirectProductCategory| 6 7) (|VectorSpace| 7) (|Algebra| 7)
                 (|FullyLinearlyExplicitRingOver| 7)
                 (|DifferentialExtension| 7) (|Module| 7) (|OrderedRing|)
                 (|CommutativeRing|) (|LinearlyExplicitRingOver| 7)
                 (|LinearlyExplicitRingOver| 25) (|PartialDifferentialRing| 20)
                 (|DifferentialRing|) (|BiModule| 7 7)
                 (|OrderedAbelianMonoidSup|) (|OrderedAbelianGroup|)
                 (|BiModule| $$ $$) (|Ring|) (|LeftModule| 7) (|RightModule| 7)
                 (|OrderedCancellationAbelianMonoid|) (|LeftModule| $$)
                 (|RightModule| $$) (|Rng|) (|OrderedAbelianMonoid|)
                 (|AbelianGroup|) (|OrderedAbelianSemiGroup|) (|SemiRing|)
                 (|CancellationAbelianMonoid|) (|IndexedAggregate| 25 7)
                 (|OrderedSet|) (|SemiRng|) (|Monoid|) (|AbelianMonoid|)
                 (|HomogeneousAggregate| 7) (|Comparable|) (|SemiGroup|)
                 (|Finite|) (|AbelianSemiGroup|) (|Aggregate|)
                 (|EltableAggregate| 25 7) (|Evalable| 7) (|SetCategory|)
                 (|FullyRetractableTo| 7) (|Type|) (|finiteAggregate|)
                 (|CoercibleTo| (|Vector| 7)) (|Eltable| 25 7)
                 (|InnerEvalable| 7 7) (|CoercibleTo| 38) (|unitsKnown|)
                 (|CommutativeStar|) (|BasicType|) (|RetractableTo| 7)
                 (|RetractableTo| 23) (|RetractableTo| 25))
              (|makeByteWordVec2| 11 '(2 6 10 0 0 11)))))
           '|lookupIncomplete|)) 
