#include <stdio.h>
#include <stdlib.h>
#include <stdbool.h>

typedef struct Info {
    int R;
    int C;
    int purifier_row;
} info;

bool is_possible_diffusion(info map_info, int r, int c);
void diffusion(int** dust_map, info map_info);
int purify(int** dust_map, info map_info);

int main() {
    int R, C, T;
    scanf("%d %d %d",&R, &C, &T);

    int total_dust = 0;
    int purifier_row = 0;
    bool find_air_purifier = false;

    int** dust_map = (int**)malloc(sizeof(int*)*R);
    for(int r=0; r<R; r++) {
        dust_map[r] = (int*)malloc(sizeof(int)*C);

        for(int c=0; c<C; c++) {
            scanf("%d",&dust_map[r][c]);
            total_dust += dust_map[r][c];
            if(dust_map[r][c] == -1 && !find_air_purifier) {
                find_air_purifier = true;
                purifier_row = r;
            }
        }
    }
    total_dust += 2;

    info map_info = {R, C, purifier_row};

    while(T--) {
        diffusion(dust_map, map_info);
        total_dust -= purify(dust_map, map_info);
    }

    printf("%d\n",total_dust);

    for(int r=0; r<R; r++) free(dust_map[r]);
    free(dust_map);

    return 0;
}


bool is_possible_diffusion(info map_info, int r, int c) {
    int R = map_info.R;
    int C = map_info.C;
    int purifier_row = map_info.purifier_row;

    return (0<=r && r<R) && (0<=c && c<C) && !(c==0 && (r == purifier_row || r == purifier_row+1));
}

void diffusion(int** dust_map, info map_info) {
    int R = map_info.R;
    int C = map_info.C;
    int purifier_row = map_info.purifier_row;

    int** temp_map = (int**)malloc(sizeof(int*)*R);

    for(int r=0; r<R; r++) {
        temp_map[r] = (int*)malloc(sizeof(int)*C);
        for(int c=0; c<C; c++) temp_map[r][c] = 0;
    }

    temp_map[purifier_row][0] = -1;
    temp_map[purifier_row+1][0] = -1;

    int dr[4] = {-1,1,0,0};
    int dc[4] = {0,0,1,-1};

    for(int r=0; r<R; r++) {
        for(int c=0; c<C; c++) {
            if(dust_map[r][c]>0) {
                int diffusion_amount = dust_map[r][c]/5;
                int diffusion_count = 0;

                for(int i=0; i<4; i++) {
                    int nr = r + dr[i];
                    int nc = c + dc[i];

                    if(is_possible_diffusion(map_info, nr, nc)) {
                        temp_map[nr][nc] += diffusion_amount;
                        diffusion_count++;
                    }
                }

                temp_map[r][c] += dust_map[r][c] - (diffusion_amount*diffusion_count);
            }
        }
    }

    for(int r=0; r<R; r++) {
        for(int c=0; c<C; c++) {
            dust_map[r][c] = temp_map[r][c];
        }
    }

    for(int r=0; r<R; r++) free(temp_map[r]);
    free(temp_map);
}

int purify(int** dust_map, info map_info) {
    int R = map_info.R;
    int C = map_info.C;
    int purifier_row = map_info.purifier_row;
    int purify_dust = 0;

    // up: anti clock-wise
    purify_dust += dust_map[purifier_row-1][0];
    for(int r=purifier_row-1; r>0; r--) dust_map[r][0] = dust_map[r-1][0];
    for(int c=0; c<C-1; c++) dust_map[0][c] = dust_map[0][c+1];
    for(int r=0; r<purifier_row; r++) dust_map[r][C-1] = dust_map[r+1][C-1];
    for(int c=C-1; c>1; c--) dust_map[purifier_row][c] = dust_map[purifier_row][c-1];
    dust_map[purifier_row][1] = 0;

    // dowm: clock-wise
    purify_dust += dust_map[purifier_row+2][0];
    for(int r=purifier_row+2; r<R-1; r++) dust_map[r][0] = dust_map[r+1][0];
    for(int c=0; c<C-1; c++) dust_map[R-1][c] = dust_map[R-1][c+1];
    for(int r=R-1; r>purifier_row+1; r--) dust_map[r][C-1] = dust_map[r-1][C-1];
    for(int c=C-1; c>1; c--) dust_map[purifier_row+1][c] = dust_map[purifier_row+1][c-1];
    dust_map[purifier_row+1][1] = 0; 

    return purify_dust;
}