
(/VERSIONCHECK 2) 

(DEFUN |SHDP;lessThanRlex| (|v1| |v2| |low| |high| $)
  (PROG (|n1| |n2| |i| #0=#:G1827)
    (RETURN
      (SEQ (EXIT (SEQ (LETT |n1| (|spadConstant| $ 10)
                            . #1=(|SHDP;lessThanRlex|))
                      (LETT |n2| (|spadConstant| $ 10) . #1#)
                      (SEQ (LETT |i| |low| . #1#) G190
                           (COND ((> |i| |high|) #2=(GO G191)))
                           (SEQ (LETT |n1|
                                      (SPADCALL |n1|
                                       (SPADCALL |v1| |i|
                                        (QREFELT $ 12))
                                       (QREFELT $ 13)) . #1#)
                                (EXIT (LETT |n2|
                                       (SPADCALL |n2|
                                        (SPADCALL |v2| |i|
                                         (QREFELT $ 12))
                                        (QREFELT $ 13)) . #1#)))
                           (LETT |i| (+ |i| 1) . #1#) #3=(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| . #1#) G190
                                     (COND ((< |i| |low|) #2#))
                                     (SEQ
                                      (COND
                                        ((SPADCALL
                                          (SPADCALL |v2| |i|
                                           (QREFELT $ 12))
                                          (SPADCALL |v1| |i|
                                           (QREFELT $ 12))
                                          (QREFELT $ 15))
                                         (PROGN
                                           (LETT #0# 'T . #1#)
                                           (GO #0#))))
                                      (EXIT
                                       (COND
                                         ((SPADCALL
                                           (SPADCALL |v1| |i|
                                            (QREFELT $ 12))
                                           (SPADCALL |v2| |i|
                                            (QREFELT $ 12))
                                           (QREFELT $ 15))
                                          (PROGN
                                            (LETT #0# 'NIL . #1#)
                                            (GO #0#))))))
                                     (LETT |i| (+ |i| -1) . #1#) #3#
                                     G191 (EXIT NIL))
                                    (EXIT 'NIL)))))))
           #0# (EXIT #0#))))) 

(DEFUN |SHDP;<;2$B;2| (|v1| |v2| $)
  (PROG (|i| #0=#:G1833 #1=#:G1832)
    (RETURN
      (SEQ (EXIT (COND
                   ((|SHDP;lessThanRlex| |v1| |v2| 1 (QREFELT $ 7) $)
                    'T)
                   ('T
                    (SEQ (SEQ (LETT |i| 1 . #2=(|SHDP;<;2$B;2|))
                              (LETT #0# (QREFELT $ 7) . #2#) G190
                              (COND ((QSGREATERP |i| #0#) (GO G191)))
                              (SEQ (EXIT
                                    (COND
                                      ((NULL
                                        (SPADCALL
                                         (SPADCALL |v1| |i|
                                          (QREFELT $ 12))
                                         (SPADCALL |v2| |i|
                                          (QREFELT $ 12))
                                         (QREFELT $ 16)))
                                       (PROGN
                                         (LETT #1# 'NIL . #2#)
                                         (GO #1#))))))
                              (LETT |i| (QSADD1 |i|) . #2#) (GO G190)
                              G191 (EXIT NIL))
                         (EXIT (|SHDP;lessThanRlex| |v1| |v2|
                                   (+ (QREFELT $ 7) 1) (QREFELT $ 6) $))))))
           #1# (EXIT #1#))))) 

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

(DEFUN |SplitHomogeneousDirectProduct;| (|#1| |#2| |#3|)
  (PROG (DV$1 DV$2 DV$3 |dv$| $ #0=#:G1855 #1=#:G1854 #2=#:G1853
              #3=#:G1852 #4=#:G1851 |pv$|)
    (RETURN
      (PROGN
        (LETT DV$1 (|devaluate| |#1|)
              . #5=(|SplitHomogeneousDirectProduct|))
        (LETT DV$2 (|devaluate| |#2|) . #5#)
        (LETT DV$3 (|devaluate| |#3|) . #5#)
        (LETT |dv$|
              (LIST '|SplitHomogeneousDirectProduct| DV$1 DV$2 DV$3) . #5#)
        (LETT $ (GETREFV 47) . #5#)
        (QSETREFV $ 0 |dv$|)
        (QSETREFV $ 3
            (LETT |pv$|
                  (|buildPredVector| 0 0
                      (LIST (|HasCategory| |#3| '(|SetCategory|))
                            (|HasCategory| |#3| '(|Field|))
                            (|HasCategory| |#3| '(|Ring|))
                            (|HasCategory| |#3|
                                '(|OrderedAbelianMonoidSup|))
                            (LETT #0#
                                  (|HasCategory| |#3| '(|OrderedRing|)) . #5#)
                            (OR (|HasCategory| |#3|
                                    '(|OrderedAbelianMonoidSup|))
                                #0#)
                            (|HasCategory| |#3| '(|Monoid|))
                            (|HasCategory| |#3| '(|unitsKnown|))
                            (LETT #1#
                                  (|HasCategory| |#3|
                                      '(|CommutativeRing|)) . #5#)
                            (OR #1# (|HasCategory| |#3| '(|Field|))
                                (|HasCategory| |#3| '(|Ring|)))
                            (OR #1# (|HasCategory| |#3| '(|Field|)))
                            (OR #1# (|HasCategory| |#3| '(|Ring|)))
                            (|HasCategory| |#3| '(|Finite|))
                            (|HasCategory| |#3|
                                '(|LinearlyExplicitRingOver|
                                     (|Integer|)))
                            (|HasCategory| |#3|
                                '(|PartialDifferentialRing| (|Symbol|)))
                            (LETT #2#
                                  (|HasCategory| |#3|
                                      '(|DifferentialRing|)) . #5#)
                            (OR (|HasCategory| |#3|
                                    '(|LinearlyExplicitRingOver|
                                      (|Integer|)))
                                (|HasCategory| |#3|
                                    '(|PartialDifferentialRing|
                                      (|Symbol|)))
                                #1# #2# (|HasCategory| |#3| '(|Field|))
                                (|HasCategory| |#3| '(|Ring|)))
                            (OR (|HasCategory| |#3|
                                    '(|LinearlyExplicitRingOver|
                                      (|Integer|)))
                                (|HasCategory| |#3|
                                    '(|PartialDifferentialRing|
                                      (|Symbol|)))
                                #1# #2# (|HasCategory| |#3| '(|Ring|)))
                            (|HasCategory| (|Integer|) '(|OrderedSet|))
                            (AND (|HasCategory| |#3| '(|Ring|))
                                 (|HasCategory| |#3|
                                     '(|LinearlyExplicitRingOver|
                                       (|Integer|))))
                            (AND #2# (|HasCategory| |#3| '(|Ring|)))
                            (AND (|HasCategory| |#3| '(|Ring|))
                                 (|HasCategory| |#3|
                                     '(|PartialDifferentialRing|
                                       (|Symbol|))))
                            (AND (|HasCategory| |#3| '(|SetCategory|))
                                 (|HasCategory| |#3|
                                     '(|RetractableTo| (|Integer|))))
                            (OR (|HasCategory| |#3| '(|Ring|))
                                (AND (|HasCategory| |#3|
                                      '(|SetCategory|))
                                     (|HasCategory| |#3|
                                      '(|RetractableTo| (|Integer|)))))
                            (AND (|HasCategory| |#3|
                                     '(|RetractableTo|
                                       (|Fraction| (|Integer|))))
                                 (|HasCategory| |#3| '(|SetCategory|)))
                            (LETT #3#
                                  (|HasCategory| |#3|
                                      '(|CancellationAbelianMonoid|)) . #5#)
                            (OR (|HasCategory| |#3|
                                    '(|LinearlyExplicitRingOver|
                                      (|Integer|)))
                                (|HasCategory| |#3|
                                    '(|PartialDifferentialRing|
                                      (|Symbol|)))
                                #3# #1# #2#
                                (|HasCategory| |#3| '(|Field|))
                                (|HasCategory| |#3| '(|Ring|)))
                            (LETT #4#
                                  (|HasCategory| |#3|
                                      '(|AbelianSemiGroup|)) . #5#)
                            (OR (|HasCategory| |#3|
                                    '(|LinearlyExplicitRingOver|
                                      (|Integer|)))
                                (|HasCategory| |#3|
                                    '(|PartialDifferentialRing|
                                      (|Symbol|)))
                                #4# #3# #1# #2#
                                (|HasCategory| |#3| '(|Field|))
                                (|HasCategory| |#3| '(|Finite|))
                                (|HasCategory| |#3| '(|Monoid|))
                                (|HasCategory| |#3|
                                    '(|OrderedAbelianMonoidSup|))
                                #0# (|HasCategory| |#3| '(|Ring|))
                                (|HasCategory| |#3| '(|SetCategory|)))
                            (OR (|HasCategory| |#3|
                                    '(|LinearlyExplicitRingOver|
                                      (|Integer|)))
                                (|HasCategory| |#3|
                                    '(|PartialDifferentialRing|
                                      (|Symbol|)))
                                #4# #3# #1# #2#
                                (|HasCategory| |#3| '(|Field|))
                                (|HasCategory| |#3| '(|Ring|)))
                            (OR (AND (|HasCategory| |#3|
                                      '(|RetractableTo|
                                        (|Fraction| (|Integer|))))
                                     (|HasCategory| |#3|
                                      '(|LinearlyExplicitRingOver|
                                        (|Integer|))))
                                (AND (|HasCategory| |#3|
                                      '(|RetractableTo|
                                        (|Fraction| (|Integer|))))
                                     (|HasCategory| |#3|
                                      '(|PartialDifferentialRing|
                                        (|Symbol|))))
                                (AND (|HasCategory| |#3|
                                      '(|RetractableTo|
                                        (|Fraction| (|Integer|))))
                                     #4#)
                                (AND (|HasCategory| |#3|
                                      '(|RetractableTo|
                                        (|Fraction| (|Integer|))))
                                     #3#)
                                (AND (|HasCategory| |#3|
                                      '(|RetractableTo|
                                        (|Fraction| (|Integer|))))
                                     #1#)
                                (AND (|HasCategory| |#3|
                                      '(|RetractableTo|
                                        (|Fraction| (|Integer|))))
                                     #2#)
                                (AND (|HasCategory| |#3|
                                      '(|RetractableTo|
                                        (|Fraction| (|Integer|))))
                                     (|HasCategory| |#3| '(|Field|)))
                                (AND (|HasCategory| |#3|
                                      '(|RetractableTo|
                                        (|Fraction| (|Integer|))))
                                     (|HasCategory| |#3| '(|Finite|)))
                                (AND (|HasCategory| |#3|
                                      '(|RetractableTo|
                                        (|Fraction| (|Integer|))))
                                     (|HasCategory| |#3| '(|Monoid|)))
                                (AND (|HasCategory| |#3|
                                      '(|RetractableTo|
                                        (|Fraction| (|Integer|))))
                                     (|HasCategory| |#3|
                                      '(|OrderedAbelianMonoidSup|)))
                                (AND (|HasCategory| |#3|
                                      '(|RetractableTo|
                                        (|Fraction| (|Integer|))))
                                     #0#)
                                (AND (|HasCategory| |#3|
                                      '(|RetractableTo|
                                        (|Fraction| (|Integer|))))
                                     (|HasCategory| |#3| '(|Ring|)))
                                (AND (|HasCategory| |#3|
                                      '(|RetractableTo|
                                        (|Fraction| (|Integer|))))
                                     (|HasCategory| |#3|
                                      '(|SetCategory|))))
                            (OR (AND (|HasCategory| |#3|
                                      '(|LinearlyExplicitRingOver|
                                        (|Integer|)))
                                     (|HasCategory| |#3|
                                      '(|RetractableTo| (|Integer|))))
                                (AND (|HasCategory| |#3|
                                      '(|PartialDifferentialRing|
                                        (|Symbol|)))
                                     (|HasCategory| |#3|
                                      '(|RetractableTo| (|Integer|))))
                                (AND #4#
                                     (|HasCategory| |#3|
                                      '(|RetractableTo| (|Integer|))))
                                (AND #3#
                                     (|HasCategory| |#3|
                                      '(|RetractableTo| (|Integer|))))
                                (AND #1#
                                     (|HasCategory| |#3|
                                      '(|RetractableTo| (|Integer|))))
                                (AND #2#
                                     (|HasCategory| |#3|
                                      '(|RetractableTo| (|Integer|))))
                                (AND (|HasCategory| |#3| '(|Field|))
                                     (|HasCategory| |#3|
                                      '(|RetractableTo| (|Integer|))))
                                (AND (|HasCategory| |#3| '(|Finite|))
                                     (|HasCategory| |#3|
                                      '(|RetractableTo| (|Integer|))))
                                (AND (|HasCategory| |#3| '(|Monoid|))
                                     (|HasCategory| |#3|
                                      '(|RetractableTo| (|Integer|))))
                                (AND (|HasCategory| |#3|
                                      '(|OrderedAbelianMonoidSup|))
                                     (|HasCategory| |#3|
                                      '(|RetractableTo| (|Integer|))))
                                (AND #0#
                                     (|HasCategory| |#3|
                                      '(|RetractableTo| (|Integer|))))
                                (AND (|HasCategory| |#3| '(|Ring|))
                                     (|HasCategory| |#3|
                                      '(|RetractableTo| (|Integer|))))
                                (AND (|HasCategory| |#3|
                                      '(|SetCategory|))
                                     (|HasCategory| |#3|
                                      '(|RetractableTo| (|Integer|)))))
                            (AND (|HasCategory| |#3| '(|SetCategory|))
                                 (|HasCategory| |#3|
                                     (LIST '|Evalable|
                                      (|devaluate| |#3|))))
                            (OR (AND #4#
                                     (|HasCategory| |#3|
                                      (LIST '|Evalable|
                                       (|devaluate| |#3|))))
                                (AND #3#
                                     (|HasCategory| |#3|
                                      (LIST '|Evalable|
                                       (|devaluate| |#3|))))
                                (AND #1#
                                     (|HasCategory| |#3|
                                      (LIST '|Evalable|
                                       (|devaluate| |#3|))))
                                (AND #2#
                                     (|HasCategory| |#3|
                                      (LIST '|Evalable|
                                       (|devaluate| |#3|))))
                                (AND (|HasCategory| |#3| '(|Field|))
                                     (|HasCategory| |#3|
                                      (LIST '|Evalable|
                                       (|devaluate| |#3|))))
                                (AND (|HasCategory| |#3| '(|Finite|))
                                     (|HasCategory| |#3|
                                      (LIST '|Evalable|
                                       (|devaluate| |#3|))))
                                (AND (|HasCategory| |#3| '(|Monoid|))
                                     (|HasCategory| |#3|
                                      (LIST '|Evalable|
                                       (|devaluate| |#3|))))
                                (AND (|HasCategory| |#3|
                                      '(|OrderedAbelianMonoidSup|))
                                     (|HasCategory| |#3|
                                      (LIST '|Evalable|
                                       (|devaluate| |#3|))))
                                (AND #0#
                                     (|HasCategory| |#3|
                                      (LIST '|Evalable|
                                       (|devaluate| |#3|))))
                                (AND (|HasCategory| |#3| '(|Ring|))
                                     (|HasCategory| |#3|
                                      (LIST '|Evalable|
                                       (|devaluate| |#3|))))
                                (AND (|HasCategory| |#3|
                                      '(|SetCategory|))
                                     (|HasCategory| |#3|
                                      (LIST '|Evalable|
                                       (|devaluate| |#3|))))
                                (AND (|HasCategory| |#3|
                                      (LIST '|Evalable|
                                       (|devaluate| |#3|)))
                                     (|HasCategory| |#3|
                                      '(|LinearlyExplicitRingOver|
                                        (|Integer|))))
                                (AND (|HasCategory| |#3|
                                      (LIST '|Evalable|
                                       (|devaluate| |#3|)))
                                     (|HasCategory| |#3|
                                      '(|PartialDifferentialRing|
                                        (|Symbol|))))))) . #5#))
        (|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| $ 17179869184))
        (AND (|HasCategory| $ '(|finiteAggregate|))
             (|HasCategory| |#3| '(|SetCategory|))
             (|augmentPredVector| $ 34359738368))
        (AND (|HasCategory| $ '(|shallowlyMutable|))
             (|augmentPredVector| $ 68719476736))
        (QSETREFV $ 9 (|Vector| |#3|))
        $)))) 

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