
(/VERSIONCHECK 2) 

(DEFUN |DIRPROD;coerce;$V;1| (|z| $) (SPADCALL |z| (QREFELT $ 9))) 

(DEFUN |DIRPROD;coerce;R$;2| (|r| $)
  (SPADCALL (QREFELT $ 6) |r| (QREFELT $ 12))) 

(PUT '|DIRPROD;parts;$L;3| '|SPADreplace| 'VEC2LIST) 

(DEFUN |DIRPROD;parts;$L;3| (|x| $) (VEC2LIST |x|)) 

(DEFUN |DIRPROD;directProduct;V$;4| (|z| $)
  (COND
    ((SPADCALL |z| (QREFELT $ 6) (QREFELT $ 17))
     (SPADCALL |z| (QREFELT $ 9)))
    ('T (|error| "Not of the correct length")))) 

(DEFUN |DIRPROD;same?| (|z| $)
  (PROG ()
    (RETURN
      (SPADCALL (CONS #'|DIRPROD;same?!0| (VECTOR $ |z|)) |z|
          (QREFELT $ 24))))) 

(DEFUN |DIRPROD;same?!0| (|#1| $$)
  (PROG (|z| $)
    (LETT |z| (QREFELT $$ 1) . #0=(|DIRPROD;same?|))
    (LETT $ (QREFELT $$ 0) . #0#)
    (RETURN
      (PROGN
        (SPADCALL |#1|
            (SPADCALL |z| (SPADCALL |z| (QREFELT $ 20)) (QREFELT $ 21))
            (QREFELT $ 22)))))) 

(DEFUN |DIRPROD;=;2$B;6| (|x| |y| $)
  (PROG (|i| #0=#:G1835 #1=#:G1834 #2=#:G1832)
    (RETURN
      (SEQ (EXIT (SEQ (SEQ (EXIT (SEQ (LETT |i| 0
                                       . #3=(|DIRPROD;=;2$B;6|))
                                      (LETT #0#
                                       (- (QREFELT $ 6) 1) . #3#)
                                      G190
                                      (COND
                                        ((QSGREATERP |i| #0#)
                                         (GO G191)))
                                      (SEQ
                                       (EXIT
                                        (COND
                                          ((NULL
                                            (EQL (QREFELT |x| |i|)
                                             (QREFELT |y| |i|)))
                                           (PROGN
                                             (LETT #2#
                                              (PROGN
                                                (LETT #1# 'NIL . #3#)
                                                (GO #1#)) . #3#)
                                             (GO #2#))))))
                                      (LETT |i| (QSADD1 |i|) . #3#)
                                      (GO G190) G191 (EXIT NIL)))
                           #2# (EXIT #2#))
                      (EXIT 'T)))
           #1# (EXIT #1#))))) 

(DEFUN |DIRPROD;=;2$B;7| (|x| |y| $)
  (PROG (|i| #0=#:G1840 #1=#:G1839 #2=#:G1837)
    (RETURN
      (SEQ (EXIT (SEQ (SEQ (EXIT (SEQ (LETT |i| 0
                                       . #3=(|DIRPROD;=;2$B;7|))
                                      (LETT #0#
                                       (- (QREFELT $ 6) 1) . #3#)
                                      G190
                                      (COND
                                        ((QSGREATERP |i| #0#)
                                         (GO G191)))
                                      (SEQ
                                       (EXIT
                                        (COND
                                          ((NULL
                                            (EQL (QREFELT |x| |i|)
                                             (QREFELT |y| |i|)))
                                           (PROGN
                                             (LETT #2#
                                              (PROGN
                                                (LETT #1# 'NIL . #3#)
                                                (GO #1#)) . #3#)
                                             (GO #2#))))))
                                      (LETT |i| (QSADD1 |i|) . #3#)
                                      (GO G190) G191 (EXIT NIL)))
                           #2# (EXIT #2#))
                      (EXIT 'T)))
           #1# (EXIT #1#))))) 

(DEFUN |DIRPROD;=;2$B;8| (|x| |y| $)
  (PROG (|i| #0=#:G1845 #1=#:G1844 #2=#:G1842)
    (RETURN
      (SEQ (EXIT (SEQ (SEQ (EXIT (SEQ (LETT |i| 1
                                       . #3=(|DIRPROD;=;2$B;8|))
                                      (LETT #0# (QREFELT $ 6) . #3#)
                                      G190
                                      (COND
                                        ((QSGREATERP |i| #0#)
                                         (GO G191)))
                                      (SEQ
                                       (EXIT
                                        (COND
                                          ((NULL
                                            (SPADCALL
                                             (SPADCALL |x| |i|
                                              (QREFELT $ 26))
                                             (SPADCALL |y| |i|
                                              (QREFELT $ 26))
                                             (QREFELT $ 22)))
                                           (PROGN
                                             (LETT #2#
                                              (PROGN
                                                (LETT #1# 'NIL . #3#)
                                                (GO #1#)) . #3#)
                                             (GO #2#))))))
                                      (LETT |i| (QSADD1 |i|) . #3#)
                                      (GO G190) G191 (EXIT NIL)))
                           #2# (EXIT #2#))
                      (EXIT 'T)))
           #1# (EXIT #1#))))) 

(DEFUN |DIRPROD;retract;$R;9| (|z| $)
  (COND
    ((|DIRPROD;same?| |z| $)
     (SPADCALL |z| (SPADCALL |z| (QREFELT $ 20)) (QREFELT $ 21)))
    ('T (|error| "Not retractable")))) 

(DEFUN |DIRPROD;retractIfCan;$U;10| (|z| $)
  (COND
    ((|DIRPROD;same?| |z| $)
     (CONS 0
           (SPADCALL |z| (SPADCALL |z| (QREFELT $ 20)) (QREFELT $ 21))))
    ('T (CONS 1 "failed")))) 

(DEFUN |DIRPROD;size;Nni;11| ($)
  (EXPT (SPADCALL (QREFELT $ 30)) (QREFELT $ 6))) 

(DEFUN |DIRPROD;index;Pi$;12| (|n| $)
  (PROG (N #0=#:G1857 |i| #1=#:G1863 |p| #2=#:G1858 L)
    (RETURN
      (SEQ (LETT N (SPADCALL (QREFELT $ 30))
                 . #3=(|DIRPROD;index;Pi$;12|))
           (LETT |p| (- |n| 1) . #3#)
           (LETT L
                 (LIST (SPADCALL
                           (PROG1 (LETT #0#
                                        (+ (REMAINDER2 |p| N) 1) . #3#)
                             (|check-subtype| (> #0# 0)
                                 '(|PositiveInteger|) #0#))
                           (QREFELT $ 33))) . #3#)
           (SEQ (LETT |i| 2 . #3#) (LETT #1# (QREFELT $ 6) . #3#) G190
                (COND ((QSGREATERP |i| #1#) (GO G191)))
                (SEQ (LETT |p| (QUOTIENT2 |p| N) . #3#)
                     (EXIT (LETT L
                                 (CONS (SPADCALL
                                        (PROG1
                                         (LETT #2#
                                          (+ (REMAINDER2 |p| N) 1) . #3#)
                                          (|check-subtype| (> #2# 0)
                                           '(|PositiveInteger|) #2#))
                                        (QREFELT $ 33))
                                       L) . #3#)))
                (LETT |i| (QSADD1 |i|) . #3#) (GO G190) G191
                (EXIT NIL))
           (EXIT (SPADCALL L (QREFELT $ 34))))))) 

(DEFUN |DIRPROD;random;$;13| ($)
  (PROG (#0=#:G1866 #1=#:G1867 |i| #2=#:G1868)
    (RETURN
      (SEQ (PRIMVEC2ARR
               (PROGN
                 (LETT #0# (GETREFV #3=(QREFELT $ 6))
                       . #4=(|DIRPROD;random;$;13|))
                 (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 (QREFELT $ 36)))))
                      (LETT |i|
                            (PROG1 (QSADD1 |i|)
                              (LETT #1# (QSADD1 #1#) . #4#)) . #4#)
                      (GO G190) G191 (EXIT NIL))
                 #0#)))))) 

(DEFUN |DIRPROD;lookup;$Pi;14| (|x| $)
  (PROG (N |i| #0=#:G1873 L #1=#:G1870)
    (RETURN
      (SEQ (LETT N (SPADCALL (QREFELT $ 30))
                 . #2=(|DIRPROD;lookup;$Pi;14|))
           (LETT L
                 (- (SPADCALL (SPADCALL |x| 1 (QREFELT $ 21))
                        (QREFELT $ 39))
                    1) . #2#)
           (SEQ (LETT |i| 2 . #2#) (LETT #0# (QREFELT $ 6) . #2#) G190
                (COND ((QSGREATERP |i| #0#) (GO G191)))
                (SEQ (EXIT (LETT L
                                 (- (+ (* L N)
                                     (SPADCALL
                                      (SPADCALL |x| |i| (QREFELT $ 21))
                                      (QREFELT $ 39)))
                                    1) . #2#)))
                (LETT |i| (QSADD1 |i|) . #2#) (GO G190) G191
                (EXIT NIL))
           (EXIT (PROG1 (LETT #1# (+ L 1) . #2#)
                   (|check-subtype| (> #1# 0) '(|PositiveInteger|) #1#))))))) 

(DEFUN |DIRPROD;hash;$Si;15| (|x| $)
  (PROG (|i| #0=#:G1877 L)
    (RETURN
      (SEQ (LETT L
                 (SPADCALL (SPADCALL |x| 1 (QREFELT $ 21))
                     (QREFELT $ 42))
                 . #1=(|DIRPROD;hash;$Si;15|))
           (SEQ (LETT |i| 2 . #1#) (LETT #0# (QREFELT $ 6) . #1#) G190
                (COND ((QSGREATERP |i| #0#) (GO G191)))
                (SEQ (EXIT (LETT L
                                 (|hashCombine| L
                                     (SPADCALL
                                      (SPADCALL |x| |i| (QREFELT $ 21))
                                      (QREFELT $ 42))) . #1#)))
                (LETT |i| (QSADD1 |i|) . #1#) (GO G190) G191
                (EXIT NIL))
           (EXIT L))))) 

(DEFUN |DIRPROD;+;3$;16| (|u| |v| $)
  (SPADCALL (ELT $ 44) |u| |v| (QREFELT $ 46))) 

(DEFUN |DIRPROD;Zero;$;17| ($)
  (SPADCALL (QREFELT $ 6) (QREFELT $ 48))) 

(DEFUN |DIRPROD;One;$;18| ($)
  (SPADCALL (QREFELT $ 6) (|spadConstant| $ 50) (QREFELT $ 51))) 

(DEFUN |DIRPROD;*;$R$;19| (|u| |r| $)
  (SPADCALL (CONS #'|DIRPROD;*;$R$;19!0| (VECTOR $ |r|)) |u|
      (QREFELT $ 54))) 

(DEFUN |DIRPROD;*;$R$;19!0| (|#1| $$)
  (SPADCALL |#1| (QREFELT $$ 1) (QREFELT (QREFELT $$ 0) 52))) 

(DEFUN |DIRPROD;*;R2$;20| (|r| |u| $)
  (SPADCALL (CONS #'|DIRPROD;*;R2$;20!0| (VECTOR $ |r|)) |u|
      (QREFELT $ 54))) 

(DEFUN |DIRPROD;*;R2$;20!0| (|#1| $$)
  (SPADCALL (QREFELT $$ 1) |#1| (QREFELT (QREFELT $$ 0) 52))) 

(DEFUN |DIRPROD;*;3$;21| (|x| |y| $)
  (PROG (#0=#:G1887 #1=#:G1888 |i| #2=#:G1889)
    (RETURN
      (SEQ (PRIMVEC2ARR
               (PROGN
                 (LETT #0# (GETREFV #3=(QREFELT $ 6))
                       . #4=(|DIRPROD;*;3$;21|))
                 (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
                                          (SPADCALL |x| |i|
                                           (QREFELT $ 21))
                                          (SPADCALL |y| |i|
                                           (QREFELT $ 21))
                                          (QREFELT $ 52)))))
                      (LETT |i|
                            (PROG1 (QSADD1 |i|)
                              (LETT #1# (QSADD1 #1#) . #4#)) . #4#)
                      (GO G190) G191 (EXIT NIL))
                 #0#)))))) 

(DEFUN |DIRPROD;subtractIfCan;2$U;22| (|u| |v| $)
  (PROG (|w| |i| #0=#:G1903 |c| #1=#:G1902)
    (RETURN
      (SEQ (EXIT (SEQ (LETT |w|
                            (SPADCALL (QREFELT $ 6)
                                (|spadConstant| $ 58) (QREFELT $ 51))
                            . #2=(|DIRPROD;subtractIfCan;2$U;22|))
                      (SEQ (LETT |i| 1 . #2#)
                           (LETT #0# (QREFELT $ 6) . #2#) G190
                           (COND ((QSGREATERP |i| #0#) (GO G191)))
                           (SEQ (LETT |c|
                                      (SPADCALL
                                       (SPADCALL |u| |i|
                                        (QREFELT $ 26))
                                       (SPADCALL |v| |i|
                                        (QREFELT $ 26))
                                       (QREFELT $ 60)) . #2#)
                                (EXIT (COND
                                        ((QEQCAR |c| 1)
                                         (PROGN
                                           (LETT #1#
                                            (CONS 1 "failed") . #2#)
                                           (GO #1#)))
                                        ('T
                                         (SPADCALL |w| |i| (QCDR |c|)
                                          (QREFELT $ 61))))))
                           (LETT |i| (QSADD1 |i|) . #2#) (GO G190) G191
                           (EXIT NIL))
                      (EXIT (CONS 0 |w|))))
           #1# (EXIT #1#))))) 

(DEFUN |DIRPROD;*;3$;23| (|u| |v| $)
  (SPADCALL (ELT $ 52) |u| |v| (QREFELT $ 46))) 

(DEFUN |DIRPROD;recip;$U;24| (|z| $)
  (PROG (|w| |i| #0=#:G1915 |u| #1=#:G1914)
    (RETURN
      (SEQ (EXIT (SEQ (LETT |w|
                            (SPADCALL (QREFELT $ 6)
                                (|spadConstant| $ 58) (QREFELT $ 51))
                            . #2=(|DIRPROD;recip;$U;24|))
                      (SEQ (LETT |i|
                                 (SPADCALL |w| (QREFELT $ 20)) . #2#)
                           (LETT #0#
                                 (SPADCALL |w| (QREFELT $ 63)) . #2#)
                           G190 (COND ((> |i| #0#) (GO G191)))
                           (SEQ (LETT |u|
                                      (SPADCALL
                                       (SPADCALL |z| |i|
                                        (QREFELT $ 64))
                                       (QREFELT $ 65)) . #2#)
                                (EXIT (COND
                                        ((QEQCAR |u| 1)
                                         (PROGN
                                           (LETT #1#
                                            (CONS 1 "failed") . #2#)
                                           (GO #1#)))
                                        ('T
                                         (SPADCALL |w| |i| (QCDR |u|)
                                          (QREFELT $ 61))))))
                           (LETT |i| (+ |i| 1) . #2#) (GO G190) G191
                           (EXIT NIL))
                      (EXIT (CONS 0 |w|))))
           #1# (EXIT #1#))))) 

(DEFUN |DIRPROD;unitVector;Pi$;25| (|i| $)
  (PROG (|v|)
    (RETURN
      (SEQ (LETT |v|
                 (SPADCALL (QREFELT $ 6) (|spadConstant| $ 58)
                     (QREFELT $ 51))
                 |DIRPROD;unitVector;Pi$;25|)
           (SPADCALL |v| |i| (|spadConstant| $ 50) (QREFELT $ 67))
           (EXIT |v|))))) 

(DEFUN |DIRPROD;<;2$B;26| (|x| |y| $)
  (PROG (|i| #0=#:G1923 |a| |b| #1=#:G1922 #2=#:G1918)
    (RETURN
      (SEQ (EXIT (SEQ (SEQ (LETT |i| 0 . #3=(|DIRPROD;<;2$B;26|))
                           (LETT #0# (- (QREFELT $ 6) 1) . #3#) G190
                           (COND ((QSGREATERP |i| #0#) (GO G191)))
                           (SEQ (LETT |a| (QREFELT |x| |i|) . #3#)
                                (LETT |b| (QREFELT |y| |i|) . #3#)
                                (EXIT (COND
                                        ((QLESSP |a| |b|)
                                         (PROGN
                                           (LETT #1# 'T . #3#)
                                           (GO #1#)))
                                        ('T
                                         (SEQ
                                          (EXIT
                                           (COND
                                             ((QLESSP |b| |a|)
                                              (PROGN
                                                (LETT #2#
                                                 (PROGN
                                                   (LETT #1#
                                                    'NIL . #3#)
                                                   (GO #1#)) . #3#)
                                                (GO #2#)))))
                                          #2# (EXIT #2#))))))
                           (LETT |i| (QSADD1 |i|) . #3#) (GO G190) G191
                           (EXIT NIL))
                      (EXIT 'NIL)))
           #1# (EXIT #1#))))) 

(DEFUN |DIRPROD;<;2$B;27| (|x| |y| $)
  (PROG (|i| #0=#:G1929 |a| |b| #1=#:G1928 #2=#:G1924)
    (RETURN
      (SEQ (EXIT (SEQ (SEQ (LETT |i| 0 . #3=(|DIRPROD;<;2$B;27|))
                           (LETT #0# (- (QREFELT $ 6) 1) . #3#) G190
                           (COND ((QSGREATERP |i| #0#) (GO G191)))
                           (SEQ (LETT |a| (QREFELT |x| |i|) . #3#)
                                (LETT |b| (QREFELT |y| |i|) . #3#)
                                (EXIT (COND
                                        ((QLESSP |a| |b|)
                                         (PROGN
                                           (LETT #1# 'T . #3#)
                                           (GO #1#)))
                                        ('T
                                         (SEQ
                                          (EXIT
                                           (COND
                                             ((QLESSP |b| |a|)
                                              (PROGN
                                                (LETT #2#
                                                 (PROGN
                                                   (LETT #1#
                                                    'NIL . #3#)
                                                   (GO #1#)) . #3#)
                                                (GO #2#)))))
                                          #2# (EXIT #2#))))))
                           (LETT |i| (QSADD1 |i|) . #3#) (GO G190) G191
                           (EXIT NIL))
                      (EXIT 'NIL)))
           #1# (EXIT #1#))))) 

(DEFUN |DIRPROD;<;2$B;28| (|x| |y| $)
  (PROG (|i| #0=#:G1935 #1=#:G1934 #2=#:G1930)
    (RETURN
      (SEQ (EXIT (SEQ (SEQ (LETT |i| 1 . #3=(|DIRPROD;<;2$B;28|))
                           (LETT #0# (QREFELT $ 6) . #3#) G190
                           (COND ((QSGREATERP |i| #0#) (GO G191)))
                           (SEQ (EXIT (COND
                                        ((SPADCALL
                                          (SPADCALL |x| |i|
                                           (QREFELT $ 64))
                                          (SPADCALL |y| |i|
                                           (QREFELT $ 64))
                                          (QREFELT $ 70))
                                         (PROGN
                                           (LETT #1# 'T . #3#)
                                           (GO #1#)))
                                        ('T
                                         (SEQ
                                          (EXIT
                                           (COND
                                             ((SPADCALL
                                               (SPADCALL |y| |i|
                                                (QREFELT $ 64))
                                               (SPADCALL |x| |i|
                                                (QREFELT $ 64))
                                               (QREFELT $ 70))
                                              (PROGN
                                                (LETT #2#
                                                 (PROGN
                                                   (LETT #1#
                                                    'NIL . #3#)
                                                   (GO #1#)) . #3#)
                                                (GO #2#)))))
                                          #2# (EXIT #2#))))))
                           (LETT |i| (QSADD1 |i|) . #3#) (GO G190) G191
                           (EXIT NIL))
                      (EXIT 'NIL)))
           #1# (EXIT #1#))))) 

(DEFUN |DIRPROD;sup;3$;29| (|x| |y| $)
  (SPADCALL (ELT $ 71) |x| |y| (QREFELT $ 46))) 

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

(DEFUN |DirectProduct;| (|#1| |#2|)
  (PROG (DV$1 DV$2 |dv$| $ #0=#:G1950 #1=#:G1949 #2=#:G1948 #3=#:G1947
              #4=#:G1946 |pv$|)
    (RETURN
      (PROGN
        (LETT DV$1 (|devaluate| |#1|) . #5=(|DirectProduct|))
        (LETT DV$2 (|devaluate| |#2|) . #5#)
        (LETT |dv$| (LIST '|DirectProduct| DV$1 DV$2) . #5#)
        (LETT $ (GETREFV 93) . #5#)
        (QSETREFV $ 0 |dv$|)
        (QSETREFV $ 3
            (LETT |pv$|
                  (|buildPredVector| 0 0
                      (LIST (|HasCategory| |#2| '(|SetCategory|))
                            (|HasCategory| |#2| '(|Field|))
                            (|HasCategory| |#2| '(|Ring|))
                            (|HasCategory| |#2|
                                '(|OrderedAbelianMonoidSup|))
                            (LETT #0#
                                  (|HasCategory| |#2| '(|OrderedRing|)) . #5#)
                            (OR (|HasCategory| |#2|
                                    '(|OrderedAbelianMonoidSup|))
                                #0#)
                            (|HasCategory| |#2| '(|Monoid|))
                            (|HasCategory| |#2| '(|unitsKnown|))
                            (LETT #1#
                                  (|HasCategory| |#2|
                                      '(|CommutativeRing|)) . #5#)
                            (OR #1# (|HasCategory| |#2| '(|Field|))
                                (|HasCategory| |#2| '(|Ring|)))
                            (OR #1# (|HasCategory| |#2| '(|Field|)))
                            (OR #1# (|HasCategory| |#2| '(|Ring|)))
                            (|HasCategory| |#2| '(|Finite|))
                            (|HasCategory| |#2|
                                '(|LinearlyExplicitRingOver|
                                     (|Integer|)))
                            (|HasCategory| |#2|
                                '(|PartialDifferentialRing| (|Symbol|)))
                            (LETT #2#
                                  (|HasCategory| |#2|
                                      '(|DifferentialRing|)) . #5#)
                            (OR (|HasCategory| |#2|
                                    '(|LinearlyExplicitRingOver|
                                      (|Integer|)))
                                (|HasCategory| |#2|
                                    '(|PartialDifferentialRing|
                                      (|Symbol|)))
                                #1# #2# (|HasCategory| |#2| '(|Field|))
                                (|HasCategory| |#2| '(|Ring|)))
                            (OR (|HasCategory| |#2|
                                    '(|LinearlyExplicitRingOver|
                                      (|Integer|)))
                                (|HasCategory| |#2|
                                    '(|PartialDifferentialRing|
                                      (|Symbol|)))
                                #1# #2# (|HasCategory| |#2| '(|Ring|)))
                            (|HasCategory| (|Integer|) '(|OrderedSet|))
                            (AND (|HasCategory| |#2| '(|Ring|))
                                 (|HasCategory| |#2|
                                     '(|LinearlyExplicitRingOver|
                                       (|Integer|))))
                            (AND #2# (|HasCategory| |#2| '(|Ring|)))
                            (AND (|HasCategory| |#2| '(|Ring|))
                                 (|HasCategory| |#2|
                                     '(|PartialDifferentialRing|
                                       (|Symbol|))))
                            (AND (|HasCategory| |#2| '(|SetCategory|))
                                 (|HasCategory| |#2|
                                     '(|RetractableTo| (|Integer|))))
                            (OR (|HasCategory| |#2| '(|Ring|))
                                (AND (|HasCategory| |#2|
                                      '(|SetCategory|))
                                     (|HasCategory| |#2|
                                      '(|RetractableTo| (|Integer|)))))
                            (AND (|HasCategory| |#2|
                                     '(|RetractableTo|
                                       (|Fraction| (|Integer|))))
                                 (|HasCategory| |#2| '(|SetCategory|)))
                            (LETT #3#
                                  (|HasCategory| |#2|
                                      '(|CancellationAbelianMonoid|)) . #5#)
                            (OR (|HasCategory| |#2|
                                    '(|LinearlyExplicitRingOver|
                                      (|Integer|)))
                                (|HasCategory| |#2|
                                    '(|PartialDifferentialRing|
                                      (|Symbol|)))
                                #3# #1# #2#
                                (|HasCategory| |#2| '(|Field|))
                                (|HasCategory| |#2| '(|Ring|)))
                            (LETT #4#
                                  (|HasCategory| |#2|
                                      '(|AbelianSemiGroup|)) . #5#)
                            (OR (|HasCategory| |#2|
                                    '(|LinearlyExplicitRingOver|
                                      (|Integer|)))
                                (|HasCategory| |#2|
                                    '(|PartialDifferentialRing|
                                      (|Symbol|)))
                                #4# #3# #1# #2#
                                (|HasCategory| |#2| '(|Field|))
                                (|HasCategory| |#2| '(|Finite|))
                                (|HasCategory| |#2| '(|Monoid|))
                                (|HasCategory| |#2|
                                    '(|OrderedAbelianMonoidSup|))
                                #0# (|HasCategory| |#2| '(|Ring|))
                                (|HasCategory| |#2| '(|SetCategory|)))
                            (OR (|HasCategory| |#2|
                                    '(|LinearlyExplicitRingOver|
                                      (|Integer|)))
                                (|HasCategory| |#2|
                                    '(|PartialDifferentialRing|
                                      (|Symbol|)))
                                #4# #3# #1# #2#
                                (|HasCategory| |#2| '(|Field|))
                                (|HasCategory| |#2| '(|Ring|)))
                            (OR (AND (|HasCategory| |#2|
                                      '(|RetractableTo|
                                        (|Fraction| (|Integer|))))
                                     (|HasCategory| |#2|
                                      '(|LinearlyExplicitRingOver|
                                        (|Integer|))))
                                (AND (|HasCategory| |#2|
                                      '(|RetractableTo|
                                        (|Fraction| (|Integer|))))
                                     (|HasCategory| |#2|
                                      '(|PartialDifferentialRing|
                                        (|Symbol|))))
                                (AND (|HasCategory| |#2|
                                      '(|RetractableTo|
                                        (|Fraction| (|Integer|))))
                                     #4#)
                                (AND (|HasCategory| |#2|
                                      '(|RetractableTo|
                                        (|Fraction| (|Integer|))))
                                     #3#)
                                (AND (|HasCategory| |#2|
                                      '(|RetractableTo|
                                        (|Fraction| (|Integer|))))
                                     #1#)
                                (AND (|HasCategory| |#2|
                                      '(|RetractableTo|
                                        (|Fraction| (|Integer|))))
                                     #2#)
                                (AND (|HasCategory| |#2|
                                      '(|RetractableTo|
                                        (|Fraction| (|Integer|))))
                                     (|HasCategory| |#2| '(|Field|)))
                                (AND (|HasCategory| |#2|
                                      '(|RetractableTo|
                                        (|Fraction| (|Integer|))))
                                     (|HasCategory| |#2| '(|Finite|)))
                                (AND (|HasCategory| |#2|
                                      '(|RetractableTo|
                                        (|Fraction| (|Integer|))))
                                     (|HasCategory| |#2| '(|Monoid|)))
                                (AND (|HasCategory| |#2|
                                      '(|RetractableTo|
                                        (|Fraction| (|Integer|))))
                                     (|HasCategory| |#2|
                                      '(|OrderedAbelianMonoidSup|)))
                                (AND (|HasCategory| |#2|
                                      '(|RetractableTo|
                                        (|Fraction| (|Integer|))))
                                     #0#)
                                (AND (|HasCategory| |#2|
                                      '(|RetractableTo|
                                        (|Fraction| (|Integer|))))
                                     (|HasCategory| |#2| '(|Ring|)))
                                (AND (|HasCategory| |#2|
                                      '(|RetractableTo|
                                        (|Fraction| (|Integer|))))
                                     (|HasCategory| |#2|
                                      '(|SetCategory|))))
                            (OR (AND (|HasCategory| |#2|
                                      '(|LinearlyExplicitRingOver|
                                        (|Integer|)))
                                     (|HasCategory| |#2|
                                      '(|RetractableTo| (|Integer|))))
                                (AND (|HasCategory| |#2|
                                      '(|PartialDifferentialRing|
                                        (|Symbol|)))
                                     (|HasCategory| |#2|
                                      '(|RetractableTo| (|Integer|))))
                                (AND #4#
                                     (|HasCategory| |#2|
                                      '(|RetractableTo| (|Integer|))))
                                (AND #3#
                                     (|HasCategory| |#2|
                                      '(|RetractableTo| (|Integer|))))
                                (AND #1#
                                     (|HasCategory| |#2|
                                      '(|RetractableTo| (|Integer|))))
                                (AND #2#
                                     (|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 #0#
                                     (|HasCategory| |#2|
                                      '(|RetractableTo| (|Integer|))))
                                (AND (|HasCategory| |#2| '(|Ring|))
                                     (|HasCategory| |#2|
                                      '(|RetractableTo| (|Integer|))))
                                (AND (|HasCategory| |#2|
                                      '(|SetCategory|))
                                     (|HasCategory| |#2|
                                      '(|RetractableTo| (|Integer|)))))
                            (AND (|HasCategory| |#2| '(|SetCategory|))
                                 (|HasCategory| |#2|
                                     (LIST '|Evalable|
                                      (|devaluate| |#2|))))
                            (OR (AND #4#
                                     (|HasCategory| |#2|
                                      (LIST '|Evalable|
                                       (|devaluate| |#2|))))
                                (AND #3#
                                     (|HasCategory| |#2|
                                      (LIST '|Evalable|
                                       (|devaluate| |#2|))))
                                (AND #1#
                                     (|HasCategory| |#2|
                                      (LIST '|Evalable|
                                       (|devaluate| |#2|))))
                                (AND #2#
                                     (|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 #0#
                                     (|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|))))))) . #5#))
        (|haddProp| |$ConstructorCache| '|DirectProduct|
            (LIST DV$1 DV$2) (CONS 1 $))
        (|stuffDomainSlots| $)
        (QSETREFV $ 6 |#1|)
        (QSETREFV $ 7 |#2|)
        (AND (|HasCategory| $ '(|finiteAggregate|))
             (|augmentPredVector| $ 17179869184))
        (AND (|HasCategory| $ '(|finiteAggregate|))
             (|HasCategory| |#2| '(|SetCategory|))
             (|augmentPredVector| $ 34359738368))
        (AND (|HasCategory| $ '(|shallowlyMutable|))
             (|augmentPredVector| $ 68719476736))
        (QSETREFV $ 8 (|Vector| |#2|))
        (COND
          ((|testBitVector| |pv$| 1)
           (PROGN
             (COND
               ((|domainEqual| |#2| (|NonNegativeInteger|))
                (QSETREFV $ 25
                    (CONS (|dispatchFunction| |DIRPROD;=;2$B;6|) $)))
               ((|domainEqual| |#2| (|Integer|))
                (QSETREFV $ 25
                    (CONS (|dispatchFunction| |DIRPROD;=;2$B;7|) $)))
               ('T
                (QSETREFV $ 25
                    (CONS (|dispatchFunction| |DIRPROD;=;2$B;8|) $))))
             (QSETREFV $ 27
                 (CONS (|dispatchFunction| |DIRPROD;retract;$R;9|) $))
             (QSETREFV $ 29
                 (CONS (|dispatchFunction|
                           |DIRPROD;retractIfCan;$U;10|)
                       $)))))
        (COND
          ((|testBitVector| |pv$| 13)
           (PROGN
             (QSETREFV $ 31
                 (CONS (|dispatchFunction| |DIRPROD;size;Nni;11|) $))
             (QSETREFV $ 35
                 (CONS (|dispatchFunction| |DIRPROD;index;Pi$;12|) $))
             (QSETREFV $ 37
                 (CONS (|dispatchFunction| |DIRPROD;random;$;13|) $))
             (QSETREFV $ 40
                 (CONS (|dispatchFunction| |DIRPROD;lookup;$Pi;14|) $))
             (QSETREFV $ 43
                 (CONS (|dispatchFunction| |DIRPROD;hash;$Si;15|) $)))))
        (COND
          ((|testBitVector| |pv$| 28)
           (QSETREFV $ 47
               (CONS (|dispatchFunction| |DIRPROD;+;3$;16|) $))))
        (COND
          ((|HasCategory| |#2| '(|AbelianMonoid|))
           (QSETREFV $ 49
               (CONS IDENTITY
                     (FUNCALL (|dispatchFunction| |DIRPROD;Zero;$;17|)
                              $)))))
        (COND
          ((|testBitVector| |pv$| 7)
           (PROGN
             (QSETREFV $ 38
                 (CONS IDENTITY
                       (FUNCALL (|dispatchFunction| |DIRPROD;One;$;18|)
                                $)))
             (QSETREFV $ 55
                 (CONS (|dispatchFunction| |DIRPROD;*;$R$;19|) $))
             (QSETREFV $ 56
                 (CONS (|dispatchFunction| |DIRPROD;*;R2$;20|) $))
             (QSETREFV $ 57
                 (CONS (|dispatchFunction| |DIRPROD;*;3$;21|) $)))))
        (COND
          ((|testBitVector| |pv$| 26)
           (QSETREFV $ 62
               (CONS (|dispatchFunction|
                         |DIRPROD;subtractIfCan;2$U;22|)
                     $))))
        (COND
          ((|testBitVector| |pv$| 3)
           (PROGN
             (QSETREFV $ 57
                 (CONS (|dispatchFunction| |DIRPROD;*;3$;23|) $))
             (QSETREFV $ 66
                 (CONS (|dispatchFunction| |DIRPROD;recip;$U;24|) $))
             (QSETREFV $ 68
                 (CONS (|dispatchFunction| |DIRPROD;unitVector;Pi$;25|)
                       $)))))
        (COND
          ((|HasCategory| |#2| '(|OrderedSet|))
           (COND
             ((|domainEqual| |#2| (|NonNegativeInteger|))
              (QSETREFV $ 69
                  (CONS (|dispatchFunction| |DIRPROD;<;2$B;26|) $)))
             ((|domainEqual| |#2| (|Integer|))
              (QSETREFV $ 69
                  (CONS (|dispatchFunction| |DIRPROD;<;2$B;27|) $)))
             ('T
              (QSETREFV $ 69
                  (CONS (|dispatchFunction| |DIRPROD;<;2$B;28|) $))))))
        (COND
          ((|testBitVector| |pv$| 4)
           (QSETREFV $ 72
               (CONS (|dispatchFunction| |DIRPROD;sup;3$;29|) $))))
        $)))) 

(MAKEPROP '|DirectProduct| '|infovec|
    (LIST '#(NIL NIL NIL NIL NIL (|Vector| 7) (|local| |#1|)
             (|local| |#2|) '|Rep| (0 . |copy|) |DIRPROD;coerce;$V;1|
             (|NonNegativeInteger|) (5 . |new|) |DIRPROD;coerce;R$;2|
             (|List| 7) |DIRPROD;parts;$L;3| (|Boolean|) (11 . |size?|)
             |DIRPROD;directProduct;V$;4| (|Integer|) (17 . |minIndex|)
             (22 . |elt|) (28 . =) (|Mapping| 16 7) (34 . |every?|)
             (40 . =) (46 . |qelt|) (52 . |retract|)
             (|Union| 7 '"failed") (57 . |retractIfCan|) (62 . |size|)
             (66 . |size|) (|PositiveInteger|) (70 . |index|)
             (75 . |vector|) (80 . |index|) (85 . |random|)
             (89 . |random|) (93 . |One|) (97 . |lookup|)
             (102 . |lookup|) (|SingleInteger|) (107 . |hash|)
             (112 . |hash|) (117 . +) (|Mapping| 7 7 7) (123 . |map|)
             (130 . +) (136 . |zero|) (141 . |Zero|) (145 . |One|)
             (149 . |new|) (155 . *) (|Mapping| 7 7) (161 . |map|)
             (167 . *) (173 . *) (179 . *) (185 . |Zero|)
             (|Union| $ '"failed") (189 . |subtractIfCan|)
             (195 . |qsetelt!|) (202 . |subtractIfCan|)
             (208 . |maxIndex|) (213 . |qelt|) (219 . |recip|)
             (224 . |recip|) (229 . |setelt|) (236 . |unitVector|)
             (241 . <) (247 . <) (253 . |sup|) (259 . |sup|)
             (|List| 74) (|Equation| 7) (|Matrix| 19) (|Matrix| $)
             (|Record| (|:| |mat| 75) (|:| |vec| (|Vector| 19)))
             (|Vector| $) (|List| 81) (|List| 11) (|Symbol|)
             (|Union| 83 '"failed") (|Fraction| 19)
             (|Union| 19 '"failed") (|Void|) (|CardinalNumber|)
             (|List| $) (|Record| (|:| |mat| 89) (|:| |vec| 5))
             (|Matrix| 7) (|OutputForm|) (|String|) (|List| 19))
          '#(~= 265 |zero?| 271 |unitVector| 276 |swap!| 281 |sup| 288
             |subtractIfCan| 294 |size?| 300 |size| 306 |sign| 310
             |setelt| 315 |sample| 322 |retractIfCan| 326 |retract| 341
             |reducedSystem| 356 |recip| 378 |random| 383 |qsetelt!|
             387 |qelt| 394 |positive?| 400 |parts| 405 |one?| 410
             |negative?| 415 |more?| 420 |minIndex| 426 |min| 431
             |members| 437 |member?| 442 |maxIndex| 448 |max| 453
             |map!| 459 |map| 465 |lookup| 471 |less?| 476 |latex| 482
             |indices| 487 |index?| 492 |index| 498 |hash| 503 |first|
             508 |fill!| 513 |every?| 519 |eval| 525 |eq?| 551
             |enumerate| 557 |entry?| 561 |entries| 567 |empty?| 572
             |empty| 577 |elt| 581 |dot| 594 |directProduct| 600
             |dimension| 605 |differentiate| 609 |count| 659 |copy| 671
             |coerce| 676 |characteristic| 701 |any?| 705 |abs| 711 ^
             716 |Zero| 728 |One| 732 D 736 >= 786 > 792 = 798 <= 804 <
             810 / 816 - 822 + 833 ** 839 * 851 |#| 887)
          '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 7)
                               (|VectorSpace| 7) (|Algebra| 7)
                               (|FullyLinearlyExplicitRingOver| 7)
                               (|DifferentialExtension| 7) (|Module| 7)
                               (|OrderedRing|) (|CommutativeRing|)
                               (|LinearlyExplicitRingOver| 7)
                               (|LinearlyExplicitRingOver| 19)
                               (|PartialDifferentialRing| 81)
                               (|DifferentialRing|) (|BiModule| 7 7)
                               (|BiModule| $$ $$) (|Ring|)
                               (|LeftModule| 7) (|RightModule| 7)
                               (|OrderedAbelianMonoidSup|)
                               (|OrderedAbelianGroup|)
                               (|LeftModule| $$) (|RightModule| $$)
                               (|Rng|)
                               (|OrderedCancellationAbelianMonoid|)
                               (|AbelianGroup|)
                               (|OrderedAbelianMonoid|) (|SemiRing|)
                               (|CancellationAbelianMonoid|)
                               (|IndexedAggregate| 19 7)
                               (|OrderedAbelianSemiGroup|) (|SemiRng|)
                               (|Monoid|) (|AbelianMonoid|)
                               (|HomogeneousAggregate| 7)
                               (|OrderedSet|) (|SemiGroup|) (|Finite|)
                               (|AbelianSemiGroup|) (|Aggregate|)
                               (|EltableAggregate| 19 7) (|Evalable| 7)
                               (|SetCategory|) (|FullyRetractableTo| 7)
                               (|Type|) (|finiteAggregate|)
                               (|CoercibleTo| (|Vector| 7))
                               (|Eltable| 19 7) (|InnerEvalable| 7 7)
                               (|CoercibleTo| 90) (|unitsKnown|)
                               (|CommutativeStar|) (|BasicType|)
                               (|RetractableTo| 7) (|RetractableTo| 83)
                               (|RetractableTo| 19))
                            (|makeByteWordVec2| 92
                                '(1 8 0 0 9 2 8 0 11 7 12 2 0 16 0 11
                                  17 1 0 19 0 20 2 0 7 0 19 21 2 7 16 0
                                  0 22 2 0 16 23 0 24 2 0 16 0 0 25 2 8
                                  7 0 19 26 1 0 7 0 27 1 0 28 0 29 0 7
                                  11 30 0 0 11 31 1 7 0 32 33 1 8 0 14
                                  34 1 0 0 32 35 0 7 0 36 0 0 0 37 0 0
                                  0 38 1 7 32 0 39 1 0 32 0 40 1 7 41 0
                                  42 1 0 41 0 43 2 7 0 0 0 44 3 8 0 45
                                  0 0 46 2 0 0 0 0 47 1 5 0 11 48 0 0 0
                                  49 0 7 0 50 2 5 0 11 7 51 2 7 0 0 0
                                  52 2 0 0 53 0 54 2 0 0 0 7 55 2 0 0 7
                                  0 56 2 0 0 0 0 57 0 7 0 58 2 7 59 0 0
                                  60 3 8 7 0 19 7 61 2 0 59 0 0 62 1 0
                                  19 0 63 2 0 7 0 19 64 1 7 59 0 65 1 0
                                  59 0 66 3 8 7 0 19 7 67 1 0 0 32 68 2
                                  0 16 0 0 69 2 7 16 0 0 70 2 7 0 0 0
                                  71 2 0 0 0 0 72 2 1 16 0 0 1 1 26 16
                                  0 1 1 3 0 32 68 3 37 85 0 19 19 1 2 4
                                  0 0 0 72 2 26 59 0 0 62 2 0 16 0 11
                                  17 0 13 11 31 1 5 19 0 1 3 37 7 0 19
                                  7 1 0 0 0 1 1 25 82 0 1 1 23 84 0 1 1
                                  1 28 0 29 1 25 83 0 1 1 23 19 0 1 1 1
                                  7 0 27 1 20 75 76 1 2 20 77 76 78 1 2
                                  3 88 76 78 1 1 3 89 76 1 1 7 59 0 66
                                  0 13 0 37 3 37 7 0 19 7 1 2 0 7 0 19
                                  64 1 5 16 0 1 1 35 14 0 15 1 7 16 0 1
                                  1 5 16 0 1 2 0 16 0 11 1 1 19 19 0 20
                                  2 6 0 0 0 1 1 35 14 0 1 2 36 16 7 0 1
                                  1 19 19 0 63 2 6 0 0 0 1 2 37 0 53 0
                                  1 2 0 0 53 0 54 1 13 32 0 40 2 0 16 0
                                  11 1 1 1 91 0 1 1 0 92 0 1 2 0 16 19
                                  0 1 1 13 0 32 35 1 1 41 0 43 1 19 7 0
                                  1 2 37 0 0 7 1 2 35 16 23 0 24 3 33 0
                                  0 14 14 1 3 33 0 0 7 7 1 2 33 0 0 73
                                  1 2 33 0 0 74 1 2 0 16 0 0 1 0 13 87
                                  1 2 36 16 7 0 1 1 0 14 0 1 1 0 16 0 1
                                  0 0 0 1 3 0 7 0 19 7 1 2 0 7 0 19 21
                                  2 3 7 0 0 1 1 0 0 5 18 0 2 86 1 2 21
                                  0 0 11 1 1 21 0 0 1 3 22 0 0 81 11 1
                                  3 22 0 0 79 80 1 2 22 0 0 81 1 2 22 0
                                  0 79 1 2 3 0 0 53 1 3 3 0 0 53 11 1 2
                                  36 11 7 0 1 2 35 11 23 0 1 1 0 0 0 1
                                  1 25 0 83 1 1 24 0 19 1 1 1 0 7 13 1
                                  1 90 0 1 1 0 5 0 10 0 3 11 1 2 35 16
                                  23 0 1 1 5 0 0 1 2 7 0 0 32 1 2 7 0 0
                                  11 1 0 26 0 49 0 7 0 38 2 21 0 0 11 1
                                  1 21 0 0 1 3 22 0 0 79 80 1 3 22 0 0
                                  81 11 1 2 22 0 0 81 1 2 22 0 0 79 1 2
                                  3 0 0 53 1 3 3 0 0 53 11 1 2 6 16 0 0
                                  1 2 6 16 0 0 1 2 1 16 0 0 25 2 6 16 0
                                  0 1 2 6 16 0 0 69 2 2 0 0 7 1 1 3 0 0
                                  1 2 3 0 0 0 1 2 28 0 0 0 47 2 7 0 0
                                  32 1 2 7 0 0 11 1 2 28 0 32 0 1 2 26
                                  0 11 0 1 2 7 0 7 0 56 2 7 0 0 7 55 2
                                  7 0 0 0 57 2 3 0 19 0 1 1 35 11 0 1)))))
          '|lookupComplete|)) 
