
(/VERSIONCHECK 2) 

(PUT '|VSBASIS;Zero;$;1| '|SPADreplace| '(XLAM NIL NIL)) 

(DEFUN |VSBASIS;Zero;$;1| ($) NIL) 

(PUT '|VSBASIS;coerce;$L;2| '|SPADreplace| '(XLAM (B) B)) 

(DEFUN |VSBASIS;coerce;$L;2| (B $) B) 

(DEFUN |VSBASIS;coerce;$Of;3| (B $)
  (PROG (|a2| |a1|)
    (RETURN
     (SEQ (LETT |a1| "VectorSpace " . #1=(|VSBASIS;coerce;$Of;3|))
          (LETT |a2| (SPADCALL B (QREFELT $ 11)) . #1#)
          (EXIT (SPADCALL |a1| |a2| (QREFELT $ 12))))))) 

(DEFUN |VSBASIS;column2matrix| (|Lv| $)
  (PROG (#1=#:G1833 |k| #2=#:G1834 |v| M |n|)
    (RETURN
     (SEQ
      (LETT |n| (QVSIZE (SPADCALL |Lv| 1 (QREFELT $ 17)))
            . #3=(|VSBASIS;column2matrix|))
      (LETT M (SPADCALL |n| (LENGTH |Lv|) (|spadConstant| $ 18) (QREFELT $ 21))
            . #3#)
      (SEQ (LETT |v| NIL . #3#) (LETT #2# |Lv| . #3#) (LETT |k| 1 . #3#)
           (LETT #1# (LENGTH |Lv|) . #3#) G190
           (COND
            ((OR (QSGREATERP |k| #1#) (ATOM #2#)
                 (PROGN (LETT |v| (CAR #2#) . #3#) NIL))
             (GO G191)))
           (SEQ
            (EXIT
             (COND
              ((NULL (EQL |n| (QVSIZE |v|)))
               (|error|
                "Length of vectors in VectorSpaceBasis must have the same size"))
              ('T (SPADCALL M |k| |v| (QREFELT $ 22))))))
           (LETT |k| (PROG1 (QSADD1 |k|) (LETT #2# (CDR #2#) . #3#)) . #3#)
           (GO G190) G191 (EXIT NIL))
      (EXIT M))))) 

(DEFUN |VSBASIS;basis;L$;5| (|Lv| $)
  (COND ((EQL (LENGTH |Lv|) 0) (|spadConstant| $ 8))
        ('T (SPADCALL (|VSBASIS;column2matrix| |Lv| $) (QREFELT $ 23))))) 

(DEFUN |VSBASIS;columnSpace;M$;6| (M $) (SPADCALL M (QREFELT $ 23))) 

(DEFUN |VSBASIS;nullSpace;M$;7| (M $) (SPADCALL M (QREFELT $ 26))) 

(DEFUN |VSBASIS;sumBasis;2L$;8| (|Lv| |Lw| $)
  (SPADCALL (SPADCALL |Lv| |Lw| (QREFELT $ 28)) (QREFELT $ 24))) 

(DEFUN |VSBASIS;sumBasis;3$;9| (B1 B2 $)
  (SPADCALL (SPADCALL B1 B2 (QREFELT $ 28)) (QREFELT $ 24))) 

(DEFUN |VSBASIS;sumBasis;L$;10| (|LLv| $)
  (SPADCALL (SPADCALL |LLv| (QREFELT $ 32)) (QREFELT $ 24))) 

(DEFUN |VSBASIS;sumBasis;L$;11| (LB $)
  (SPADCALL (SPADCALL LB (QREFELT $ 35)) (QREFELT $ 24))) 

(DEFUN |VSBASIS;+;3$;12| (B1 B2 $) (SPADCALL B1 B2 (QREFELT $ 30))) 

(DEFUN |VSBASIS;subVector| (|v| |a| |b| $)
  (PROG (#1=#:G1848 |k| |vv| #2=#:G1844)
    (RETURN
     (SEQ
      (LETT |vv|
            (MAKEARR1
             (PROG1 (LETT #2# (+ (- |b| |a|) 1) . #3=(|VSBASIS;subVector|))
               (|check-subtype| (>= #2# 0) '(|NonNegativeInteger|) #2#))
             (|spadConstant| $ 18))
            . #3#)
      (SEQ (LETT |k| 1 . #3#) (LETT #1# (+ (- |b| |a|) 1) . #3#) G190
           (COND ((QSGREATERP |k| #1#) (GO G191)))
           (SEQ
            (EXIT (QSETAREF1O |vv| |k| (QAREF1O |v| (- (+ |k| |a|) 1) 1) 1)))
           (LETT |k| (QSADD1 |k|) . #3#) (GO G190) G191 (EXIT NIL))
      (EXIT |vv|))))) 

(DEFUN |VSBASIS;linearSum| (|t| |Lv| $)
  (PROG (#1=#:G1856 |j| |t2| #2=#:G1854 |k| #3=#:G1855 |v2| |vv|)
    (RETURN
     (SEQ
      (LETT |vv|
            (MAKEARR1 (QVSIZE (SPADCALL |Lv| 1 (QREFELT $ 17)))
                      (|spadConstant| $ 18))
            . #4=(|VSBASIS;linearSum|))
      (SEQ (LETT |v2| NIL . #4#) (LETT #3# |Lv| . #4#) (LETT |k| 1 . #4#)
           (LETT #2# (LENGTH |Lv|) . #4#) G190
           (COND
            ((OR (QSGREATERP |k| #2#) (ATOM #3#)
                 (PROGN (LETT |v2| (CAR #3#) . #4#) NIL))
             #5=(GO G191)))
           (SEQ (LETT |t2| (SPADCALL |t| |k| (QREFELT $ 38)) . #4#)
                (EXIT
                 (SEQ (LETT |j| 1 . #4#) (LETT #1# (QVSIZE |vv|) . #4#) G190
                      (COND ((QSGREATERP |j| #1#) #5#))
                      (SEQ
                       (EXIT
                        (SPADCALL |vv| |j|
                                  (SPADCALL (SPADCALL |vv| |j| (QREFELT $ 38))
                                            (SPADCALL |t2|
                                                      (SPADCALL |v2| |j|
                                                                (QREFELT $ 38))
                                                      (QREFELT $ 39))
                                            (QREFELT $ 40))
                                  (QREFELT $ 41))))
                      (LETT |j| (QSADD1 |j|) . #4#) #6=(GO G190) G191
                      (EXIT NIL))))
           (LETT |k| (PROG1 (QSADD1 |k|) (LETT #3# (CDR #3#) . #4#)) . #4#) #6#
           G191 (EXIT NIL))
      (EXIT |vv|))))) 

(DEFUN |VSBASIS;intBasis;2L$;15| (|Lv| |Lw| $)
  (SPADCALL (SPADCALL |Lv| (QREFELT $ 24)) (SPADCALL |Lw| (QREFELT $ 24))
            (QREFELT $ 42))) 

(DEFUN |VSBASIS;intBasis;3$;16| (B1 B2 $)
  (PROG (#1=#:G1870 |cc| #2=#:G1869 |LcoeffB1| #3=#:G1868 |kv| #4=#:G1867
         |lker| |k| #5=#:G1866 |v| #6=#:G1865 |w| M |d2| |d1| |Lw| |Lv|)
    (RETURN
     (SEQ (LETT |Lv| B1 . #7=(|VSBASIS;intBasis;3$;16|)) (LETT |Lw| B2 . #7#)
          (COND ((OR (NULL |Lv|) (NULL |Lw|)) (EXIT (|spadConstant| $ 8))))
          (LETT |d1| (LENGTH |Lv|) . #7#) (LETT |d2| (LENGTH |Lw|) . #7#)
          (COND
           ((NULL
             (EQL (QVSIZE (|SPADfirst| |Lv|)) (QVSIZE (|SPADfirst| |Lw|))))
            (EXIT (|error| "vectors have not the same length in intBasis"))))
          (LETT M
                (SPADCALL (QVSIZE (|SPADfirst| |Lv|)) (+ |d1| |d2|)
                          (|spadConstant| $ 18) (QREFELT $ 21))
                . #7#)
          (SEQ (LETT |w| NIL . #7#) (LETT #6# |Lw| . #7#) (LETT |k| 1 . #7#)
               G190
               (COND
                ((OR (QSGREATERP |k| |d2|) (ATOM #6#)
                     (PROGN (LETT |w| (CAR #6#) . #7#) NIL))
                 #8=(GO G191)))
               (SEQ (EXIT (SPADCALL M |k| |w| (QREFELT $ 22))))
               (LETT |k| (PROG1 (QSADD1 |k|) (LETT #6# (CDR #6#) . #7#)) . #7#)
               #9=(GO G190) G191 (EXIT NIL))
          (SEQ (LETT |v| NIL . #7#) (LETT #5# |Lv| . #7#) (LETT |k| 1 . #7#)
               G190
               (COND
                ((OR (QSGREATERP |k| |d1|) (ATOM #5#)
                     (PROGN (LETT |v| (CAR #5#) . #7#) NIL))
                 #8#))
               (SEQ (EXIT (SPADCALL M (+ |d2| |k|) |v| (QREFELT $ 22))))
               (LETT |k| (PROG1 (QSADD1 |k|) (LETT #5# (CDR #5#) . #7#)) . #7#)
               #9# G191 (EXIT NIL))
          (LETT |lker| (SPADCALL M (QREFELT $ 26)) . #7#)
          (LETT |LcoeffB1|
                (PROGN
                 (LETT #4# NIL . #7#)
                 (SEQ (LETT |kv| NIL . #7#) (LETT #3# |lker| . #7#) G190
                      (COND
                       ((OR (ATOM #3#) (PROGN (LETT |kv| (CAR #3#) . #7#) NIL))
                        #8#))
                      (SEQ
                       (EXIT
                        (LETT #4#
                              (CONS
                               (|VSBASIS;subVector| |kv| (+ |d2| 1)
                                (+ |d2| |d1|) $)
                               #4#)
                              . #7#)))
                      (LETT #3# (CDR #3#) . #7#) #9# G191
                      (EXIT (NREVERSE0 #4#))))
                . #7#)
          (EXIT
           (PROGN
            (LETT #2# NIL . #7#)
            (SEQ (LETT |cc| NIL . #7#) (LETT #1# |LcoeffB1| . #7#) G190
                 (COND
                  ((OR (ATOM #1#) (PROGN (LETT |cc| (CAR #1#) . #7#) NIL))
                   #8#))
                 (SEQ
                  (EXIT
                   (LETT #2# (CONS (|VSBASIS;linearSum| |cc| |Lv| $) #2#)
                         . #7#)))
                 (LETT #1# (CDR #1#) . #7#) #9# G191
                 (EXIT (NREVERSE0 #2#))))))))) 

(DEFUN |VSBASIS;intBasis;L$;17| (LLB $)
  (PROG (|res| #1=#:G1876 LB)
    (RETURN
     (SEQ
      (COND
       ((EQL (LENGTH LLB) 0) (|error| "intersect no subspace is impossible"))
       ((EQL (LENGTH LLB) 1)
        (SPADCALL (SPADCALL LLB 1 (QREFELT $ 44)) (QREFELT $ 24)))
       ('T
        (SEQ
         (LETT |res| (SPADCALL LLB 1 (QREFELT $ 44))
               . #2=(|VSBASIS;intBasis;L$;17|))
         (SEQ (LETT LB NIL . #2#) (LETT #1# (CDR LLB) . #2#) G190
              (COND
               ((OR (ATOM #1#) (PROGN (LETT LB (CAR #1#) . #2#) NIL))
                (GO G191)))
              (SEQ
               (EXIT
                (LETT |res|
                      (SPADCALL |res| (SPADCALL LB (QREFELT $ 24))
                                (QREFELT $ 42))
                      . #2#)))
              (LETT #1# (CDR #1#) . #2#) (GO G190) G191 (EXIT NIL))
         (EXIT |res|)))))))) 

(DEFUN |VSBASIS;intBasis;L$;18| (LLB $)
  (PROG (|res| #1=#:G1884 LB)
    (RETURN
     (SEQ
      (COND
       ((EQL (SPADCALL LLB (QREFELT $ 47)) 0)
        (|error| "intersect no subspace is impossible"))
       ((EQL (SPADCALL LLB (QREFELT $ 47)) 1) (SPADCALL LLB 1 (QREFELT $ 48)))
       ('T
        (SEQ
         (LETT |res| (SPADCALL LLB 1 (QREFELT $ 48))
               . #2=(|VSBASIS;intBasis;L$;18|))
         (SEQ (LETT LB NIL . #2#)
              (LETT #1# (SPADCALL LLB (QREFELT $ 49)) . #2#) G190
              (COND
               ((OR (ATOM #1#) (PROGN (LETT LB (CAR #1#) . #2#) NIL))
                (GO G191)))
              (SEQ
               (EXIT (LETT |res| (SPADCALL |res| LB (QREFELT $ 42)) . #2#)))
              (LETT #1# (CDR #1#) . #2#) (GO G190) G191 (EXIT NIL))
         (EXIT |res|)))))))) 

(DEFUN |VSBASIS;*;3$;19| (B1 B2 $) (SPADCALL B1 B2 (QREFELT $ 42))) 

(PUT '|VSBASIS;rank;$Nni;20| '|SPADreplace| 'LENGTH) 

(DEFUN |VSBASIS;rank;$Nni;20| (B $) (LENGTH B)) 

(DEFUN |VSBASIS;rank;LNni;21| (|Lv| $)
  (SPADCALL (SPADCALL |Lv| (QREFELT $ 24)) (QREFELT $ 52))) 

(DEFUN |VSBASIS;isBasis?;LB;22| (|Lv| $)
  (EQL (SPADCALL |Lv| (QREFELT $ 52)) (LENGTH |Lv|))) 

(DEFUN |VSBASIS;subspace?;2$B;23| (B1 B2 $)
  (EQL (SPADCALL B2 (QREFELT $ 52))
       (SPADCALL (SPADCALL B1 B2 (QREFELT $ 30)) (QREFELT $ 52)))) 

(DEFUN |VSBASIS;=;2$B;24| (B1 B2 $)
  (PROG (|rk|)
    (RETURN
     (SEQ
      (LETT |rk| (SPADCALL (SPADCALL B1 B2 (QREFELT $ 30)) (QREFELT $ 52))
            |VSBASIS;=;2$B;24|)
      (EXIT
       (COND
        ((EQL |rk| (SPADCALL B1 (QREFELT $ 52)))
         (EQL |rk| (SPADCALL B2 (QREFELT $ 52))))
        ('T 'NIL))))))) 

(DEFUN |VSBASIS;canonicalBasis;Nni$;25| (|n| $)
  (PROG (L |v| |k|)
    (RETURN
     (SEQ (LETT L NIL . #1=(|VSBASIS;canonicalBasis;Nni$;25|))
          (SEQ (LETT |k| 1 . #1#) G190 (COND ((QSGREATERP |k| |n|) (GO G191)))
               (SEQ (LETT |v| (MAKEARR1 |n| (|spadConstant| $ 18)) . #1#)
                    (SPADCALL |v| (- (+ |n| 1) |k|) (|spadConstant| $ 14)
                              (QREFELT $ 41))
                    (EXIT (LETT L (CONS |v| L) . #1#)))
               (LETT |k| (QSADD1 |k|) . #1#) (GO G190) G191 (EXIT NIL))
          (EXIT L))))) 

(DEFUN |VSBASIS;complementSpace;L$;26| (|Lv| $)
  (PROG (|ind| RES #1=#:G1904 |k| #2=#:G1905 |v| #3=#:G1903 |n| M |Lw| |bc|
         |dim|)
    (RETURN
     (SEQ
      (COND
       ((SPADCALL |Lv| NIL (QREFELT $ 57))
        (|error|
         "Can't get vector length of an empty family for complementSpace"))
       ('T
        (SEQ
         (LETT |dim| (QVSIZE (SPADCALL |Lv| 1 (QREFELT $ 17)))
               . #4=(|VSBASIS;complementSpace;L$;26|))
         (LETT |bc| (SPADCALL (SPADCALL |dim| (QREFELT $ 58)) (QREFELT $ 9))
               . #4#)
         (LETT |Lw| (SPADCALL |Lv| |bc| (QREFELT $ 28)) . #4#)
         (LETT M (SPADCALL (|VSBASIS;column2matrix| |Lw| $) (QREFELT $ 59))
               . #4#)
         (LETT |n| (LENGTH |Lv|) . #4#) (LETT |ind| 1 . #4#)
         (SEQ (LETT |v| NIL . #4#) (LETT #3# |Lw| . #4#) (LETT |k| 1 . #4#)
              G190
              (COND
               ((OR (QSGREATERP |k| |n|) (ATOM #3#)
                    (PROGN (LETT |v| (CAR #3#) . #4#) NIL))
                #5=(GO G191)))
              (SEQ
               (EXIT
                (COND
                 ((NULL (< |dim| |ind|))
                  (COND
                   ((NULL
                     (SPADCALL (SPADCALL M |ind| |k| (QREFELT $ 60))
                               (|spadConstant| $ 18) (QREFELT $ 61)))
                    (LETT |ind| (+ |ind| 1) . #4#)))))))
              (LETT |k| (PROG1 (QSADD1 |k|) (LETT #3# (CDR #3#) . #4#)) . #4#)
              #6=(GO G190) G191 (EXIT NIL))
         (LETT RES NIL . #4#)
         (SEQ (LETT |v| NIL . #4#) (LETT #2# |bc| . #4#)
              (LETT |k| (+ |n| 1) . #4#) (LETT #1# (+ |n| |dim|) . #4#) G190
              (COND
               ((OR (> |k| #1#) (ATOM #2#)
                    (PROGN (LETT |v| (CAR #2#) . #4#) NIL))
                #5#))
              (SEQ
               (EXIT
                (COND
                 ((NULL (< |dim| |ind|))
                  (COND
                   ((NULL
                     (SPADCALL (SPADCALL M |ind| |k| (QREFELT $ 60))
                               (|spadConstant| $ 18) (QREFELT $ 61)))
                    (SEQ (LETT RES (CONS |v| RES) . #4#)
                         (EXIT (LETT |ind| (+ |ind| 1) . #4#)))))))))
              (LETT |k| (PROG1 (+ |k| 1) (LETT #2# (CDR #2#) . #4#)) . #4#) #6#
              G191 (EXIT NIL))
         (EXIT (NREVERSE RES))))))))) 

(DEFUN |VSBASIS;complementSpace;LNni$;27| (|Lv| |n| $)
  (COND ((SPADCALL |Lv| NIL (QREFELT $ 57)) (SPADCALL |n| (QREFELT $ 58)))
        ((NULL (EQL |n| (QVSIZE (SPADCALL |Lv| 1 (QREFELT $ 17)))))
         (|error| "Inconsistant vector length in complementSpace"))
        ('T (SPADCALL |Lv| (QREFELT $ 63))))) 

(DEFUN |VSBASIS;complementSpace;2$;28| (B $)
  (PROG (|ind| RES #1=#:G1914 |k| #2=#:G1915 |v| |n| M |Lw| |bc| |dim|)
    (RETURN
     (SEQ
      (COND
       ((SPADCALL B (|spadConstant| $ 8) (QREFELT $ 57))
        (|error|
         "Can't get vector length of an empty basis for complement Space"))
       ('T
        (SEQ
         (LETT |dim| (QVSIZE (SPADCALL B 1 (QREFELT $ 17)))
               . #3=(|VSBASIS;complementSpace;2$;28|))
         (LETT |bc| (SPADCALL (SPADCALL |dim| (QREFELT $ 58)) (QREFELT $ 9))
               . #3#)
         (LETT |Lw| (SPADCALL (SPADCALL B (QREFELT $ 9)) |bc| (QREFELT $ 28))
               . #3#)
         (LETT M (SPADCALL (|VSBASIS;column2matrix| |Lw| $) (QREFELT $ 59))
               . #3#)
         (LETT |n| (LENGTH B) . #3#) (LETT |ind| (+ |n| 1) . #3#)
         (LETT RES NIL . #3#)
         (SEQ (LETT |v| NIL . #3#) (LETT #2# |bc| . #3#)
              (LETT |k| (+ |n| 1) . #3#) (LETT #1# (+ |n| |dim|) . #3#) G190
              (COND
               ((OR (> |k| #1#) (ATOM #2#)
                    (PROGN (LETT |v| (CAR #2#) . #3#) NIL))
                (GO G191)))
              (SEQ
               (EXIT
                (COND
                 ((NULL (< |dim| |ind|))
                  (COND
                   ((NULL
                     (SPADCALL (SPADCALL M |ind| |k| (QREFELT $ 60))
                               (|spadConstant| $ 18) (QREFELT $ 61)))
                    (SEQ (LETT RES (CONS |v| RES) . #3#)
                         (EXIT (LETT |ind| (+ |ind| 1) . #3#)))))))))
              (LETT |k| (PROG1 (+ |k| 1) (LETT #2# (CDR #2#) . #3#)) . #3#)
              (GO G190) G191 (EXIT NIL))
         (EXIT (NREVERSE RES))))))))) 

(DEFUN |VSBASIS;complementSpace;$Nni$;29| (B |n| $)
  (COND ((SPADCALL B NIL (QREFELT $ 57)) (SPADCALL |n| (QREFELT $ 58)))
        ((NULL (EQL |n| (QVSIZE (SPADCALL B 1 (QREFELT $ 17)))))
         (|error| "Inconsistant vector length in complementSpace"))
        ('T (SPADCALL B (QREFELT $ 63))))) 

(DEFUN |VSBASIS;member?;V$B;30| (|v| B $)
  (SPADCALL (|VSBASIS;column2matrix| B $) |v| (QREFELT $ 67))) 

(DEFUN |VSBASIS;coordinatesIfCan;V$U;31| (|v| B $)
  (SPADCALL (|VSBASIS;column2matrix| B $) |v| (QREFELT $ 70))) 

(DEFUN |VSBASIS;coordinates;V$V;32| (V B $)
  (PROG (|res|)
    (RETURN
     (SEQ
      (LETT |res| (SPADCALL (|VSBASIS;column2matrix| B $) V (QREFELT $ 70))
            |VSBASIS;coordinates;V$V;32|)
      (EXIT
       (COND ((QEQCAR |res| 1) (|error| "Vector not in the subspace"))
             ('T (QCDR |res|)))))))) 

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

(DEFUN |VectorSpaceBasis;| (|#1|)
  (PROG (|pv$| $ |dv$| DV$1)
    (RETURN
     (PROGN
      (LETT DV$1 (|devaluate| |#1|) . #1=(|VectorSpaceBasis|))
      (LETT |dv$| (LIST '|VectorSpaceBasis| DV$1) . #1#)
      (LETT $ (GETREFV 73) . #1#)
      (QSETREFV $ 0 |dv$|)
      (QSETREFV $ 3 (LETT |pv$| (|buildPredVector| 0 0 NIL) . #1#))
      (|haddProp| |$ConstructorCache| '|VectorSpaceBasis| (LIST DV$1)
                  (CONS 1 $))
      (|stuffDomainSlots| $)
      (QSETREFV $ 6 |#1|)
      (SETF |pv$| (QREFELT $ 3))
      (QSETREFV $ 7 (|List| (|Vector| |#1|)))
      $)))) 

(MAKEPROP '|VectorSpaceBasis| '|infovec|
          (LIST
           '#(NIL NIL NIL NIL NIL (|List| 15) (|local| |#1|) '|Rep|
              (CONS IDENTITY
                    (FUNCALL (|dispatchFunction| |VSBASIS;Zero;$;1|) $))
              |VSBASIS;coerce;$L;2| (|OutputForm|) (0 . |coerce|)
              (5 . |hconcat|) |VSBASIS;coerce;$Of;3| (11 . |One|) (|Vector| 6)
              (|Integer|) (15 . |elt|) (21 . |Zero|) (|NonNegativeInteger|)
              (|Matrix| 6) (25 . |new|) (32 . |setColumn!|)
              (39 . |columnSpace|) |VSBASIS;basis;L$;5|
              |VSBASIS;columnSpace;M$;6| (44 . |nullSpace|)
              |VSBASIS;nullSpace;M$;7| (49 . |concat|) |VSBASIS;sumBasis;2L$;8|
              |VSBASIS;sumBasis;3$;9| (|List| $) (55 . |concat|) (|List| 5)
              |VSBASIS;sumBasis;L$;10| (60 . |concat|) |VSBASIS;sumBasis;L$;11|
              |VSBASIS;+;3$;12| (65 . |elt|) (71 . *) (77 . +) (83 . |setelt|)
              |VSBASIS;intBasis;3$;16| |VSBASIS;intBasis;2L$;15| (90 . |elt|)
              |VSBASIS;intBasis;L$;17| (|List| $$) (96 . |#|) (101 . |elt|)
              (107 . |rest|) |VSBASIS;intBasis;L$;18| |VSBASIS;*;3$;19|
              |VSBASIS;rank;$Nni;20| |VSBASIS;rank;LNni;21| (|Boolean|)
              |VSBASIS;isBasis?;LB;22| |VSBASIS;subspace?;2$B;23|
              |VSBASIS;=;2$B;24| |VSBASIS;canonicalBasis;Nni$;25|
              (112 . |rowEchelon|) (117 . |elt|) (124 . =)
              |VSBASIS;complementSpace;L$;26| |VSBASIS;complementSpace;2$;28|
              |VSBASIS;complementSpace;LNni$;27|
              |VSBASIS;complementSpace;$Nni$;29|
              (|LinearSystemMatrixPackage1| 6) (130 . |hasSolution?|)
              |VSBASIS;member?;V$B;30| (|Union| 15 '"failed")
              (136 . |particularSolution|) |VSBASIS;coordinatesIfCan;V$U;31|
              |VSBASIS;coordinates;V$V;32|)
           '#(|sumBasis| 142 |subspace?| 164 |rank| 170 |nullSpace| 180
              |member?| 185 |isBasis?| 191 |intBasis| 196 |coordinatesIfCan|
              218 |coordinates| 224 |complementSpace| 230 |columnSpace| 252
              |coerce| 257 |canonicalBasis| 267 |basis| 272 |Zero| 277 = 281 +
              287 * 293)
           'NIL
           (CONS (|makeByteWordVec2| 1 'NIL)
                 (CONS '#()
                       (CONS '#()
                             (|makeByteWordVec2| 72
                                                 '(1 5 10 0 11 2 10 0 0 0 12 0
                                                   6 0 14 2 7 15 0 16 17 0 6 0
                                                   18 3 20 0 19 19 6 21 3 20 0
                                                   0 16 15 22 1 20 5 0 23 1 20
                                                   5 0 26 2 5 0 0 0 28 1 5 0 31
                                                   32 1 7 0 31 35 2 15 6 0 16
                                                   38 2 6 0 0 0 39 2 6 0 0 0 40
                                                   3 15 6 0 16 6 41 2 33 5 0 16
                                                   44 1 46 19 0 47 2 46 2 0 16
                                                   48 1 46 0 0 49 1 20 0 0 59 3
                                                   20 6 0 16 16 60 2 6 54 0 0
                                                   61 2 66 54 20 15 67 2 66 69
                                                   20 15 70 2 0 0 5 5 29 2 0 0
                                                   0 0 30 1 0 0 31 36 1 0 0 33
                                                   34 2 0 54 0 0 56 1 0 19 0 52
                                                   1 0 19 5 53 1 0 0 20 27 2 0
                                                   54 15 0 68 1 0 54 5 55 2 0 0
                                                   5 5 43 2 0 0 0 0 42 1 0 0 33
                                                   45 1 0 0 31 50 2 0 69 15 0
                                                   71 2 0 15 15 0 72 2 0 0 0 19
                                                   65 1 0 0 0 63 2 0 0 5 19 64
                                                   1 0 0 5 62 1 0 0 20 25 1 0
                                                   10 0 13 1 0 5 0 9 1 0 0 19
                                                   58 1 0 0 5 24 0 0 0 8 2 0 54
                                                   0 0 57 2 0 0 0 0 37 2 0 0 0
                                                   0 51)))))
           '|lookupComplete|)) 
