from collections import deque

# 탐색 시작 좌표 x, y
# 탐색 시작 블록 색깔 c
def search_block_group(x, y, c, grid, visited):
    global N
    global max_group

    # 4방향 탐색
    dx = [0,0,-1,1]
    dy = [1,-1,0,0]

    q = deque()
    # 시작 좌표 큐에 삽입
    q.append([x, y])
    # 시작 좌표 방문 표시
    visited[x][y] = True
    # 탐색할 블록 그룹 크기(현재블록 포함시작임으로 1)
    curr_size = 1

    # 무지개 블록 방문 표시 해제
    rainbow_block_list = []
    # 대표보석을 찾기 위한 리스트
    except_rainbow_block_list = [[x, y]]
    # 이후 블록 제거를 위한 블록 리스트
    blocks_list = [[x, y]]

    # 탐색시작
    while q:
        cx, cy = q.popleft()

        for dir in range(4):
            # 주변 좌표
            nx = cx + dx[dir]
            ny = cy + dy[dir]
            
            # 맵밖으로 나가면 안됨
            if 0 <= nx < N and 0 <= ny < N:
                # 방문했거나, 빈칸, 검은색이면 진행 x
                if visited[nx][ny] or grid[nx][ny] == -2 or grid[nx][ny] == -1:
                    continue
                # 같은 색상이거나 무지개 블록이면 진행
                if(grid[nx][ny] == c or grid[nx][ny] == 0):
                    if grid[nx][ny] == 0: 
                        # 무지개 블록이면 무지개 블록 리스트에 삽입
                        rainbow_block_list.append([nx, ny])
                    else:
                        # 무지개 블록이 아니면, 무지개 블록 제외 리스트에 삽입
                        except_rainbow_block_list.append([nx, ny])
                    # 전체 블록리스트에도 삽입
                    blocks_list.append([nx, ny])
                    # 방문표시
                    visited[nx][ny] = True
                    # 블록 그룹 크기 증가
                    curr_size += 1
                    q.append([nx, ny])

    # 탐색종료(시작 탐색 위치에서 찾을 수 있는 가장 큰 블록 크기)
    # 정렬(행, 열 기준 오름차순)
    sorted(except_rainbow_block_list)

    # 그룹 크기가 2가 안되면 빈 리스트 반환
    if len(blocks_list) < 2: return []

    temp_group = {
        'size': curr_size,
        'list': blocks_list,
        'rainbow_num': len(rainbow_block_list),
        'x' : except_rainbow_block_list[0][0],
        'y' : except_rainbow_block_list[0][1]
    }

    # 현재 그룹의 크기가 더 크면 변경
    if max_group['size'] < temp_group['size']:
        max_group = temp_group
        # 크기가 같으면
    elif max_group['size'] == temp_group['size']:
        # 무지개 블록 수
        if max_group['rainbow_num'] < temp_group['rainbow_num']:
            max_group = temp_group
        elif max_group['rainbow_num'] == temp_group['rainbow_num']:
        # 행기준으로
            if max_group['x'] < temp_group['x']:
                max_group = temp_group
                # 행도 같으면
            elif max_group['x'] == temp_group['x']:
                # 열기준으로 판별
                if max_group['y'] < temp_group['y']:
                    max_group = temp_group

    # 무지개색 블록은 중복 방문이 가능하기 때문에 방문 표시 해제
    for rainbow_x, rainbow_y  in rainbow_block_list:
        visited[rainbow_x][rainbow_y] = False

# 블록 그룹 제거
def delete_block(grid):
    for x, y in max_group['list']:
        grid[x][y] = -2

# 중력 작용
def apply_gravity(grid):
    global N
    for y in range(N):
        for x in range(N-1, -1, -1):
            # 검은색은 안움직임
            if grid[x][y] == -1: continue
            # 빈칸이면
            if grid[x][y] == -2:
                idx = x
                # 위쪽으로 검은색이 아닌 색상블록을 찾아기
                while grid[idx][y] != -1 and grid[idx][y] == -2 and idx > 0:
                    idx -= 1
                # 찾았으면 위치 교환(값 변경)
                if grid[idx][y] != -1:
                    grid[x][y] = grid[idx][y] # 해당 블록 값으로
                    grid[idx][y] = -2 # 빈칸으로

# 회전
def rotate_block(grid):
    global N
    square_num = N - 2 # 회전할 사각형 개수
    length = N - 1 # 회전할 사각형 한변의 길이
    
    for sq in range(square_num):
        start_x = 0 + sq
        start_y = 0 + sq
        end_x = N - 1 - sq
        end_y = N - 1 - sq

        temp = [0 for _ in range(20)]
        # 첫 테두리 복사해두기
        for idx in range(length): 
            temp[idx] = grid[start_x][start_y + idx]
        # 첫 테두리로 회전한 테두리값 옮기기
        for idx in range(length): 
            grid[start_x][start_y + idx] = grid[start_x + idx][end_y]
        # 두번째 테두리
        for idx in range(length): 
            grid[start_x + idx][end_y] = grid[end_x][end_y - idx]
        # 세번째 테두리
        for idx in range(length): 
            grid[end_x][end_y - idx] = grid[end_x - idx][start_y]
        # 마지막 테두리에 복사해 두었던 값 옮기기
        for idx in range(length): 
            grid[end_x - idx][start_y] = temp[idx]

        length -= 2 # 사각형이 줄어들면 한변의 길이가 2 줄어든다

# Main
# N 값 입력
N, M = map(int, input().split())
# grid 정보 입력
grid = [list(map(int, input().split())) for _ in range(N)]

answer = 0
while True:
    # max group 초기화
    max_group = {'size': 0, 'list': [], 'x': -1, 'y': -1}
    # visited 초기화
    visited = [[False for _ in range(N)] for __ in range(N)]
    
    # 1. 가장 큰 블록 탐색
    # 큰거로 찾으니까 큰 좌표 부터 탐색
    for x in range(N-1, -1, -1):
        for y in range(N-1, -1, -1):
            # 빈칸이나 검은색, 무지개색 또는 방문한 블럭은 넘기기
            if grid[x][y] == -2 or grid[x][y] == -1 or grid[x][y] == 0 or visited[x][y]: 
                continue
            search_block_group(x, y, grid[x][y], grid, visited)

    # 만족하는 group를 못찾으면 종료
    if max_group['x'] == -1:
        break

    # 2. 보석제거
    answer += (len(max_group['list']) ** 2) # 점수 증가
    delete_block(grid)

    # 3. 중력작용
    apply_gravity(grid)

    # 4. 회전
    rotate_block(grid)

    # 5. 중력작용
    apply_gravity(grid)

print(answer)