
(/VERSIONCHECK 2) 

(DEFUN |MATLIN;rowAllZeroes?| (|x| |i| $)
  (PROG (|j| #0=#:G1840 #1=#:G1839 #2=#:G1837)
    (RETURN
      (SEQ (EXIT (SEQ (SEQ (EXIT (SEQ (LETT |j|
                                       (SPADCALL |x| (QREFELT $ 11))
                                       . #3=(|MATLIN;rowAllZeroes?|))
                                      (LETT #0#
                                       (SPADCALL |x| (QREFELT $ 12)) . #3#)
                                      G190
                                      (COND ((> |j| #0#) (GO G191)))
                                      (SEQ
                                       (EXIT
                                        (COND
                                          ((NULL
                                            (SPADCALL
                                             (SPADCALL |x| |i| |j|
                                              (QREFELT $ 13))
                                             (|spadConstant| $ 14)
                                             (QREFELT $ 16)))
                                           (PROGN
                                             (LETT #2#
                                              (PROGN
                                                (LETT #1# 'NIL . #3#)
                                                (GO #1#)) . #3#)
                                             (GO #2#))))))
                                      (LETT |j| (+ |j| 1) . #3#)
                                      (GO G190) G191 (EXIT NIL)))
                           #2# (EXIT #2#))
                      (EXIT 'T)))
           #1# (EXIT #1#))))) 

(DEFUN |MATLIN;colAllZeroes?| (|x| |j| $)
  (PROG (|i| #0=#:G1845 #1=#:G1844 #2=#:G1842)
    (RETURN
      (SEQ (EXIT (SEQ (SEQ (EXIT (SEQ (LETT |i|
                                       (SPADCALL |x| (QREFELT $ 17))
                                       . #3=(|MATLIN;colAllZeroes?|))
                                      (LETT #0#
                                       (SPADCALL |x| (QREFELT $ 18)) . #3#)
                                      G190
                                      (COND ((> |i| #0#) (GO G191)))
                                      (SEQ
                                       (EXIT
                                        (COND
                                          ((NULL
                                            (SPADCALL
                                             (SPADCALL |x| |i| |j|
                                              (QREFELT $ 13))
                                             (|spadConstant| $ 14)
                                             (QREFELT $ 16)))
                                           (PROGN
                                             (LETT #2#
                                              (PROGN
                                                (LETT #1# 'NIL . #3#)
                                                (GO #1#)) . #3#)
                                             (GO #2#))))))
                                      (LETT |i| (+ |i| 1) . #3#)
                                      (GO G190) G191 (EXIT NIL)))
                           #2# (EXIT #2#))
                      (EXIT 'T)))
           #1# (EXIT #1#))))) 

(DEFUN |MATLIN;minorDet| (|x| |m| |l| |i| |v| $)
  (PROG (|z| |minR| |minC| #0=#:G1874 |md| |ans| #1=#:G1886 |pos| |rl|
             |j|)
    (RETURN
      (SEQ (EXIT (SEQ (LETT |z| (ELT |v| |m|) . #2=(|MATLIN;minorDet|))
                      (EXIT (COND
                              ((QEQCAR |z| 0) (QCDR |z|))
                              ('T
                               (SEQ (LETT |ans|
                                     (|spadConstant| $ 14) . #2#)
                                    (LETT |rl| NIL . #2#)
                                    (LETT |j| (|SPADfirst| |l|) . #2#)
                                    (LETT |l| (CDR |l|) . #2#)
                                    (LETT |pos| 'T . #2#)
                                    (LETT |minR|
                                     (SPADCALL |x| (QREFELT $ 17)) . #2#)
                                    (LETT |minC|
                                     (SPADCALL |x| (QREFELT $ 11)) . #2#)
                                    (EXIT
                                     (SEQ G190 NIL
                                      (SEQ
                                       (COND
                                         ((NULL
                                           (SPADCALL
                                            (SPADCALL |x|
                                             (+ |j| |minR|)
                                             (+ |i| |minC|)
                                             (QREFELT $ 13))
                                            (|spadConstant| $ 14)
                                            (QREFELT $ 16)))
                                          (LETT |ans|
                                           (SEQ
                                            (LETT |md|
                                             (SPADCALL
                                              (|MATLIN;minorDet| |x|
                                               (- |m|
                                                (EXPT 2
                                                 (PROG1
                                                  (LETT #0# |j| . #2#)
                                                   (|check-subtype|
                                                    (>= #0# 0)
                                                    '(|NonNegativeInteger|)
                                                    #0#))))
                                               (SPADCALL (REVERSE |rl|)
                                                |l| (QREFELT $ 20))
                                               (+ |i| 1) |v| $)
                                              (SPADCALL |x|
                                               (+ |j| |minR|)
                                               (+ |i| |minC|)
                                               (QREFELT $ 13))
                                              (QREFELT $ 22)) . #2#)
                                            (EXIT
                                             (COND
                                               (|pos|
                                                (SPADCALL |ans| |md|
                                                 (QREFELT $ 23)))
                                               ('T
                                                (SPADCALL |ans| |md|
                                                 (QREFELT $ 24)))))) . #2#)))
                                       (EXIT
                                        (COND
                                          ((NULL |l|)
                                           (SEQ
                                            (SETELT |v| |m|
                                             (CONS 0 |ans|))
                                            (EXIT
                                             (PROGN
                                               (LETT #1# |ans| . #2#)
                                               (GO #1#)))))
                                          ('T
                                           (SEQ
                                            (LETT |pos|
                                             (COND
                                               (|pos| 'NIL)
                                               ('T 'T)) . #2#)
                                            (LETT |rl|
                                             (CONS |j| |rl|) . #2#)
                                            (LETT |j|
                                             (|SPADfirst| |l|) . #2#)
                                            (EXIT
                                             (LETT |l| (CDR |l|) . #2#)))))))
                                      NIL (GO G190) G191 (EXIT NIL)))))))))
           #1# (EXIT #1#))))) 

(DEFUN |MATLIN;minordet;MR;4| (|x| $)
  (PROG (|ndim| |n1| #0=#:G1891 |v| |minR| |maxC| #1=#:G1905 |i|)
    (RETURN
      (SEQ (COND
             ((NULL (EQL (LETT |ndim| (SPADCALL |x| (QREFELT $ 26))
                               . #2=(|MATLIN;minordet;MR;4|))
                         (SPADCALL |x| (QREFELT $ 27))))
              (|error| "determinant: matrix must be square"))
             ('T
              (SEQ (LETT |n1| (- |ndim| 1) . #2#)
                   (LETT |v|
                         (SPADCALL
                             (PROG1 (LETT #0#
                                     (- (EXPT 2 |ndim|) 1) . #2#)
                               (|check-subtype| (>= #0# 0)
                                   '(|NonNegativeInteger|) #0#))
                             (CONS 1 "uncomputed") (QREFELT $ 30)) . #2#)
                   (LETT |minR| (SPADCALL |x| (QREFELT $ 17)) . #2#)
                   (LETT |maxC| (SPADCALL |x| (QREFELT $ 12)) . #2#)
                   (SEQ (LETT |i| 0 . #2#) G190
                        (COND ((QSGREATERP |i| |n1|) #3=(GO G191)))
                        (SEQ (EXIT (SETELT |v|
                                    (QSDIFFERENCE
                                     (SPADCALL 2 |i| (QREFELT $ 32)) 1)
                                    (CONS 0
                                     (SPADCALL |x| (+ |i| |minR|)
                                      |maxC| (QREFELT $ 13))))))
                        (LETT |i| (QSADD1 |i|) . #2#) #4=(GO G190) G191
                        (EXIT NIL))
                   (EXIT (|MATLIN;minorDet| |x|
                             (QSDIFFERENCE
                                 (SPADCALL 2 |ndim| (QREFELT $ 32)) 2)
                             (PROGN
                               (LETT #1# NIL . #2#)
                               (SEQ (LETT |i| 0 . #2#) G190
                                    (COND ((QSGREATERP |i| |n1|) #3#))
                                    (SEQ
                                     (EXIT
                                      (LETT #1# (CONS |i| #1#) . #2#)))
                                    (LETT |i| (QSADD1 |i|) . #2#) #4#
                                    G191 (EXIT (NREVERSE0 #1#))))
                             0 |v| $))))))))) 

(DEFUN |MATLIN;elRow1!;M2IM;5| (|m| |i| |j| $)
  (PROG (|vec|)
    (RETURN
      (SEQ (LETT |vec| (SPADCALL |m| |i| (QREFELT $ 34))
                 |MATLIN;elRow1!;M2IM;5|)
           (SPADCALL |m| |i| (SPADCALL |m| |j| (QREFELT $ 34))
               (QREFELT $ 35))
           (SPADCALL |m| |j| |vec| (QREFELT $ 35)) (EXIT |m|))))) 

(DEFUN |MATLIN;elRow2!;MR2IM;6| (|m| |a| |i| |j| $)
  (PROG (|vec|)
    (RETURN
      (SEQ (LETT |vec|
                 (SPADCALL
                     (CONS #'|MATLIN;elRow2!;MR2IM;6!0| (VECTOR $ |a|))
                     (SPADCALL |m| |j| (QREFELT $ 34)) (QREFELT $ 38))
                 . #0=(|MATLIN;elRow2!;MR2IM;6|))
           (LETT |vec|
                 (SPADCALL (ELT $ 23) (SPADCALL |m| |i| (QREFELT $ 34))
                     |vec| (QREFELT $ 40)) . #0#)
           (SPADCALL |m| |i| |vec| (QREFELT $ 35)) (EXIT |m|))))) 

(DEFUN |MATLIN;elRow2!;MR2IM;6!0| (|#1| $$)
  (SPADCALL (QREFELT $$ 1) |#1| (QREFELT (QREFELT $$ 0) 22))) 

(DEFUN |MATLIN;elColumn2!;MR2IM;7| (|m| |a| |i| |j| $)
  (PROG (|vec|)
    (RETURN
      (SEQ (LETT |vec|
                 (SPADCALL
                     (CONS #'|MATLIN;elColumn2!;MR2IM;7!0|
                           (VECTOR $ |a|))
                     (SPADCALL |m| |j| (QREFELT $ 42)) (QREFELT $ 43))
                 . #0=(|MATLIN;elColumn2!;MR2IM;7|))
           (LETT |vec|
                 (SPADCALL (ELT $ 23) (SPADCALL |m| |i| (QREFELT $ 42))
                     |vec| (QREFELT $ 44)) . #0#)
           (SPADCALL |m| |i| |vec| (QREFELT $ 45)) (EXIT |m|))))) 

(DEFUN |MATLIN;elColumn2!;MR2IM;7!0| (|#1| $$)
  (SPADCALL (QREFELT $$ 1) |#1| (QREFELT (QREFELT $$ 0) 22))) 

(DEFUN |MATLIN;fractionFreeGauss!;2M;8| (|x| $)
  (PROG (|ndim| |minR| |maxR| |minC| |maxC| |rown| #0=#:G1916 |ans| |c|
                |k| |pv| |l| |val| #1=#:G1924 |b| |i| #2=#:G1934
                #3=#:G1932 |lasti| |j|)
    (RETURN
      (SEQ (LETT |ndim| (SPADCALL |x| (QREFELT $ 26))
                 . #4=(|MATLIN;fractionFreeGauss!;2M;8|))
           (EXIT (COND
                   ((EQL |ndim| 1) |x|)
                   ('T
                    (SEQ (LETT |ans|
                               (LETT |b| (|spadConstant| $ 21) . #4#) . #4#)
                         (LETT |minR|
                               (SPADCALL |x| (QREFELT $ 17)) . #4#)
                         (LETT |maxR|
                               (SPADCALL |x| (QREFELT $ 18)) . #4#)
                         (LETT |minC|
                               (SPADCALL |x| (QREFELT $ 11)) . #4#)
                         (LETT |maxC|
                               (SPADCALL |x| (QREFELT $ 12)) . #4#)
                         (LETT |i| |minR| . #4#)
                         (SEQ (EXIT (SEQ (LETT |j| |minC| . #4#) G190
                                     (COND
                                       ((> |j| |maxC|) #5=(GO G191)))
                                     (SEQ
                                      (COND
                                        ((SPADCALL
                                          (SPADCALL |x| |i| |j|
                                           (QREFELT $ 13))
                                          (|spadConstant| $ 14)
                                          (QREFELT $ 16))
                                         (SEQ
                                          (LETT |rown|
                                           (- |minR| 1) . #4#)
                                          (SEQ
                                           (EXIT
                                            (SEQ
                                             (LETT |k| (+ |i| 1) . #4#)
                                             G190
                                             (COND
                                               ((> |k| |maxR|) #5#))
                                             (SEQ
                                              (EXIT
                                               (COND
                                                 ((NULL
                                                   (SPADCALL
                                                    (SPADCALL |x| |k|
                                                     |j|
                                                     (QREFELT $ 13))
                                                    (|spadConstant| $
                                                     14)
                                                    (QREFELT $ 16)))
                                                  (SEQ
                                                   (LETT |rown|
                                                    |k| . #4#)
                                                   (EXIT
                                                    (PROGN
                                                      (LETT #0#
                                                       |$NoValue| . #4#)
                                                      (GO #0#))))))))
                                             (LETT |k| (+ |k| 1) . #4#)
                                             #6=(GO G190) G191
                                             (EXIT NIL)))
                                           #0# (EXIT #0#))
                                          (EXIT
                                           (COND
                                             ((< (- |minR| 1) |rown|)
                                              (SEQ
                                               (SPADCALL |x| |i| |rown|
                                                (QREFELT $ 47))
                                               (EXIT
                                                (LETT |ans|
                                                 (SPADCALL |ans|
                                                  (QREFELT $ 48)) . #4#)))))))))
                                      (LETT |c|
                                       (SPADCALL |x| |i| |j|
                                        (QREFELT $ 13)) . #4#)
                                      (EXIT
                                       (COND
                                         ((SPADCALL |c|
                                           (|spadConstant| $ 14)
                                           (QREFELT $ 16))
                                          "next j")
                                         ('T
                                          (SEQ
                                           (EXIT
                                            (SEQ
                                             (SEQ
                                              (LETT |k|
                                               (+ |i| 1) . #4#)
                                              G190
                                              (COND
                                                ((> |k| |maxR|) #5#))
                                              (SEQ
                                               (EXIT
                                                (COND
                                                  ((SPADCALL
                                                    (SPADCALL |x| |k|
                                                     |j|
                                                     (QREFELT $ 13))
                                                    (|spadConstant| $
                                                     14)
                                                    (QREFELT $ 16))
                                                   (SEQ
                                                    (LETT |l|
                                                     (+ |j| 1) . #4#)
                                                    G190
                                                    (COND
                                                      ((> |l| |maxC|)
                                                       #5#))
                                                    (SEQ
                                                     (EXIT
                                                      (SPADCALL |x| |k|
                                                       |l|
                                                       (PROG2
                                                        (LETT #1#
                                                         (SPADCALL
                                                          (SPADCALL |c|
                                                           (SPADCALL
                                                            |x| |k| |l|
                                                            (QREFELT $
                                                             13))
                                                           (QREFELT $
                                                            22))
                                                          |b|
                                                          (QREFELT $
                                                           50)) . #4#)
                                                        (QCDR #1#)
                                                         (|check-union|
                                                          (QEQCAR #1#
                                                           0)
                                                          (QREFELT $ 6)
                                                          #1#))
                                                       (QREFELT $ 51))))
                                                    (LETT |l|
                                                     (+ |l| 1) . #4#)
                                                    #6# G191
                                                    (EXIT NIL)))
                                                  ('T
                                                   (SEQ
                                                    (LETT |pv|
                                                     (SPADCALL |x| |k|
                                                      |j|
                                                      (QREFELT $ 13)) . #4#)
                                                    (SPADCALL |x| |k|
                                                     |j|
                                                     (|spadConstant| $
                                                      14)
                                                     (QREFELT $ 51))
                                                    (EXIT
                                                     (SEQ
                                                      (LETT |l|
                                                       (+ |j| 1) . #4#)
                                                      G190
                                                      (COND
                                                        ((> |l| |maxC|)
                                                         #5#))
                                                      (SEQ
                                                       (LETT |val|
                                                        (SPADCALL
                                                         (SPADCALL |c|
                                                          (SPADCALL |x|
                                                           |k| |l|
                                                           (QREFELT $
                                                            13))
                                                          (QREFELT $
                                                           22))
                                                         (SPADCALL |pv|
                                                          (SPADCALL |x|
                                                           |i| |l|
                                                           (QREFELT $
                                                            13))
                                                          (QREFELT $
                                                           22))
                                                         (QREFELT $ 24)) . #4#)
                                                       (EXIT
                                                        (SPADCALL |x|
                                                         |k| |l|
                                                         (PROG2
                                                          (LETT #1#
                                                           (SPADCALL
                                                            |val| |b|
                                                            (QREFELT $
                                                             50)) . #4#)
                                                          (QCDR #1#)
                                                           (|check-union|
                                                            (QEQCAR #1#
                                                             0)
                                                            (QREFELT $
                                                             6)
                                                            #1#))
                                                         (QREFELT $ 51))))
                                                      (LETT |l|
                                                       (+ |l| 1) . #4#)
                                                      #6# G191
                                                      (EXIT NIL))))))))
                                              (LETT |k|
                                               (+ |k| 1) . #4#)
                                              #6# G191 (EXIT NIL))
                                             (LETT |b| |c| . #4#)
                                             (LETT |i| (+ |i| 1) . #4#)
                                             (EXIT
                                              (COND
                                                ((< |maxR| |i|)
                                                 (PROGN
                                                   (LETT #3#
                                                    (PROGN
                                                      (LETT #2#
                                                       |$NoValue| . #4#)
                                                      (GO #2#)) . #4#)
                                                   (GO #3#)))))))
                                           #3# (EXIT #3#))))))
                                     (LETT |j| (+ |j| 1) . #4#) #6#
                                     G191 (EXIT NIL)))
                              #2# (EXIT #2#))
                         (COND
                           ((SPADCALL |ans|
                                (SPADCALL (|spadConstant| $ 21)
                                    (QREFELT $ 48))
                                (QREFELT $ 16))
                            (SEQ (LETT |lasti| (- |i| 1) . #4#)
                                 (EXIT (SEQ (LETT |j| 1 . #4#) G190
                                        (COND
                                          ((QSGREATERP |j| |maxC|) #5#))
                                        (SEQ
                                         (EXIT
                                          (SPADCALL |x| |lasti| |j|
                                           (SPADCALL
                                            (SPADCALL |x| |lasti| |j|
                                             (QREFELT $ 52))
                                            (QREFELT $ 48))
                                           (QREFELT $ 53))))
                                        (LETT |j| (QSADD1 |j|) . #4#)
                                        #6# G191 (EXIT NIL))))))
                         (EXIT |x|))))))))) 

(DEFUN |MATLIN;lastStep| (|x| $)
  (PROG (|ndim| |minR| |maxR| |minC| |maxC| |exCol| |det| |maxR1|
                |maxC1| |minC1| |iRow| |i| |j| |k| #0=#:G1953
                #1=#:G1943 #2=#:G1941 #3=#:G1942 |ss| #4=#:G1945
                |iCol|)
    (RETURN
      (SEQ (LETT |ndim| (SPADCALL |x| (QREFELT $ 26))
                 . #5=(|MATLIN;lastStep|))
           (LETT |minR| (SPADCALL |x| (QREFELT $ 17)) . #5#)
           (LETT |maxR| (SPADCALL |x| (QREFELT $ 18)) . #5#)
           (LETT |minC| (SPADCALL |x| (QREFELT $ 11)) . #5#)
           (LETT |maxC| (- (+ |minC| |ndim|) 1) . #5#)
           (LETT |exCol| (SPADCALL |x| (QREFELT $ 12)) . #5#)
           (LETT |det|
                 (SPADCALL |x| |maxR| |maxC| (QREFELT $ 52)) . #5#)
           (LETT |maxR1| (- |maxR| 1) . #5#)
           (LETT |maxC1| (+ |maxC| 1) . #5#)
           (LETT |minC1| (+ |minC| 1) . #5#) (LETT |iRow| |maxR| . #5#)
           (LETT |iCol| (- |maxC| 1) . #5#)
           (SEQ (LETT |i| |maxR1| . #5#) G190
                (COND ((< |i| 1) #6=(GO G191)))
                (SEQ (SEQ (LETT |j| |maxC1| . #5#) G190
                          (COND ((> |j| |exCol|) #6#))
                          (SEQ (LETT |ss|
                                     (PROGN
                                       (LETT #3# NIL . #5#)
                                       (SEQ (LETT |k| 1 . #5#)
                                        (LETT #0# (- |maxR| |i|) . #5#)
                                        G190
                                        (COND
                                          ((QSGREATERP |k| #0#) #6#))
                                        (SEQ
                                         (EXIT
                                          (PROGN
                                            (LETT #1#
                                             (SPADCALL
                                              (SPADCALL |x| |i|
                                               (+ |iCol| |k|)
                                               (QREFELT $ 52))
                                              (SPADCALL |x| (+ |i| |k|)
                                               |j| (QREFELT $ 52))
                                              (QREFELT $ 22)) . #5#)
                                            (COND
                                              (#3#
                                               (LETT #2#
                                                (SPADCALL #2# #1#
                                                 (QREFELT $ 23)) . #5#))
                                              ('T
                                               (PROGN
                                                 (LETT #2# #1# . #5#)
                                                 (LETT #3# 'T . #5#)))))))
                                        (LETT |k| (QSADD1 |k|) . #5#)
                                        #7=(GO G190) G191 (EXIT NIL))
                                       (COND
                                         (#3# #2#)
                                         ('T (|spadConstant| $ 14)))) . #5#)
                               (EXIT (SPADCALL |x| |i| |j|
                                      (PROG2
                                       (LETT #4#
                                        (SPADCALL
                                         (SPADCALL
                                          (SPADCALL |det|
                                           (SPADCALL |x| |i| |j|
                                            (QREFELT $ 52))
                                           (QREFELT $ 22))
                                          |ss| (QREFELT $ 24))
                                         (SPADCALL |x| |i| |iCol|
                                          (QREFELT $ 52))
                                         (QREFELT $ 50)) . #5#)
                                       (QCDR #4#)
                                        (|check-union| (QEQCAR #4# 0)
                                         (QREFELT $ 6) #4#))
                                      (QREFELT $ 53))))
                          (LETT |j| (+ |j| 1) . #5#) #7# G191
                          (EXIT NIL))
                     (EXIT (LETT |iCol| (- |iCol| 1) . #5#)))
                (LETT |i| (+ |i| -1) . #5#) #7# G191 (EXIT NIL))
           (EXIT (SPADCALL |x| |minR| |maxR| |maxC1| |exCol|
                     (QREFELT $ 55))))))) 

(DEFUN |MATLIN;invertIfCan;MU;10| (|y| $)
  (PROG (|nr| |adjRec| |den|)
    (RETURN
      (SEQ (COND
             ((NULL (EQL (LETT |nr| (SPADCALL |y| (QREFELT $ 26))
                               . #0=(|MATLIN;invertIfCan;MU;10|))
                         (SPADCALL |y| (QREFELT $ 27))))
              (|error| "invertIfCan: matrix must be square"))
             ('T
              (SEQ (LETT |adjRec| (SPADCALL |y| (QREFELT $ 57)) . #0#)
                   (LETT |den|
                         (SPADCALL (QCDR |adjRec|) (QREFELT $ 58)) . #0#)
                   (EXIT (COND
                           ((QEQCAR |den| 1) (CONS 1 "failed"))
                           ('T
                            (CONS 0
                                  (SPADCALL (QCDR |den|)
                                      (QCAR |adjRec|) (QREFELT $ 59))))))))))))) 

(DEFUN |MATLIN;adjoint;MR;11| (|y| $)
  (PROG (|nr| |maxR| |maxC| |x| |ffr| |det|)
    (RETURN
      (SEQ (COND
             ((NULL (EQL (LETT |nr| (SPADCALL |y| (QREFELT $ 26))
                               . #0=(|MATLIN;adjoint;MR;11|))
                         (SPADCALL |y| (QREFELT $ 27))))
              (|error| "adjoint: matrix must be square"))
             ('T
              (SEQ (LETT |maxR| (SPADCALL |y| (QREFELT $ 18)) . #0#)
                   (LETT |maxC| (SPADCALL |y| (QREFELT $ 12)) . #0#)
                   (LETT |x|
                         (SPADCALL (SPADCALL |y| (QREFELT $ 62))
                                   (SPADCALL |nr| (|spadConstant| $ 21)
                                    (QREFELT $ 63))
                                   (QREFELT $ 64)) . #0#)
                   (LETT |ffr| (SPADCALL |x| (QREFELT $ 54)) . #0#)
                   (LETT |det|
                         (SPADCALL |ffr| |maxR| |maxC| (QREFELT $ 52)) . #0#)
                   (EXIT (CONS (|MATLIN;lastStep| |ffr| $) |det|))))))))) 

(DEFUN |MATLIN;rowEchelon;2M;12| (|y| $)
  (SPADCALL |y| (QREFELT $ 66))) 

(DEFUN |MATLIN;rank;MNni;13| (|y| $) (SPADCALL |y| (QREFELT $ 68))) 

(DEFUN |MATLIN;nullity;MNni;14| (|y| $) (SPADCALL |y| (QREFELT $ 70))) 

(DEFUN |MATLIN;determinant;MR;15| (|y| $)
  (SPADCALL |y| (QREFELT $ 72))) 

(DEFUN |MATLIN;inverse;MU;16| (|y| $) (SPADCALL |y| (QREFELT $ 74))) 

(DEFUN |MATLIN;nullSpace;ML;17| (|y| $) (SPADCALL |y| (QREFELT $ 77))) 

(DEFUN |MATLIN;nullSpace;ML;18| (|y| $)
  (PROG (#0=#:G1983 |v| #1=#:G1984)
    (RETURN
      (SEQ (PROGN
             (LETT #0# NIL . #2=(|MATLIN;nullSpace;ML;18|))
             (SEQ (LETT |v| NIL . #2#)
                  (LETT #1#
                        (SPADCALL
                            (SPADCALL
                                (LIST #'|MATLIN;nullSpace;ML;18!0|) |y|
                                (QREFELT $ 81))
                            (QREFELT $ 84)) . #2#)
                  G190
                  (COND
                    ((OR (ATOM #1#)
                         (PROGN (LETT |v| (CAR #1#) . #2#) NIL))
                     (GO G191)))
                  (SEQ (EXIT (LETT #0#
                                   (CONS
                                    (SPADCALL
                                     (LIST
                                      #'|MATLIN;nullSpace;ML;18!1|)
                                     |v| (QREFELT $ 87))
                                    #0#) . #2#)))
                  (LETT #1# (CDR #1#) . #2#) (GO G190) G191
                  (EXIT (NREVERSE0 #0#)))))))) 

(DEFUN |MATLIN;nullSpace;ML;18!1| (|#1| $$) |#1|) 

(DEFUN |MATLIN;nullSpace;ML;18!0| (|#1| $$) |#1|) 

(DEFUN |MATLIN;nullSpace;ML;19| (|m| $) (SPADCALL |m| (QREFELT $ 89))) 

(DEFUN |MATLIN;determinant;MR;20| (|y| $)
  (PROG (|fm|)
    (RETURN
      (SEQ (COND
             ((NULL (EQL (SPADCALL |y| (QREFELT $ 26))
                         (SPADCALL |y| (QREFELT $ 27))))
              (|error| "determinant: matrix must be square"))
             ('T
              (SEQ (LETT |fm|
                         (SPADCALL (SPADCALL |y| (QREFELT $ 62))
                             (QREFELT $ 54))
                         |MATLIN;determinant;MR;20|)
                   (EXIT (SPADCALL |fm| (SPADCALL |fm| (QREFELT $ 18))
                             (SPADCALL |fm| (QREFELT $ 12))
                             (QREFELT $ 52)))))))))) 

(DEFUN |MATLIN;rank;MNni;21| (|x| $)
  (PROG (|rh| |y| |i| #0=#:G1991 |rk|)
    (RETURN
      (SEQ (LETT |y|
                 (SEQ (LETT |rh| (SPADCALL |x| (QREFELT $ 27))
                            . #1=(|MATLIN;rank;MNni;21|))
                      (LETT |rk| (SPADCALL |x| (QREFELT $ 26)) . #1#)
                      (EXIT (COND
                              ((< |rh| |rk|)
                               (SEQ (LETT |rk| |rh| . #1#)
                                    (EXIT
                                     (SPADCALL |x| (QREFELT $ 90)))))
                              ('T (SPADCALL |x| (QREFELT $ 62)))))) . #1#)
           (LETT |y| (SPADCALL |y| (QREFELT $ 54)) . #1#)
           (LETT |i| (SPADCALL |y| (QREFELT $ 18)) . #1#)
           (SEQ G190
                (COND
                  ((NULL (COND
                           ((< 0 |rk|)
                            (|MATLIN;rowAllZeroes?| |y| |i| $))
                           ('T 'NIL)))
                   (GO G191)))
                (SEQ (LETT |i| (- |i| 1) . #1#)
                     (EXIT (LETT |rk|
                                 (PROG1 (LETT #0# (- |rk| 1) . #1#)
                                   (|check-subtype| (>= #0# 0)
                                    '(|NonNegativeInteger|) #0#)) . #1#)))
                NIL (GO G190) G191 (EXIT NIL))
           (EXIT |rk|))))) 

(DEFUN |MATLIN;nullity;MNni;22| (|x| $)
  (PROG (#0=#:G1996)
    (RETURN
      (PROG1 (LETT #0#
                   (- (SPADCALL |x| (QREFELT $ 27))
                      (SPADCALL |x| (QREFELT $ 69)))
                   |MATLIN;nullity;MNni;22|)
        (|check-subtype| (>= #0# 0) '(|NonNegativeInteger|) #0#))))) 

(DEFUN |MATLIN;normalizedDivide;2RR;23| (|n| |d| $)
  (PROG (|qr|)
    (RETURN
      (SEQ (LETT |qr| (SPADCALL |n| |d| (QREFELT $ 92))
                 |MATLIN;normalizedDivide;2RR;23|)
           (COND
             ((NULL (SPADCALL (QCDR |qr|) (|spadConstant| $ 14)
                        (QREFELT $ 93)))
              (EXIT |qr|)))
           (EXIT (COND
                   ((SPADCALL (|spadConstant| $ 14) |d| (QREFELT $ 93))
                    (SEQ (PROGN
                           (RPLACD |qr|
                                   (SPADCALL (QCDR |qr|) |d|
                                    (QREFELT $ 23)))
                           (QCDR |qr|))
                         (PROGN
                           (RPLACA |qr|
                                   (SPADCALL (QCAR |qr|)
                                    (|spadConstant| $ 21)
                                    (QREFELT $ 24)))
                           (QCAR |qr|))
                         (EXIT |qr|)))
                   ('T
                    (SEQ (PROGN
                           (RPLACD |qr|
                                   (SPADCALL (QCDR |qr|) |d|
                                    (QREFELT $ 24)))
                           (QCDR |qr|))
                         (PROGN
                           (RPLACA |qr|
                                   (SPADCALL (QCAR |qr|)
                                    (|spadConstant| $ 21)
                                    (QREFELT $ 23)))
                           (QCAR |qr|))
                         (EXIT |qr|))))))))) 

(DEFUN |MATLIN;normalizedDivide;2RR;24| (|n| |d| $)
  (SPADCALL |n| |d| (QREFELT $ 92))) 

(DEFUN |MATLIN;rowEchelon;2M;25| (|y| $)
  (PROG (|x| |minR| |maxR| |minC| |maxC| |j| #0=#:G2035 |xkj| |n| |xnj|
             |aa| |#G66| |#G67| |#G68| |a| |b| |d| |b1| #1=#:G2017 |a1|
             |val1| |val2| |un| |jj| |xij| |k| #2=#:G2038 |qr| |k1|
             |i|)
    (RETURN
      (SEQ (LETT |x| (SPADCALL |y| (QREFELT $ 62))
                 . #3=(|MATLIN;rowEchelon;2M;25|))
           (LETT |minR| (SPADCALL |x| (QREFELT $ 17)) . #3#)
           (LETT |maxR| (SPADCALL |x| (QREFELT $ 18)) . #3#)
           (LETT |minC| (SPADCALL |x| (QREFELT $ 11)) . #3#)
           (LETT |maxC| (SPADCALL |x| (QREFELT $ 12)) . #3#)
           (LETT |n| (- |minR| 1) . #3#) (LETT |i| |minR| . #3#)
           (SEQ (EXIT (SEQ (LETT |j| |minC| . #3#) G190
                           (COND ((> |j| |maxC|) #4=(GO G191)))
                           (SEQ (COND
                                  ((< |maxR| |i|)
                                   (PROGN
                                     (LETT #0# |x| . #3#)
                                     (GO #0#))))
                                (LETT |n| (- |minR| 1) . #3#)
                                (SEQ (LETT |k| |i| . #3#) G190
                                     (COND ((> |k| |maxR|) #4#))
                                     (SEQ
                                      (EXIT
                                       (COND
                                         ((NULL
                                           (SPADCALL
                                            (LETT |xkj|
                                             (SPADCALL |x| |k| |j|
                                              (QREFELT $ 13)) . #3#)
                                            (QREFELT $ 96)))
                                          (COND
                                            ((OR (EQL |n| (- |minR| 1))
                                              (SPADCALL |xkj| |xnj|
                                               (QREFELT $ 97)))
                                             (SEQ (LETT |n| |k| . #3#)
                                              (EXIT
                                               (LETT |xnj| |xkj| . #3#)))))))))
                                     (LETT |k| (+ |k| 1) . #3#)
                                     #5=(GO G190) G191 (EXIT NIL))
                                (EXIT (COND
                                        ((EQL |n| (- |minR| 1))
                                         "next j")
                                        ('T
                                         (SEQ
                                          (SPADCALL |x| |i| |n|
                                           (QREFELT $ 47))
                                          (SEQ
                                           (LETT |k| (+ |i| 1) . #3#)
                                           G190
                                           (COND ((> |k| |maxR|) #4#))
                                           (SEQ
                                            (EXIT
                                             (COND
                                               ((SPADCALL
                                                 (SPADCALL |x| |k| |j|
                                                  (QREFELT $ 13))
                                                 (|spadConstant| $ 14)
                                                 (QREFELT $ 16))
                                                "next k")
                                               ('T
                                                (SEQ
                                                 (LETT |aa|
                                                  (SPADCALL
                                                   (SPADCALL |x| |i|
                                                    |j| (QREFELT $ 13))
                                                   (SPADCALL |x| |k|
                                                    |j| (QREFELT $ 13))
                                                   (QREFELT $ 99)) . #3#)
                                                 (PROGN
                                                   (LETT |#G66|
                                                    (QVELT |aa| 0) . #3#)
                                                   (LETT |#G67|
                                                    (QVELT |aa| 1) . #3#)
                                                   (LETT |#G68|
                                                    (QVELT |aa| 2) . #3#)
                                                   (LETT |a|
                                                    |#G66| . #3#)
                                                   (LETT |b|
                                                    |#G67| . #3#)
                                                   (LETT |d|
                                                    |#G68| . #3#))
                                                 (LETT |b1|
                                                  (PROG2
                                                   (LETT #1#
                                                    (SPADCALL
                                                     (SPADCALL |x| |i|
                                                      |j|
                                                      (QREFELT $ 13))
                                                     |d|
                                                     (QREFELT $ 50)) . #3#)
                                                   (QCDR #1#)
                                                    (|check-union|
                                                     (QEQCAR #1# 0)
                                                     (QREFELT $ 6) #1#)) . #3#)
                                                 (LETT |a1|
                                                  (PROG2
                                                   (LETT #1#
                                                    (SPADCALL
                                                     (SPADCALL |x| |k|
                                                      |j|
                                                      (QREFELT $ 13))
                                                     |d|
                                                     (QREFELT $ 50)) . #3#)
                                                   (QCDR #1#)
                                                    (|check-union|
                                                     (QEQCAR #1# 0)
                                                     (QREFELT $ 6) #1#)) . #3#)
                                                 (SEQ
                                                  (LETT |k1|
                                                   (+ |j| 1) . #3#)
                                                  G190
                                                  (COND
                                                    ((> |k1| |maxC|)
                                                     #4#))
                                                  (SEQ
                                                   (LETT |val1|
                                                    (SPADCALL
                                                     (SPADCALL |a|
                                                      (SPADCALL |x| |i|
                                                       |k1|
                                                       (QREFELT $ 13))
                                                      (QREFELT $ 22))
                                                     (SPADCALL |b|
                                                      (SPADCALL |x| |k|
                                                       |k1|
                                                       (QREFELT $ 13))
                                                      (QREFELT $ 22))
                                                     (QREFELT $ 23)) . #3#)
                                                   (LETT |val2|
                                                    (SPADCALL
                                                     (SPADCALL
                                                      (SPADCALL |a1|
                                                       (SPADCALL |x|
                                                        |i| |k1|
                                                        (QREFELT $ 13))
                                                       (QREFELT $ 22))
                                                      (QREFELT $ 48))
                                                     (SPADCALL |b1|
                                                      (SPADCALL |x| |k|
                                                       |k1|
                                                       (QREFELT $ 13))
                                                      (QREFELT $ 22))
                                                     (QREFELT $ 23)) . #3#)
                                                   (SPADCALL |x| |i|
                                                    |k1| |val1|
                                                    (QREFELT $ 51))
                                                   (EXIT
                                                    (SPADCALL |x| |k|
                                                     |k1| |val2|
                                                     (QREFELT $ 51))))
                                                  (LETT |k1|
                                                   (+ |k1| 1) . #3#)
                                                  #5# G191 (EXIT NIL))
                                                 (SPADCALL |x| |i| |j|
                                                  |d| (QREFELT $ 51))
                                                 (EXIT
                                                  (SPADCALL |x| |k| |j|
                                                   (|spadConstant| $
                                                    14)
                                                   (QREFELT $ 51))))))))
                                           (LETT |k| (+ |k| 1) . #3#)
                                           #5# G191 (EXIT NIL))
                                          (LETT |un|
                                           (SPADCALL
                                            (SPADCALL |x| |i| |j|
                                             (QREFELT $ 13))
                                            (QREFELT $ 101)) . #3#)
                                          (SPADCALL |x| |i| |j|
                                           (QVELT |un| 1)
                                           (QREFELT $ 51))
                                          (COND
                                            ((NULL
                                              (SPADCALL (QVELT |un| 2)
                                               (|spadConstant| $ 21)
                                               (QREFELT $ 16)))
                                             (SEQ
                                              (LETT |jj|
                                               (+ |j| 1) . #3#)
                                              G190
                                              (COND
                                                ((> |jj| |maxC|) #4#))
                                              (SEQ
                                               (EXIT
                                                (SPADCALL |x| |i| |jj|
                                                 (SPADCALL
                                                  (QVELT |un| 2)
                                                  (SPADCALL |x| |i|
                                                   |jj| (QREFELT $ 13))
                                                  (QREFELT $ 22))
                                                 (QREFELT $ 51))))
                                              (LETT |jj|
                                               (+ |jj| 1) . #3#)
                                              #5# G191 (EXIT NIL))))
                                          (LETT |xij|
                                           (SPADCALL |x| |i| |j|
                                            (QREFELT $ 13)) . #3#)
                                          (SEQ (LETT |k| |minR| . #3#)
                                           (LETT #2# (- |i| 1) . #3#)
                                           G190
                                           (COND ((> |k| #2#) #4#))
                                           (SEQ
                                            (EXIT
                                             (COND
                                               ((SPADCALL
                                                 (SPADCALL |x| |k| |j|
                                                  (QREFELT $ 13))
                                                 (|spadConstant| $ 14)
                                                 (QREFELT $ 16))
                                                "next k")
                                               ('T
                                                (SEQ
                                                 (LETT |qr|
                                                  (SPADCALL
                                                   (SPADCALL |x| |k|
                                                    |j| (QREFELT $ 13))
                                                   |xij|
                                                   (QREFELT $ 95)) . #3#)
                                                 (SPADCALL |x| |k| |j|
                                                  (QCDR |qr|)
                                                  (QREFELT $ 51))
                                                 (EXIT
                                                  (SEQ
                                                   (LETT |k1|
                                                    (+ |j| 1) . #3#)
                                                   G190
                                                   (COND
                                                     ((> |k1| |maxC|)
                                                      #4#))
                                                   (SEQ
                                                    (EXIT
                                                     (SPADCALL |x| |k|
                                                      |k1|
                                                      (SPADCALL
                                                       (SPADCALL |x|
                                                        |k| |k1|
                                                        (QREFELT $ 13))
                                                       (SPADCALL
                                                        (QCAR |qr|)
                                                        (SPADCALL |x|
                                                         |i| |k1|
                                                         (QREFELT $ 13))
                                                        (QREFELT $ 22))
                                                       (QREFELT $ 24))
                                                      (QREFELT $ 51))))
                                                   (LETT |k1|
                                                    (+ |k1| 1) . #3#)
                                                   #5# G191 (EXIT NIL))))))))
                                           (LETT |k| (+ |k| 1) . #3#)
                                           #5# G191 (EXIT NIL))
                                          (EXIT
                                           (LETT |i| (+ |i| 1) . #3#)))))))
                           (LETT |j| (+ |j| 1) . #3#) #5# G191
                           (EXIT NIL)))
                #0# (EXIT #0#))
           (EXIT |x|))))) 

(DEFUN |MATLIN;determinant;MR;26| (|x| $)
  (SPADCALL |x| (QREFELT $ 33))) 

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

(DEFUN |MatrixLinearAlgebraFunctions;| (|#1| |#2| |#3| |#4|)
  (PROG (DV$1 DV$2 DV$3 DV$4 |dv$| $ |pv$|)
    (RETURN
      (PROGN
        (LETT DV$1 (|devaluate| |#1|)
              . #0=(|MatrixLinearAlgebraFunctions|))
        (LETT DV$2 (|devaluate| |#2|) . #0#)
        (LETT DV$3 (|devaluate| |#3|) . #0#)
        (LETT DV$4 (|devaluate| |#4|) . #0#)
        (LETT |dv$|
              (LIST '|MatrixLinearAlgebraFunctions| DV$1 DV$2 DV$3
                    DV$4) . #0#)
        (LETT $ (GETREFV 102) . #0#)
        (QSETREFV $ 0 |dv$|)
        (QSETREFV $ 3
            (LETT |pv$|
                  (|buildPredVector| 0 0
                      (LIST (|HasCategory| |#1| '(|Field|))
                            (|HasCategory| |#1| '(|EuclideanDomain|))
                            (|HasCategory| |#1| '(|IntegralDomain|)))) . #0#))
        (|haddProp| |$ConstructorCache| '|MatrixLinearAlgebraFunctions|
            (LIST DV$1 DV$2 DV$3 DV$4) (CONS 1 $))
        (|stuffDomainSlots| $)
        (QSETREFV $ 6 |#1|)
        (QSETREFV $ 7 |#2|)
        (QSETREFV $ 8 |#3|)
        (QSETREFV $ 9 |#4|)
        (COND
          ((|testBitVector| |pv$| 3)
           (PROGN
             (QSETREFV $ 54
                 (CONS (|dispatchFunction|
                           |MATLIN;fractionFreeGauss!;2M;8|)
                       $))
             (QSETREFV $ 61
                 (CONS (|dispatchFunction| |MATLIN;invertIfCan;MU;10|)
                       $))
             (QSETREFV $ 57
                 (CONS (|dispatchFunction| |MATLIN;adjoint;MR;11|) $)))))
        (COND
          ((|testBitVector| |pv$| 1)
           (PROGN
             (QSETREFV $ 67
                 (CONS (|dispatchFunction| |MATLIN;rowEchelon;2M;12|)
                       $))
             (QSETREFV $ 69
                 (CONS (|dispatchFunction| |MATLIN;rank;MNni;13|) $))
             (QSETREFV $ 71
                 (CONS (|dispatchFunction| |MATLIN;nullity;MNni;14|) $))
             (QSETREFV $ 73
                 (CONS (|dispatchFunction| |MATLIN;determinant;MR;15|)
                       $))
             (QSETREFV $ 75
                 (CONS (|dispatchFunction| |MATLIN;inverse;MU;16|) $))
             (COND
               ((|HasCategory| |#3| '(|shallowlyMutable|))
                (QSETREFV $ 78
                    (CONS (|dispatchFunction| |MATLIN;nullSpace;ML;17|)
                          $)))
               ('T
                (QSETREFV $ 78
                    (CONS (|dispatchFunction| |MATLIN;nullSpace;ML;18|)
                          $))))))
          ((|testBitVector| |pv$| 3)
           (PROGN
             (QSETREFV $ 78
                 (CONS (|dispatchFunction| |MATLIN;nullSpace;ML;19|) $))
             (QSETREFV $ 73
                 (CONS (|dispatchFunction| |MATLIN;determinant;MR;20|)
                       $))
             (QSETREFV $ 69
                 (CONS (|dispatchFunction| |MATLIN;rank;MNni;21|) $))
             (QSETREFV $ 71
                 (CONS (|dispatchFunction| |MATLIN;nullity;MNni;22|) $))
             (COND
               ((|testBitVector| |pv$| 2)
                (PROGN
                  (COND
                    ((|HasCategory| |#1| '(|IntegerNumberSystem|))
                     (QSETREFV $ 95
                         (CONS (|dispatchFunction|
                                   |MATLIN;normalizedDivide;2RR;23|)
                               $)))
                    ('T
                     (QSETREFV $ 95
                         (CONS (|dispatchFunction|
                                   |MATLIN;normalizedDivide;2RR;24|)
                               $))))
                  (QSETREFV $ 67
                      (CONS (|dispatchFunction|
                                |MATLIN;rowEchelon;2M;25|)
                            $)))))))
          ('T
           (QSETREFV $ 73
               (CONS (|dispatchFunction| |MATLIN;determinant;MR;26|) $))))
        $)))) 

(MAKEPROP '|MatrixLinearAlgebraFunctions| '|infovec|
    (LIST '#(NIL NIL NIL NIL NIL NIL (|local| |#1|) (|local| |#2|)
             (|local| |#3|) (|local| |#4|) (|Integer|)
             (0 . |minColIndex|) (5 . |maxColIndex|) (10 . |qelt|)
             (17 . |Zero|) (|Boolean|) (21 . =) (27 . |minRowIndex|)
             (32 . |maxRowIndex|) (|List| 10) (37 . |concat!|)
             (43 . |One|) (47 . *) (53 . +) (59 . -)
             (|NonNegativeInteger|) (65 . |nrows|) (70 . |ncols|)
             (|Union| 6 '"uncomputed") (|PrimitiveArray| 28)
             (75 . |new|) (|SingleInteger|) (81 . **)
             |MATLIN;minordet;MR;4| (87 . |row|) (93 . |setRow!|)
             |MATLIN;elRow1!;M2IM;5| (|Mapping| 6 6) (100 . |map|)
             (|Mapping| 6 6 6) (106 . |map|) |MATLIN;elRow2!;MR2IM;6|
             (113 . |column|) (119 . |map|) (125 . |map|)
             (132 . |setColumn!|) |MATLIN;elColumn2!;MR2IM;7|
             (139 . |swapRows!|) (146 . -) (|Union| $ '"failed")
             (151 . |exquo|) (157 . |qsetelt!|) (165 . |elt|)
             (172 . |setelt|) (180 . |fractionFreeGauss!|)
             (185 . |subMatrix|)
             (|Record| (|:| |adjMat| 9) (|:| |detMat| 6))
             (194 . |adjoint|) (199 . |recip|) (204 . *)
             (|Union| 9 '"failed") (210 . |invertIfCan|) (215 . |copy|)
             (220 . |scalarMatrix|) (226 . |horizConcat|)
             (|InnerMatrixLinearAlgebraFunctions| 6 7 8 9)
             (232 . |rowEchelon|) (237 . |rowEchelon|) (242 . |rank|)
             (247 . |rank|) (252 . |nullity|) (257 . |nullity|)
             (262 . |determinant|) (267 . |determinant|)
             (272 . |inverse|) (277 . |inverse|) (|List| 8)
             (282 . |nullSpace|) (287 . |nullSpace|) (|Matrix| 6)
             (|MatrixCategoryFunctions2| 6 7 8 9 6 85 85 79)
             (292 . |map|) (|List| 85)
             (|InnerMatrixLinearAlgebraFunctions| 6 85 85 79)
             (298 . |nullSpace|) (|Vector| 6)
             (|FiniteLinearAggregateFunctions2| 6 85 6 8) (303 . |map|)
             (|InnerMatrixQuotientFieldFunctions| 6 7 8 9
                 (|Fraction| 6) (|Vector| (|Fraction| 6))
                 (|Vector| (|Fraction| 6)) (|Matrix| (|Fraction| 6)))
             (309 . |nullSpace|) (314 . |transpose|)
             (|Record| (|:| |quotient| $) (|:| |remainder| $))
             (319 . |divide|) (325 . <)
             (|Record| (|:| |quotient| 6) (|:| |remainder| 6))
             (331 . |normalizedDivide|) (337 . |zero?|)
             (342 . |sizeLess?|)
             (|Record| (|:| |coef1| $) (|:| |coef2| $)
                 (|:| |generator| $))
             (348 . |extendedEuclidean|)
             (|Record| (|:| |unit| $) (|:| |canonical| $)
                 (|:| |associate| $))
             (354 . |unitNormal|))
          '#(|rowEchelon| 359 |rank| 364 |nullity| 369 |nullSpace| 374
             |normalizedDivide| 379 |minordet| 385 |invertIfCan| 390
             |inverse| 395 |fractionFreeGauss!| 400 |elRow2!| 405
             |elRow1!| 413 |elColumn2!| 420 |determinant| 428 |adjoint|
             433)
          'NIL
          (CONS (|makeByteWordVec2| 1 'NIL)
                (CONS '#()
                      (CONS '#()
                            (|makeByteWordVec2| 101
                                '(1 9 10 0 11 1 9 10 0 12 3 9 6 0 10 10
                                  13 0 6 0 14 2 6 15 0 0 16 1 9 10 0 17
                                  1 9 10 0 18 2 19 0 0 0 20 0 6 0 21 2
                                  6 0 0 0 22 2 6 0 0 0 23 2 6 0 0 0 24
                                  1 9 25 0 26 1 9 25 0 27 2 29 0 25 28
                                  30 2 31 0 0 25 32 2 9 7 0 10 34 3 9 0
                                  0 10 7 35 2 7 0 37 0 38 3 7 0 39 0 0
                                  40 2 9 8 0 10 42 2 8 0 37 0 43 3 8 0
                                  39 0 0 44 3 9 0 0 10 8 45 3 9 0 0 10
                                  10 47 1 6 0 0 48 2 6 49 0 0 50 4 9 6
                                  0 10 10 6 51 3 9 6 0 10 10 52 4 9 6 0
                                  10 10 6 53 1 0 9 9 54 5 9 0 0 10 10
                                  10 10 55 1 0 56 9 57 1 6 49 0 58 2 9
                                  0 6 0 59 1 0 60 9 61 1 9 0 0 62 2 9 0
                                  25 6 63 2 9 0 0 0 64 1 65 9 9 66 1 0
                                  9 9 67 1 65 25 9 68 1 0 25 9 69 1 65
                                  25 9 70 1 0 25 9 71 1 65 6 9 72 1 0 6
                                  9 73 1 65 60 9 74 1 0 60 9 75 1 65 76
                                  9 77 1 0 76 9 78 2 80 79 37 9 81 1 83
                                  82 79 84 2 86 8 37 85 87 1 88 76 9 89
                                  1 9 0 0 90 2 6 91 0 0 92 2 6 15 0 0
                                  93 2 0 94 6 6 95 1 6 15 0 96 2 6 15 0
                                  0 97 2 6 98 0 0 99 1 6 100 0 101 1 2
                                  9 9 67 1 3 25 9 69 1 3 25 9 71 1 3 76
                                  9 78 2 2 94 6 6 95 1 0 6 9 33 1 3 60
                                  9 61 1 1 60 9 75 1 3 9 9 54 4 0 9 9 6
                                  10 10 41 3 0 9 9 10 10 36 4 0 9 9 6
                                  10 10 46 1 0 6 9 73 1 3 56 9 57)))))
          '|lookupComplete|)) 
