
(/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| (|x| $$)
  (PROG (|z| $)
    (LETT |z| (QREFELT $$ 1) . #1=(|DIRPROD;same?|))
    (LETT $ (QREFELT $$ 0) . #1#)
    (RETURN
     (PROGN
      (SPADCALL |x| (SPADCALL |z| (SPADCALL |z| (QREFELT $ 20)) (QREFELT $ 21))
                (QREFELT $ 22)))))) 

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

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

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

(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 (L #1=#:G704 |p| #2=#:G709 |i| #3=#:G703 N)
    (RETURN
     (SEQ (LETT N (SPADCALL (QREFELT $ 30)) . #4=(|DIRPROD;index;Pi$;12|))
          (LETT |p| (- |n| 1) . #4#)
          (LETT L
                (LIST
                 (SPADCALL
                  (PROG1 (LETT #3# (+ (REMAINDER2 |p| N) 1) . #4#)
                    (|check-subtype| (> #3# 0) '(|PositiveInteger|) #3#))
                  (QREFELT $ 33)))
                . #4#)
          (SEQ (LETT |i| 2 . #4#) (LETT #2# (QREFELT $ 6) . #4#) G190
               (COND ((QSGREATERP |i| #2#) (GO G191)))
               (SEQ (LETT |p| (QUOTIENT2 |p| N) . #4#)
                    (EXIT
                     (LETT L
                           (CONS
                            (SPADCALL
                             (PROG1 (LETT #1# (+ (REMAINDER2 |p| N) 1) . #4#)
                               (|check-subtype| (> #1# 0) '(|PositiveInteger|)
                                                #1#))
                             (QREFELT $ 33))
                            L)
                           . #4#)))
               (LETT |i| (QSADD1 |i|) . #4#) (GO G190) G191 (EXIT NIL))
          (EXIT (SPADCALL L (QREFELT $ 34))))))) 

(DEFUN |DIRPROD;random;$;13| ($)
  (PROG (#1=#:G714 |i| #2=#:G713 #3=#:G712)
    (RETURN
     (SEQ
      (PROGN
       (LETT #3# (GETREFV #4=(QREFELT $ 6)) . #5=(|DIRPROD;random;$;13|))
       (SEQ (LETT #2# 0 . #5#) (LETT |i| 1 . #5#) (LETT #1# #4# . #5#) G190
            (COND ((QSGREATERP |i| #1#) (GO G191)))
            (SEQ (EXIT (SETELT #3# #2# (SPADCALL (QREFELT $ 36)))))
            (LETT |i| (PROG1 (QSADD1 |i|) (LETT #2# (QSADD1 #2#) . #5#)) . #5#)
            (GO G190) G191 (EXIT NIL))
       #3#))))) 

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

(DEFUN |DIRPROD;hash;$Si;15| (|x| $)
  (PROG (L #1=#:G723 |i|)
    (RETURN
     (SEQ
      (LETT L (SPADCALL (SPADCALL |x| 1 (QREFELT $ 21)) (QREFELT $ 42))
            . #2=(|DIRPROD;hash;$Si;15|))
      (SEQ (LETT |i| 2 . #2#) (LETT #1# (QREFELT $ 6) . #2#) G190
           (COND ((QSGREATERP |i| #1#) (GO G191)))
           (SEQ
            (EXIT
             (LETT L
                   (|hashCombine| L
                                  (SPADCALL (SPADCALL |x| |i| (QREFELT $ 21))
                                            (QREFELT $ 42)))
                   . #2#)))
           (LETT |i| (QSADD1 |i|) . #2#) (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| $)
  (PROG ()
    (RETURN
     (SPADCALL (CONS #'|DIRPROD;*;$R$;19!0| (VECTOR $ |r|)) |u|
               (QREFELT $ 54))))) 

(DEFUN |DIRPROD;*;$R$;19!0| (|x| $$)
  (PROG (|r| $)
    (LETT |r| (QREFELT $$ 1) . #1=(|DIRPROD;*;$R$;19|))
    (LETT $ (QREFELT $$ 0) . #1#)
    (RETURN (PROGN (SPADCALL |x| |r| (QREFELT $ 52)))))) 

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

(DEFUN |DIRPROD;*;R2$;20!0| (|x| $$)
  (PROG (|r| $)
    (LETT |r| (QREFELT $$ 1) . #1=(|DIRPROD;*;R2$;20|))
    (LETT $ (QREFELT $$ 0) . #1#)
    (RETURN (PROGN (SPADCALL |r| |x| (QREFELT $ 52)))))) 

(DEFUN |DIRPROD;*;3$;21| (|x| |y| $)
  (PROG (#1=#:G735 |i| #2=#:G734 #3=#:G733)
    (RETURN
     (SEQ
      (PROGN
       (LETT #3# (GETREFV #4=(QREFELT $ 6)) . #5=(|DIRPROD;*;3$;21|))
       (SEQ (LETT #2# 0 . #5#) (LETT |i| 1 . #5#) (LETT #1# #4# . #5#) G190
            (COND ((QSGREATERP |i| #1#) (GO G191)))
            (SEQ
             (EXIT
              (SETELT #3# #2#
                      (SPADCALL (SPADCALL |x| |i| (QREFELT $ 21))
                                (SPADCALL |y| |i| (QREFELT $ 21))
                                (QREFELT $ 52)))))
            (LETT |i| (PROG1 (QSADD1 |i|) (LETT #2# (QSADD1 #2#) . #5#)) . #5#)
            (GO G190) G191 (EXIT NIL))
       #3#))))) 

(DEFUN |DIRPROD;subtractIfCan;2$U;22| (|u| |v| $)
  (PROG (#1=#:G748 |c| #2=#:G749 |i| |w|)
    (RETURN
     (SEQ
      (EXIT
       (SEQ
        (LETT |w| (SPADCALL (QREFELT $ 6) (|spadConstant| $ 58) (QREFELT $ 51))
              . #3=(|DIRPROD;subtractIfCan;2$U;22|))
        (SEQ (LETT |i| 1 . #3#) (LETT #2# (QREFELT $ 6) . #3#) G190
             (COND ((QSGREATERP |i| #2#) (GO G191)))
             (SEQ
              (LETT |c|
                    (SPADCALL (SPADCALL |u| |i| (QREFELT $ 26))
                              (SPADCALL |v| |i| (QREFELT $ 26)) (QREFELT $ 60))
                    . #3#)
              (EXIT
               (COND
                ((QEQCAR |c| 1)
                 (PROGN (LETT #1# (CONS 1 "failed") . #3#) (GO #1#)))
                ('T (SPADCALL |w| |i| (QCDR |c|) (QREFELT $ 61))))))
             (LETT |i| (QSADD1 |i|) . #3#) (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 (#1=#:G760 |u| #2=#:G761 |i| |w|)
    (RETURN
     (SEQ
      (EXIT
       (SEQ
        (LETT |w| (SPADCALL (QREFELT $ 6) (|spadConstant| $ 58) (QREFELT $ 51))
              . #3=(|DIRPROD;recip;$U;24|))
        (SEQ (LETT |i| (SPADCALL |w| (QREFELT $ 20)) . #3#)
             (LETT #2# (SPADCALL |w| (QREFELT $ 63)) . #3#) G190
             (COND ((> |i| #2#) (GO G191)))
             (SEQ
              (LETT |u|
                    (SPADCALL (SPADCALL |z| |i| (QREFELT $ 64)) (QREFELT $ 65))
                    . #3#)
              (EXIT
               (COND
                ((QEQCAR |u| 1)
                 (PROGN (LETT #1# (CONS 1 "failed") . #3#) (GO #1#)))
                ('T (SPADCALL |w| |i| (QCDR |u|) (QREFELT $ 61))))))
             (LETT |i| (+ |i| 1) . #3#) (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 (#1=#:G764 #2=#:G768 |b| |a| #3=#:G769 |i|)
    (RETURN
     (SEQ
      (EXIT
       (SEQ
        (SEQ (LETT |i| 0 . #4=(|DIRPROD;<;2$B;26|))
             (LETT #3# (- (QREFELT $ 6) 1) . #4#) G190
             (COND ((QSGREATERP |i| #3#) (GO G191)))
             (SEQ (LETT |a| (QREFELT |x| |i|) . #4#)
                  (LETT |b| (QREFELT |y| |i|) . #4#)
                  (EXIT
                   (COND
                    ((QLESSP |a| |b|) (PROGN (LETT #2# 'T . #4#) (GO #2#)))
                    ('T
                     (SEQ
                      (EXIT
                       (COND
                        ((QLESSP |b| |a|)
                         (PROGN
                          (LETT #1# (PROGN (LETT #2# 'NIL . #4#) (GO #2#))
                                . #4#)
                          (GO #1#)))))
                      #1# (EXIT #1#))))))
             (LETT |i| (QSADD1 |i|) . #4#) (GO G190) G191 (EXIT NIL))
        (EXIT 'NIL)))
      #2# (EXIT #2#))))) 

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

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

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

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

(DEFUN |DirectProduct;| (|#1| |#2|)
  (PROG (|pv$| #1=#:G792 #2=#:G793 #3=#:G794 #4=#:G795 #5=#:G796 $ |dv$| DV$2
         DV$1)
    (RETURN
     (PROGN
      (LETT DV$1 (|devaluate| |#1|) . #6=(|DirectProduct|))
      (LETT DV$2 (|devaluate| |#2|) . #6#)
      (LETT |dv$| (LIST '|DirectProduct| DV$1 DV$2) . #6#)
      (LETT $ (GETREFV 93) . #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| '|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)
              (|Record| (|:| |mat| 78) (|:| |vec| (|Vector| 19))) (|Matrix| $)
              (|Vector| $) (|Matrix| 19) (|Symbol|) (|List| 79) (|List| 11)
              (|Fraction| 19) (|Union| 82 '#1="failed") (|Union| 19 '#1#)
              (|Void|) (|CardinalNumber|) (|List| $) (|Matrix| 7)
              (|Record| (|:| |mat| 88) (|:| |vec| 5)) (|OutputForm|) (|String|)
              (|List| 19))
           '#(~= 265 |zero?| 271 |unitVector| 276 |swap!| 281 |sup| 288
              |subtractIfCan| 294 |smaller?| 300 |size?| 306 |size| 312 |sign|
              316 |setelt| 321 |sample| 328 |retractIfCan| 332 |retract| 347
              |reducedSystem| 362 |recip| 384 |random| 389 |qsetelt!| 393
              |qelt| 400 |positive?| 406 |parts| 411 |one?| 416 |negative?| 421
              |more?| 426 |minIndex| 432 |min| 437 |members| 443 |member?| 448
              |maxIndex| 454 |max| 459 |map!| 465 |map| 471 |lookup| 477
              |less?| 482 |latex| 488 |indices| 493 |index?| 498 |index| 504
              |hash| 509 |first| 514 |fill!| 519 |every?| 525 |eval| 531 |eq?|
              557 |enumerate| 563 |entry?| 567 |entries| 573 |empty?| 578
              |empty| 583 |elt| 587 |dot| 600 |directProduct| 606 |dimension|
              611 |differentiate| 615 |count| 665 |copy| 677 |coerce| 682
              |characteristic| 707 |any?| 711 |abs| 717 ^ 722 |Zero| 734 |One|
              738 D 742 >= 792 > 798 = 804 <= 810 < 816 / 822 - 828 + 839 * 845
              |#| 881)
           '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| 19) (|PartialDifferentialRing| 79)
                 (|DifferentialRing|) (|BiModule| 7 7)
                 (|OrderedAbelianMonoidSup|) (|OrderedAbelianGroup|)
                 (|BiModule| $$ $$) (|Ring|) (|LeftModule| 7) (|RightModule| 7)
                 (|OrderedCancellationAbelianMonoid|) (|LeftModule| $$)
                 (|RightModule| $$) (|Rng|) (|OrderedAbelianMonoid|)
                 (|AbelianGroup|) (|OrderedAbelianSemiGroup|) (|SemiRing|)
                 (|CancellationAbelianMonoid|) (|IndexedAggregate| 19 7)
                 (|OrderedSet|) (|SemiRng|) (|Monoid|) (|AbelianMonoid|)
                 (|HomogeneousAggregate| 7) (|Comparable|) (|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| 82) (|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 6 16 0 0 1 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 83 0
                                    1 1 23 84 0 1 1 1 28 0 29 1 25 82 0 1 1 23
                                    19 0 1 1 1 7 0 27 2 20 75 76 77 1 1 20 78
                                    76 1 1 3 88 76 1 2 3 89 76 77 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 80 81 1 2
                                    22 0 0 80 1 3 22 0 0 79 11 1 2 22 0 0 79 1
                                    3 3 0 0 53 11 1 2 3 0 0 53 1 2 36 11 7 0 1
                                    2 35 11 23 0 1 1 0 0 0 1 1 25 0 82 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 11 1 3 22 0 0 80
                                    81 1 2 22 0 0 80 1 2 22 0 0 79 1 3 3 0 0 53
                                    11 1 2 3 0 0 53 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 2 3 0 0 0 1 1 3 0 0 1 2 28 0 0 0
                                    47 2 28 0 32 0 1 2 26 0 11 0 1 2 7 0 7 0 56
                                    2 7 0 0 0 57 2 7 0 0 7 55 2 3 0 19 0 1 1 35
                                    11 0 1)))))
           '|lookupComplete|)) 
