import sys
input = sys.stdin.readline

def possible_diffusion(position_info: list[int]) -> bool :
    nr, nc, R, C, air_purifier = position_info
    return 0<=nr<R and 0<=nc<C and not (nc==0 and (nr == air_purifier or nr == air_purifier+1))

def dust_diffusion(dust_map: list[list[int]], map_info: list[int]) :
    R, C, air_purifier = map_info
    temp_map = [[0] * C for _ in range(R)]
    
    for r in range(R):
        for c in range(C):
            if dust_map[r][c] > 0:
                diffusion_amount = dust_map[r][c] // 5
                diffused_count = 0

                for nr, nc in [(r+1, c), (r-1, c), (r, c+1), (r, c-1)] :
                    if possible_diffusion([nr, nc, R, C, air_purifier]):
                        temp_map[nr][nc] += diffusion_amount
                        diffused_count += 1

                temp_map[r][c] += dust_map[r][c] - (diffusion_amount * diffused_count)

    temp_map[air_purifier][0] = -1
    temp_map[air_purifier+1][0] = -1
    
    for i in range(R):
        dust_map[i][:] = temp_map[i]

def dust_purify(dust_map, map_info) -> int :
    R, C, air_purifier = map_info

    purified_dust = 0

    # anti clockwise purify
    purified_dust += dust_map[air_purifier - 1][0]
    
    for r in range(air_purifier - 1, 0, -1):
        dust_map[r][0] = dust_map[r - 1][0]

    for c in range(0, C - 1):
        dust_map[0][c] = dust_map[0][c + 1]
        
    for r in range(0, air_purifier):
        dust_map[r][C - 1] = dust_map[r + 1][C - 1]
        
    for c in range(C - 1, 1, -1):
        dust_map[air_purifier][c] = dust_map[air_purifier][c - 1]
    
    dust_map[air_purifier][1] = 0

    # clockwise purify
    purified_dust += dust_map[air_purifier + 2][0]
    
    for r in range(air_purifier + 2, R - 1):
        dust_map[r][0] = dust_map[r + 1][0]
        
    for c in range(0, C - 1):
        dust_map[R - 1][c] = dust_map[R - 1][c + 1]

    for r in range(R - 1, air_purifier + 1, -1):
        dust_map[r][C - 1] = dust_map[r - 1][C - 1]

    for c in range(C - 1, 1, -1):
        dust_map[air_purifier + 1][c] = dust_map[air_purifier+ 1][c - 1]

    dust_map[air_purifier + 1][1] = 0
    
    return purified_dust

R, C, T = map(int, input().split())

dust_map: list[list[int]] = []
air_purifier = -1
find_air_purifier = False
total_dust = 0

for r in range(R) :
    dust_map.append(list(map(int, input().split())))
    total_dust += sum(dust_map[r])
    if not find_air_purifier :
        if dust_map[r][0] == -1 :
            air_purifier = r
            find_air_purifier = True

total_dust += 2
map_info = [R, C, air_purifier]

for _ in range(T) :
    dust_diffusion(dust_map, map_info)
    total_dust -= dust_purify(dust_map, map_info)

print(total_dust)