Замена элементов в матрице

INSOMNIA> (defun matrix-copy (mx)
            "Copy matrix"
            (declare (type (simple-array t *) mx))
            (let* ((l (array-dimension mx 0))
                   (c (array-dimension mx 1))
                   (res (make-array (list l c))))
              (declare (type fixnum l c)
                       (type (simple-array t *) res))
              (loop for ln of-type fixnum below l
                 do (loop for co of-type fixnum below c
                       do (setf (aref res ln co)
                                (aref mx ln co))))
              res))
 
MATRIX-COPY
INSOMNIA> (defun f (x)
            (let ((mx (matrix-copy x)))
              (flet ((ad (n) (array-dimension mx n)))
                (loop for l below (ad 0)
                   minimize
                     (loop for c from l below (ad 1)
                        minimize (aref mx l c))
                   into rigth
                   minimize 
                     (loop for c from l downto 0
                        minimize (aref mx l c))
                   into left
                   finally 
                     (return
                       (values
                        (let ((max (max rigth left)))
                          (loop 
                             for l below (ad 0)
                             do (setf (aref mx l l) max))
                          mx)
                        (list rigth left)))))))
F
INSOMNIA> (defparameter
              mx
            #2A((3 6 7 3 4 0)
                (6 7 9 3 4 1)
                (8 0 1 2 1 1)
                (3 0 1 1 1 -5)
                (4 1 7 5 3 4)
                (9 -7 6 3 4 8)))
MX
INSOMNIA> (f mx)
#2A((-5 6 7 3 4 0)
    (6 -5 9 3 4 1)
    (8 0 -5 2 1 1)
    (3 0 1 -5 1 -5)
    (4 1 7 5 -5 4)
    (9 -7 6 3 4 -5))
(-5 -7)
INSOMNIA>

(defun task (matr)
   (let ((miu nil) (mid nil) (n (length matr)))
     (iter (for i from 1 to n)
       (iter (for j from (+ i 1) to n)
             (minimizing (nth (- j 1) (nth (- i 1) matr)) into miu)))
     (iter (for i from 2 to n)
       (iter (for j from 1 to (- i 1))
             (minimizing (nth (- j 1) (nth (- i 1) matr)) into mid)))
     (let ((mi (min miu mid)))
           (iter (for i from 1 to n) (setf (nth (- i 1) (nth (- i 1) matr)) mi))
           matr))) 
 
 
 
==> task
 
(task '((1 2 3 1) (4 5 6 -2) (7 8 9 10) (-11 2 3 4)))
 
==> ((-11 2 3 1) (4 -11 6 -2) (7 8 -11 10) (-11 2 3 -11))