; variables
(defparameter *score* 0)
(defparameter *n-m* '(4 9))
(defparameter *items* (make-array '(10 10)
				  :initial-element 0))

; functions
(defun stack-to-int (nstack)
  (parse-integer (coerce (reverse nstack) 'string))
  )

(defun input-to-list (str)
  (setf nstack '())
  (setf int-list '())
  ; each character
  (loop for c across str
	do
	(cond
	  ; space
	  ((char= c #\ )
	   (push (stack-to-int nstack) int-list)
	   (setf nstack nil))
	  (t
	    (push c nstack)))
	finally (push (stack-to-int nstack) int-list)
	)
  (reverse int-list)
  )

(defun input-scores ()
  (setf l '())
  (loop repeat (cadr *n-m*)
	do
	(push (input-to-list (read-line)) l)
	)
  (setf *scores* '())
  (loop for item in l
	do
	(setf (aref *items* (first item) (second item)) (third item))
	;(push (list (list (first item) (second item))
	;	    (third item)) *scores*))
	)
  )

(defun input ()
  (setf *n-m* (input-to-list (read-line)))
  (input-scores)
  )

; Calculate the score for a given list.
(defun score-list (l)
  (setf ret 0)
  ;(print l)
  (loop for i1 in l
	do
	(loop for i2 in (cdr (member i1 l))
	      ;initially
	      ;(print (cdr (member i1 l)))
	      do
	      (setf ret (+ ret (aref *items* i1 i2)))))
  ret
  )

; Calculate the score while generating the permutation lists.
(defun permutate (l &optional a)
  (if (null l)
    (setf *score* (max *score* (score-list (reverse a))))
    ;(print (reverse a))
    (dolist (i l)
      (permutate (remove i l) (cons i a))))
  )

(defun n90 ()
  (input)
  (permutate (loop for x from 0 to (1- (car *n-m*))
		   collect x))
  (princ *score*)
  )

(n90)