#include <iostream>
#include <vector>
#include <queue>

using namespace std;

vector<pair<int, int>> dir = {{0,1},{1,0},{0,-1},{-1,0}};

int main() {
	int R, C, K;
	cin >> R >> C >> K;

	vector<vector<int>> grid(R, vector<int>(C));
	for (int i=0; i<R; i++)
		for (int j=0; j<C; j++)
			cin >> grid[i][j];

	// Build graph
	vector<vector<pair<int, int>>> neigh(R*C*(K+1)+2);
	for (int k=0; k<=K; k++) {
		for (int i=0; i<R; i++) {
			for (int j=0; j<C; j++) {
				for (int d=0; d<4; d++) {
					if (i+dir[d].first < 0 || i+dir[d].first >=R || j+dir[d].second < 0 || j+dir[d].second >= C)
						continue;

					// In-plane transitions
					neigh[k*R*C+i*C+j].push_back({k*R*C+(i+dir[d].first)*C+(j+dir[d].second),grid[i+dir[d].first][j+dir[d].second]});

					// Out-of-plane transitions
					if (k != K)
						neigh[k*R*C+i*C+j].push_back({(k+1)*R*C+(i+dir[d].first)*C+(j+dir[d].second),1000000000});
				}
			}
		}
	}

	// Entry into bottom row
	for (int j=0; j<C; j++) {
		neigh[(K+1)*R*C].push_back({j,grid[0][j]});
		if (K != 0)
			neigh[(K+1)*R*C].push_back({R*C+j, 1000000000});
	}

	// Exit out of top row
	for (int k=0; k<=K; k++) {
		for (int j=0; j<C; j++) {
			neigh[k*R*C+(R-1)*C+j].push_back({(K+1)*R*C+1,1000000000});
		}
	}

	vector<bool> done(R*C*(K+1)+2, false);
	vector<int> dist(R*C*(K+1)+2, 0);
	dist[R*C*(K+1)]=1000000000;
	priority_queue<pair<int, int>> work;
	work.push({1000000000,R*C*(K+1)});

	while (!work.empty()) {
		auto top = work.top();
		work.pop();

		if (done[top.second]) continue;
		done[top.second] = true;

		for (auto t : neigh[top.second]) {
			if (done[t.first]) continue;
			if (dist[t.first] >= min(t.second, dist[top.second])) continue;
			dist[t.first] = min(t.second, dist[top.second]);
			work.push({dist[t.first],t.first});
		}
	}

	cout << dist[R*C*(K+1)+1] << endl;

	return 0;
}