anchor.diff:          (largerIndex '()))
       (dolist (i lastList (list largerNum largerIndex))
         (if (> (car i) thisNum)
  -          (progn (incf largerNum)
  +          (progn ;(print i)
  +            (incf largerNum)
                   (setf largerIndex (append largerIndex (list (cadr i))))
             )))))
   
  
positive.code:         (colNum (length (car matrix))))
      (loop for r from 0 to (1- rowNum) do
           (loop for c from 0 to (1- colNum) do
                (
  |#
  
negative.code:     (dolist (i list summation)
        (setf summation (+ i summation)))))
  
  (defun max-list (list)
      (loop for element in list maximizing element))
  
  (defun longest-list ( &rest llist)
    (let ((length-list '()))
      ;(print llist)
      (loop for i in llist do (progn
                                ;(print i)
                                (setf length-list (append length-list (list (length i))))
                                ;(print length-list)
                                ))
      (let ((largerNum (max-list length-list)))
        (loop for i from 0 to (1- (length length-list)) do
             (if (= largerNum (nth i length-list))
                 (return-from longest-list (nth i llist)))))))
  
  (defun tree-search-matrix (indexTable r c)
    (let ((this-hash (gethash (change-index-to-string r c) indexTable))
          (result))
      ;(print (nth 1 this-hash))
    (cond ((= 0 (car this-hash)) (progn ;(print (list r c))
           (return-from tree-search-matrix '(1) )))
          ((= 1 (car this-hash)) (progn ;(print (list r c))
           (return-from tree-search-matrix (setf result
                         (append '(1) (tree-search-matrix indexTable
                                                          (nth 0 (nth 0 (nth 1 this-hash)))
                                                          (nth 1 (nth 0 (nth 1 this-hash)))))))))
          ((= 2 (car this-hash)) (progn ;(print (list r c))
           (return-from tree-search-matrix (setf result (longest-list 
                         (append '(1) (tree-search-matrix indexTable
                                                          (nth 0 (nth 0 (nth 1 this-hash)))
                                                          (nth 1 (nth 0 (nth 1 this-hash)))))
                         (append '(1) (tree-search-matrix indexTable
                                                          (nth 0 (nth 1 (nth 1 this-hash)))
                                                          (nth 1 (nth 1 (nth 1 this-hash))))))))))
          ((= 3 (car this-hash)) (progn ;(print (list r c))
           (return-from tree-search-matrix (setf result (longest-list 
                         (append '(1) (tree-search-matrix indexTable
                                                          (nth 0 (nth 0 (nth 1 this-hash)))
                                                          (nth 1 (nth 0 (nth 1 this-hash)))))
                         (append '(1) (tree-search-matrix indexTable
                                                          (nth 0 (nth 1 (nth 1 this-hash)))
                                                          (nth 1 (nth 1 (nth 1 this-hash)))))
                         (append '(1) (tree-search-matrix indexTable
                                                          (nth 0 (nth 2 (nth 1 this-hash)))
                                                          (nth 1 (nth 2 (nth 1 this-hash)))))))))))
    result))
          
  
  (defun main (matrix)
    (let ((resultList '())
          (indexTable (gen-index-table matrix))
  