
(/VERSIONCHECK 2) 

(DEFUN |M3D;matrixConcat3D;S3$;1| (|dir| |mat1| |mat2| $)
  (PROG (|retVal| #1=#:G678 |j| |temp| #2=#:G677 |i| #3=#:G676 |matRep2|
         |matRep1| |kDim2| |jDim2| |iDim2| |kDim1| |jDim1| |iDim1| |mat2Dim|
         |mat1Dim|)
    (RETURN
     (SEQ
      (COND
       ((NULL (EQUAL |dir| '|i|))
        (COND
         ((NULL (EQUAL |dir| '|j|))
          (COND
           ((NULL (EQUAL |dir| '|k|))
            (EXIT (|error| "the axis of concatenation must be i,j or k"))))))))
      (LETT |mat1Dim| (SPADCALL |mat1| (QREFELT $ 8))
            . #4=(|M3D;matrixConcat3D;S3$;1|))
      (LETT |mat2Dim| (SPADCALL |mat2| (QREFELT $ 8)) . #4#)
      (LETT |iDim1| (SPADCALL |mat1Dim| 1 (QREFELT $ 11)) . #4#)
      (LETT |jDim1| (SPADCALL |mat1Dim| 2 (QREFELT $ 11)) . #4#)
      (LETT |kDim1| (SPADCALL |mat1Dim| 3 (QREFELT $ 11)) . #4#)
      (LETT |iDim2| (SPADCALL |mat2Dim| 1 (QREFELT $ 11)) . #4#)
      (LETT |jDim2| (SPADCALL |mat2Dim| 2 (QREFELT $ 11)) . #4#)
      (LETT |kDim2| (SPADCALL |mat2Dim| 3 (QREFELT $ 11)) . #4#)
      (LETT |matRep1|
            (SPADCALL (SPADCALL |mat1| (QREFELT $ 12)) (QREFELT $ 13)) . #4#)
      (LETT |matRep2|
            (SPADCALL (SPADCALL |mat2| (QREFELT $ 12)) (QREFELT $ 13)) . #4#)
      (COND
       ((EQUAL |dir| '|i|)
        (COND
         ((EQL |jDim1| |jDim2|)
          (COND
           ((EQL |kDim1| |kDim2|)
            (LETT |retVal|
                  (SPADCALL (SPADCALL |matRep1| |matRep2| (QREFELT $ 14))
                            (QREFELT $ 15))
                  . #4#))
           (#5='T (|error| #6="jxk do not agree"))))
         (#5# (|error| #6#)))))
      (COND
       ((EQUAL |dir| '|j|)
        (COND
         ((EQL |iDim1| |iDim2|)
          (COND
           ((EQL |kDim1| |kDim2|)
            (SEQ
             (SEQ (LETT |i| 0 . #4#) (LETT #3# (- |iDim1| 1) . #4#) G190
                  (COND ((QSGREATERP |i| #3#) #7=(GO G191)))
                  (SEQ
                   (EXIT
                    (SETELT |matRep1| |i|
                            (SPADCALL (ELT |matRep1| |i|) (ELT |matRep2| |i|)
                                      (QREFELT $ 17)))))
                  (LETT |i| (QSADD1 |i|) . #4#) #8=(GO G190) G191 (EXIT NIL))
             (EXIT (LETT |retVal| (SPADCALL |matRep1| (QREFELT $ 15)) . #4#))))
           (#5# (|error| #9="ixk do not agree"))))
         (#5# (|error| #9#)))))
      (COND
       ((EQUAL |dir| '|k|)
        (COND
         ((EQL |iDim1| |iDim2|)
          (COND
           ((EQL |jDim1| |jDim2|)
            (SEQ
             (SEQ (LETT |i| 0 . #4#) (LETT #2# (- |iDim1| 1) . #4#) G190
                  (COND ((QSGREATERP |i| #2#) #7#))
                  (SEQ
                   (LETT |temp| (SPADCALL (ELT |matRep1| |i|) (QREFELT $ 18))
                         . #4#)
                   (SEQ (LETT |j| 0 . #4#) (LETT #1# (- |jDim1| 1) . #4#) G190
                        (COND ((QSGREATERP |j| #1#) #7#))
                        (SEQ
                         (EXIT
                          (SETELT |temp| |j|
                                  (SPADCALL (ELT (ELT |matRep1| |i|) |j|)
                                            (ELT (ELT |matRep2| |i|) |j|)
                                            (QREFELT $ 20)))))
                        (LETT |j| (QSADD1 |j|) . #4#) #8# G191 (EXIT NIL))
                   (EXIT (SETELT |matRep1| |i| |temp|)))
                  (LETT |i| (QSADD1 |i|) . #4#) #8# G191 (EXIT NIL))
             (EXIT (LETT |retVal| (SPADCALL |matRep1| (QREFELT $ 15)) . #4#))))
           (#5# (|error| #10="ixj do not agree"))))
         (#5# (|error| #10#)))))
      (EXIT |retVal|))))) 

(DEFUN |M3D;matrixDimensions;$V;2| (|mat| $)
  (PROG (|retVal| |kDim| |matRep3| |jDim| |matRep2| |iDim| |matRep|)
    (RETURN
     (SEQ
      (LETT |matRep| (SPADCALL |mat| (QREFELT $ 12))
            . #1=(|M3D;matrixDimensions;$V;2|))
      (LETT |iDim| (QVSIZE |matRep|) . #1#)
      (LETT |matRep2| (ELT |matRep| 0) . #1#)
      (LETT |jDim| (QVSIZE |matRep2|) . #1#)
      (LETT |matRep3| (ELT |matRep2| 0) . #1#)
      (LETT |kDim| (QVSIZE |matRep3|) . #1#)
      (LETT |retVal| (SPADCALL 3 0 (QREFELT $ 23)) . #1#)
      (SPADCALL |retVal| 1 |iDim| (QREFELT $ 24))
      (SPADCALL |retVal| 2 |jDim| (QREFELT $ 24))
      (SPADCALL |retVal| 3 |kDim| (QREFELT $ 24)) (EXIT |retVal|))))) 

(PUT '|M3D;coerce;Pa$;3| '|SPADreplace| '(XLAM (|matrixRep|) |matrixRep|)) 

(DEFUN |M3D;coerce;Pa$;3| (|matrixRep| $) |matrixRep|) 

(PUT '|M3D;coerce;$Pa;4| '|SPADreplace| '(XLAM (|mat|) |mat|)) 

(DEFUN |M3D;coerce;$Pa;4| (|mat| $) |mat|) 

(DEFUN |M3D;elt;$3NniR;5| (|mat| |i| |j| |k| $)
  (PROG (|matrixRep| |kLength| |jLength| |iLength| |matDims|)
    (RETURN
     (SEQ
      (LETT |matDims| (SPADCALL |mat| (QREFELT $ 8)) . #1=(|M3D;elt;$3NniR;5|))
      (LETT |iLength| (SPADCALL |matDims| 1 (QREFELT $ 11)) . #1#)
      (LETT |jLength| (SPADCALL |matDims| 2 (QREFELT $ 11)) . #1#)
      (LETT |kLength| (SPADCALL |matDims| 3 (QREFELT $ 11)) . #1#)
      (COND
       ((OR
         (OR
          (OR (OR (OR (< |iLength| |i|) (< |jLength| |j|)) (< |kLength| |k|))
              (EQL |i| 0))
          (EQL |j| 0))
         (EQL |k| 0))
        (EXIT
         (|error| "coordinates must be within the bounds of the matrix"))))
      (LETT |matrixRep| (SPADCALL |mat| (QREFELT $ 12)) . #1#)
      (EXIT (ELT (ELT (ELT |matrixRep| (- |i| 1)) (- |j| 1)) (- |k| 1))))))) 

(DEFUN |M3D;setelt!;$3Nni2R;6| (|mat| |i| |j| |k| |val| $)
  (PROG (|row1| |row2| |matrixRep| |kLength| |jLength| |iLength| |matDims|)
    (RETURN
     (SEQ
      (LETT |matDims| (SPADCALL |mat| (QREFELT $ 8))
            . #1=(|M3D;setelt!;$3Nni2R;6|))
      (LETT |iLength| (SPADCALL |matDims| 1 (QREFELT $ 11)) . #1#)
      (LETT |jLength| (SPADCALL |matDims| 2 (QREFELT $ 11)) . #1#)
      (LETT |kLength| (SPADCALL |matDims| 3 (QREFELT $ 11)) . #1#)
      (COND
       ((OR
         (OR
          (OR (OR (OR (< |iLength| |i|) (< |jLength| |j|)) (< |kLength| |k|))
              (EQL |i| 0))
          (EQL |j| 0))
         (EQL |k| 0))
        (EXIT
         (|error| "coordinates must be within the bounds of the matrix"))))
      (LETT |matrixRep| (SPADCALL |mat| (QREFELT $ 12)) . #1#)
      (LETT |row2| (SPADCALL (ELT |matrixRep| (- |i| 1)) (QREFELT $ 18)) . #1#)
      (LETT |row1| (SPADCALL (ELT |row2| (- |j| 1)) (QREFELT $ 26)) . #1#)
      (SETELT |row1| (- |k| 1) |val|) (SETELT |row2| (- |j| 1) |row1|)
      (SETELT |matrixRep| (- |i| 1) |row2|) (EXIT |val|))))) 

(DEFUN |M3D;zeroMatrix;3Nni$;7| (|iLength| |jLength| |kLength| $)
  (SPADCALL
   (SPADCALL |iLength|
             (SPADCALL |jLength|
                       (SPADCALL |kLength| (|spadConstant| $ 28)
                                 (QREFELT $ 29))
                       (QREFELT $ 30))
             (QREFELT $ 31))
   (QREFELT $ 15))) 

(DEFUN |M3D;identityMatrix;Nni$;8| (|iLength| $)
  (PROG (|row2| |row1| #1=#:G692 |count| |row2empty| |row1empty| |retValueRep|)
    (RETURN
     (SEQ
      (LETT |retValueRep|
            (SPADCALL (SPADCALL |iLength| |iLength| |iLength| (QREFELT $ 32))
                      (QREFELT $ 12))
            . #2=(|M3D;identityMatrix;Nni$;8|))
      (LETT |row1empty|
            (SPADCALL |iLength| (|spadConstant| $ 28) (QREFELT $ 29)) . #2#)
      (LETT |row2empty|
            (SPADCALL |iLength| (SPADCALL |row1empty| (QREFELT $ 26))
                      (QREFELT $ 30))
            . #2#)
      (SEQ (LETT |count| 0 . #2#) (LETT #1# (- |iLength| 1) . #2#) G190
           (COND ((QSGREATERP |count| #1#) (GO G191)))
           (SEQ (LETT |row1| (SPADCALL |row1empty| (QREFELT $ 26)) . #2#)
                (SETELT |row1| |count| (|spadConstant| $ 33))
                (LETT |row2| (SPADCALL |row2empty| (QREFELT $ 18)) . #2#)
                (SETELT |row2| |count| (SPADCALL |row1| (QREFELT $ 26)))
                (EXIT
                 (SETELT |retValueRep| |count|
                         (SPADCALL |row2| (QREFELT $ 18)))))
           (LETT |count| (QSADD1 |count|) . #2#) (GO G190) G191 (EXIT NIL))
      (EXIT (SPADCALL |retValueRep| (QREFELT $ 15))))))) 

(DEFUN |M3D;plus;3$;9| (|mat1| |mat2| $)
  (PROG (|resultMatrix| |sum| |k| |j| |i| |row3| |row2| |row1| |kLength2|
         |jLength2| |iLength2| |mat2Dims| |kLength1| |jLength1| |iLength1|
         |mat1Dims|)
    (RETURN
     (SEQ
      (LETT |mat1Dims| (SPADCALL |mat1| (QREFELT $ 8)) . #1=(|M3D;plus;3$;9|))
      (LETT |iLength1| (SPADCALL |mat1Dims| 1 (QREFELT $ 11)) . #1#)
      (LETT |jLength1| (SPADCALL |mat1Dims| 2 (QREFELT $ 11)) . #1#)
      (LETT |kLength1| (SPADCALL |mat1Dims| 3 (QREFELT $ 11)) . #1#)
      (LETT |mat2Dims| (SPADCALL |mat2| (QREFELT $ 8)) . #1#)
      (LETT |iLength2| (SPADCALL |mat2Dims| 1 (QREFELT $ 11)) . #1#)
      (LETT |jLength2| (SPADCALL |mat2Dims| 2 (QREFELT $ 11)) . #1#)
      (LETT |kLength2| (SPADCALL |mat2Dims| 3 (QREFELT $ 11)) . #1#)
      (COND
       ((EQL |iLength1| |iLength2|)
        (COND
         ((EQL |jLength1| |jLength2|)
          (COND
           ((NULL (EQL |kLength1| |kLength2|))
            (EXIT (|error| #2="error the matrices are different sizes")))))
         (#3='T (EXIT (|error| #2#)))))
       (#3# (EXIT (|error| #2#))))
      (LETT |row1| (SPADCALL |kLength1| (|spadConstant| $ 28) (QREFELT $ 29))
            . #1#)
      (LETT |row2|
            (SPADCALL |jLength1| (SPADCALL |row1| (QREFELT $ 26))
                      (QREFELT $ 30))
            . #1#)
      (LETT |row3|
            (SPADCALL |iLength1| (SPADCALL |row2| (QREFELT $ 18))
                      (QREFELT $ 31))
            . #1#)
      (SEQ (LETT |i| 1 . #1#) G190
           (COND ((QSGREATERP |i| |iLength1|) #4=(GO G191)))
           (SEQ
            (SEQ (LETT |j| 1 . #1#) G190
                 (COND ((QSGREATERP |j| |jLength1|) #4#))
                 (SEQ
                  (SEQ (LETT |k| 1 . #1#) G190
                       (COND ((QSGREATERP |k| |kLength1|) #4#))
                       (SEQ
                        (LETT |sum|
                              (SPADCALL
                               (SPADCALL |mat1| |i| |j| |k| (QREFELT $ 25))
                               (SPADCALL |mat2| |i| |j| |k| (QREFELT $ 25))
                               (QREFELT $ 35))
                              . #1#)
                        (EXIT (SETELT |row1| (- |k| 1) |sum|)))
                       (LETT |k| (QSADD1 |k|) . #1#) #5=(GO G190) G191
                       (EXIT NIL))
                  (EXIT
                   (SETELT |row2| (- |j| 1) (SPADCALL |row1| (QREFELT $ 26)))))
                 (LETT |j| (QSADD1 |j|) . #1#) #5# G191 (EXIT NIL))
            (EXIT (SETELT |row3| (- |i| 1) (SPADCALL |row2| (QREFELT $ 18)))))
           (LETT |i| (QSADD1 |i|) . #1#) #5# G191 (EXIT NIL))
      (LETT |resultMatrix| |row3| . #1#) (EXIT |resultMatrix|))))) 

(DEFUN |M3D;construct;L$;10| (|listRep| $)
  (PROG (|resultMatrix| |element| |k| |j| |i| |row3| |row2| |row1| #1=#:G703
         #2=#:G718 |subSubList| #3=#:G717 |subList| |kLength| |jLength|
         |iLength|)
    (RETURN
     (SEQ
      (COND
       ((OR (EQL (LENGTH |listRep|) 0)
            (OR (EQL (LENGTH (SPADCALL |listRep| 1 (QREFELT $ 39))) 0)
                (EQL
                 (LENGTH
                  (SPADCALL (SPADCALL |listRep| 1 (QREFELT $ 39)) 1
                            (QREFELT $ 41)))
                 0)))
        (|error| "empty list"))
       ('T
        (SEQ (LETT |iLength| (LENGTH |listRep|) . #4=(|M3D;construct;L$;10|))
             (LETT |jLength| (LENGTH (SPADCALL |listRep| 1 (QREFELT $ 39)))
                   . #4#)
             (LETT |kLength|
                   (LENGTH
                    (SPADCALL (SPADCALL |listRep| 1 (QREFELT $ 39)) 1
                              (QREFELT $ 41)))
                   . #4#)
             (SEQ (LETT |subList| NIL . #4#) (LETT #3# |listRep| . #4#) G190
                  (COND
                   ((OR (ATOM #3#)
                        (PROGN (LETT |subList| (CAR #3#) . #4#) NIL))
                    #5=(GO G191)))
                  (SEQ
                   (EXIT
                    (COND
                     ((NULL (EQL (LENGTH |subList|) |jLength|))
                      (|error| "can not have an irregular shaped matrix"))
                     ('T
                      (SEQ
                       (EXIT
                        (SEQ (LETT |subSubList| NIL . #4#)
                             (LETT #2# |subList| . #4#) G190
                             (COND
                              ((OR (ATOM #2#)
                                   (PROGN
                                    (LETT |subSubList| (CAR #2#) . #4#)
                                    NIL))
                               #5#))
                             (SEQ
                              (EXIT
                               (COND
                                ((NULL (EQL (LENGTH |subSubList|) |kLength|))
                                 (PROGN
                                  (LETT #1#
                                        (|error|
                                         "can not have an irregular shaped matrix")
                                        . #4#)
                                  (GO #1#))))))
                             (LETT #2# (CDR #2#) . #4#) #6=(GO G190) G191
                             (EXIT NIL)))
                       #1# (EXIT #1#))))))
                  (LETT #3# (CDR #3#) . #4#) #6# G191 (EXIT NIL))
             (LETT |row1|
                   (SPADCALL |kLength|
                             (SPADCALL
                              (SPADCALL (SPADCALL |listRep| 1 (QREFELT $ 39)) 1
                                        (QREFELT $ 41))
                              1 (QREFELT $ 42))
                             (QREFELT $ 29))
                   . #4#)
             (LETT |row2|
                   (SPADCALL |jLength| (SPADCALL |row1| (QREFELT $ 26))
                             (QREFELT $ 30))
                   . #4#)
             (LETT |row3|
                   (SPADCALL |iLength| (SPADCALL |row2| (QREFELT $ 18))
                             (QREFELT $ 31))
                   . #4#)
             (SEQ (LETT |i| 1 . #4#) G190
                  (COND ((QSGREATERP |i| |iLength|) #5#))
                  (SEQ
                   (SEQ (LETT |j| 1 . #4#) G190
                        (COND ((QSGREATERP |j| |jLength|) #5#))
                        (SEQ
                         (SEQ (LETT |k| 1 . #4#) G190
                              (COND ((QSGREATERP |k| |kLength|) #5#))
                              (SEQ
                               (LETT |element|
                                     (SPADCALL
                                      (SPADCALL
                                       (SPADCALL |listRep| |i| (QREFELT $ 39))
                                       |j| (QREFELT $ 41))
                                      |k| (QREFELT $ 42))
                                     . #4#)
                               (EXIT (SETELT |row1| (- |k| 1) |element|)))
                              (LETT |k| (QSADD1 |k|) . #4#) #6# G191
                              (EXIT NIL))
                         (EXIT
                          (SETELT |row2| (- |j| 1)
                                  (SPADCALL |row1| (QREFELT $ 26)))))
                        (LETT |j| (QSADD1 |j|) . #4#) #6# G191 (EXIT NIL))
                   (EXIT
                    (SETELT |row3| (- |i| 1)
                            (SPADCALL |row2| (QREFELT $ 18)))))
                  (LETT |i| (QSADD1 |i|) . #4#) #6# G191 (EXIT NIL))
             (LETT |resultMatrix| |row3| . #4#) (EXIT |resultMatrix|)))))))) 

(DEFUN |ThreeDimensionalMatrix| (#1=#:G722)
  (PROG ()
    (RETURN
     (PROG (#2=#:G723)
       (RETURN
        (COND
         ((LETT #2#
                (|lassocShiftWithFunction| (LIST (|devaluate| #1#))
                                           (HGET |$ConstructorCache|
                                                 '|ThreeDimensionalMatrix|)
                                           '|domainEqualList|)
                . #3=(|ThreeDimensionalMatrix|))
          (|CDRwithIncrement| #2#))
         ('T
          (UNWIND-PROTECT
              (PROG1 (|ThreeDimensionalMatrix;| #1#) (LETT #2# T . #3#))
            (COND
             ((NOT #2#)
              (HREM |$ConstructorCache| '|ThreeDimensionalMatrix|))))))))))) 

(DEFUN |ThreeDimensionalMatrix;| (|#1|)
  (PROG (|pv$| $ |dv$| DV$1)
    (RETURN
     (PROGN
      (LETT DV$1 (|devaluate| |#1|) . #1=(|ThreeDimensionalMatrix|))
      (LETT |dv$| (LIST '|ThreeDimensionalMatrix| DV$1) . #1#)
      (LETT $ (GETREFV 52) . #1#)
      (QSETREFV $ 0 |dv$|)
      (QSETREFV $ 3
                (LETT |pv$|
                      (|buildPredVector| 0 0
                                         (LIST
                                          (|HasCategory| |#1| '(|SetCategory|))
                                          (|HasCategory| |#1| '(|Ring|))
                                          (AND
                                           (|HasCategory| |#1|
                                                          '(|SetCategory|))
                                           (|HasCategory| |#1|
                                                          (LIST '|Evalable|
                                                                (|devaluate|
                                                                 |#1|))))
                                          (OR
                                           (AND (|HasCategory| |#1| '(|Ring|))
                                                (|HasCategory| |#1|
                                                               (LIST
                                                                '|Evalable|
                                                                (|devaluate|
                                                                 |#1|))))
                                           (AND
                                            (|HasCategory| |#1|
                                                           '(|SetCategory|))
                                            (|HasCategory| |#1|
                                                           (LIST '|Evalable|
                                                                 (|devaluate|
                                                                  |#1|)))))))
                      . #1#))
      (|haddProp| |$ConstructorCache| '|ThreeDimensionalMatrix| (LIST DV$1)
                  (CONS 1 $))
      (|stuffDomainSlots| $)
      (QSETREFV $ 6 |#1|)
      (AND (|HasCategory| $ '(|shallowlyMutable|)) (|augmentPredVector| $ 16))
      (AND (|HasCategory| $ '(|finiteAggregate|)) (|augmentPredVector| $ 32))
      (AND (|HasCategory| $ '(|finiteAggregate|))
           (|HasCategory| |#1| '(|SetCategory|)) (|augmentPredVector| $ 64))
      (COND
       ((|testBitVector| |pv$| 2)
        (PROGN
         (QSETREFV $ 32 (CONS (|dispatchFunction| |M3D;zeroMatrix;3Nni$;7|) $))
         (QSETREFV $ 34
                   (CONS (|dispatchFunction| |M3D;identityMatrix;Nni$;8|) $))
         (QSETREFV $ 36 (CONS (|dispatchFunction| |M3D;plus;3$;9|) $)))))
      $)))) 

(MAKEPROP '|ThreeDimensionalMatrix| '|infovec|
          (LIST
           '#(NIL NIL NIL NIL NIL (|PrimitiveArray| 16) (|local| |#1|)
              (|Vector| 9) |M3D;matrixDimensions;$V;2| (|NonNegativeInteger|)
              (|Integer|) (0 . |elt|) |M3D;coerce;$Pa;4| (6 . |copy|)
              (11 . |concat|) |M3D;coerce;Pa$;3| (|PrimitiveArray| 19)
              (17 . |concat|) (23 . |copy|) (|PrimitiveArray| 6)
              (28 . |concat|) (|Symbol|) |M3D;matrixConcat3D;S3$;1|
              (34 . |new|) (40 . |setelt|) |M3D;elt;$3NniR;5| (47 . |copy|)
              |M3D;setelt!;$3Nni2R;6| (52 . |Zero|) (56 . |new|) (62 . |new|)
              (68 . |new|) (74 . |zeroMatrix|) (81 . |One|)
              (85 . |identityMatrix|) (90 . +) (96 . |plus|) (|List| 40)
              (|List| 37) (102 . |elt|) (|List| 6) (108 . |elt|) (114 . |elt|)
              |M3D;construct;L$;10| (|Boolean|) (|Equation| 6) (|List| 45)
              (|Mapping| 44 6) (|Mapping| 6 6) (|OutputForm|) (|String|)
              (|SingleInteger|))
           '#(~= 120 |zeroMatrix| 126 |size?| 133 |setelt!| 139 |sample| 148
              |plus| 152 |parts| 158 |more?| 163 |members| 169 |member?| 174
              |matrixDimensions| 180 |matrixConcat3D| 185 |map!| 192 |map| 198
              |less?| 204 |latex| 210 |identityMatrix| 215 |hash| 220 |every?|
              225 |eval| 231 |eq?| 257 |empty?| 263 |empty| 268 |elt| 272
              |count| 280 |copy| 292 |construct| 297 |coerce| 302 |any?| 317 =
              323 |#| 329)
           'NIL
           (CONS (|makeByteWordVec2| 4 '(0 0 4 1 0 4 1 1))
                 (CONS
                  '#(|HomogeneousAggregate&| |Aggregate&| |Evalable&|
                     |SetCategory&| NIL |InnerEvalable&| |BasicType&| NIL)
                  (CONS
                   '#((|HomogeneousAggregate| 6) (|Aggregate|) (|Evalable| 6)
                      (|SetCategory|) (|Type|) (|InnerEvalable| 6 6)
                      (|BasicType|) (|CoercibleTo| 49))
                   (|makeByteWordVec2| 51
                                       '(2 7 9 0 10 11 1 5 0 0 13 2 5 0 0 0 14
                                         2 16 0 0 0 17 1 16 0 0 18 2 19 0 0 0
                                         20 2 7 0 9 9 23 3 7 9 0 10 9 24 1 19 0
                                         0 26 0 6 0 28 2 19 0 9 6 29 2 16 0 9
                                         19 30 2 5 0 9 16 31 3 0 0 9 9 9 32 0 6
                                         0 33 1 0 0 9 34 2 6 0 0 0 35 2 0 0 0 0
                                         36 2 38 37 0 10 39 2 37 40 0 10 41 2
                                         40 6 0 10 42 2 1 44 0 0 1 3 2 0 9 9 9
                                         32 2 0 44 0 9 1 5 0 6 0 9 9 9 6 27 0 0
                                         0 1 2 2 0 0 0 36 1 6 40 0 1 2 0 44 0 9
                                         1 1 6 40 0 1 2 7 44 6 0 1 1 0 7 0 8 3
                                         0 0 21 0 0 22 2 5 0 48 0 1 2 0 0 48 0
                                         1 2 0 44 0 9 1 1 1 50 0 1 1 2 0 9 34 1
                                         1 51 0 1 2 6 44 47 0 1 3 3 0 0 40 40 1
                                         2 3 0 0 45 1 3 3 0 0 6 6 1 2 3 0 0 46
                                         1 2 0 44 0 0 1 1 0 44 0 1 0 0 0 1 4 0
                                         6 0 9 9 9 25 2 7 9 6 0 1 2 6 9 47 0 1
                                         1 0 0 0 1 1 0 0 38 43 1 1 49 0 1 1 0 0
                                         5 15 1 0 5 0 12 2 6 44 47 0 1 2 1 44 0
                                         0 1 1 6 9 0 1)))))
           '|lookupComplete|)) 
