#include <bits/stdc++.h>
using namespace std;

int main() {
    int n, m, k;
    cin >> n >> m >> k;
    vector<vector<int>> a(n, vector<int>(m));
    for (int i = 0; i < n; ++i)
        for (int j = 0; j < m; ++j)
            cin >> a[i][j];

    // Bước 1: Gán số thứ tự cho ma trận theo thứ tự xoắn ốc
    vector<vector<int>> b(n, vector<int>(m, 0));
    int r1 = 0, c1 = 0, r2 = n - 1, c2 = m - 1;
    int cnt = 1;
    while (r1 <= r2 && c1 <= c2) {
        // Hang tren
        for (int j = c1; j <= c2; ++j) b[r1][j] = cnt++;
        // Cot phai
        for (int i = r1 + 1; i < r2; ++i) b[i][c2] = cnt++;
        // Hang duoi
        if (r1 < r2) {
            for (int j = c2; j >= c1; --j) b[r2][j] = cnt++;
        }
        // Cot trai
        if (c1 < c2) {
            for (int i = r2 - 1; i > r1; --i) b[i][c1] = cnt++;
        }
        r1++; c1++; r2--; c2--;
    }

    // Bước 2: Duyet de tao mang cac so thu tu cua cac o tot
    // Hoac su dung DP: tinh so luong o tot den truoc moi o
    vector<int> dp(n * m + 1, 0);
    for (int i = 0; i < n; ++i) {
        for (int j = 0; j < m; ++j) {
            if (a[i][j] == 1) {
                dp[b[i][j]] = 1;
            }
        }
    }
    // Tien tich luy
    for (int i = 1; i <= n * m; ++i) {
        dp[i] += dp[i - 1];
    }

    // Bước 3: Tim kiem nhi phan
    int low = 1, high = n * m, res = -1;
    while (low <= high) {
        int mid = low + (high - low) / 2;
        if (dp[mid] >= k) {
            res = mid;
            high = mid - 1;
        } else {
            low = mid + 1;
        }
    }

    if (res != -1 && dp[res] >= k) cout << res;
    else cout << -1;

    return 0;
}

#include <bits/stdc++.h>
using namespace std;

int main() {
    ios_base::sync_with_stdio(false); cin.tie(NULL);
    int n, m, k;
    cin >> n >> m >> k;
    vector<int> a(n * m + 1);
    // Đọc input theo thứ tự hàng
    for (int i = 1; i <= n; ++i) {
        for (int j = 1; j <= m; ++j) {
            int val; cin >> val;
            a[(i - 1) * m + j] = val;
        }
    }

    // Mảng đánh dấu vị trí trong xoắn ốc
    // Tuy nhiên, ta không cần mảng 2D nếu tính chỉ số trực tiếp.
    // Dưới đây là giải pháp sử dụng mảng 1D lưu giá trị gốc và xử lý.
    // Code này chỉ minh họa logic.
    // Thực tế Solution 2 sử dụng vector 2D cho `b` (số thứ tự) và `f` (giá trị).
    // Để tối ưu, ta có thể sinh số thứ tự và kiểm tra điều kiện ngay.
    // Tuy nhiên, phương pháp 1 là phổ biến nhất trong C++.

    // Phân tích Solution 2 (LongvnXD):
    // Giải pháp này sử dụng 4 biên (h1, h2, c1, c2) và đánh số tuần tự.
    // Nó duy trì một mảng `b` (số thứ tự) và một mảng `f` (giá trị).
    // Sau đó nó dùng Binary Search trên tổng tiền tố.
    // Cấu trúc tương tự phương pháp 1, nhưng cách lập trình vòng lặp xoắn ốc khác một chút.

    // Logic chung:
    // 1. Xây dựng map vị trí -> số thứ tự.
    // 2. Xây dựng prefix sum.
    // 3. Binary Search.

    return 0;
}

#include <bits/stdc++.h>
using namespace std;

int main() {
    // Code tương tự Approach 1, nhưng có thể tối ưu vector
    // Nếu N, M quá lớn, không thể lưu ma trận 2D.
    // Tuy nhiên, đề bài có N, M <= 30000, nên O(N*M) là chấp nhận được (~900 triệu phần tử nếu dùng int, quá lớn).
    // Nhưng trong thực tế, các solution accepted dùng mảng 2D kích thước 201x30001 (tức là N <= 200, M <= 30000).
    // Cần kiểm tra constraints kỹ.
    // Nếu N, M nhỏ (<= 1000), Approach 1 là tốt nhất.
    // Nếu N, M lớn, cần tối ưu tính toán chỉ số xoắn ốc không cần ma trận.

    // Phân tích Solution 1 (kimtuan15):
    // Dùng mảng toàn c cục `a[201][30001]`. Rõ ràng `n` <= 200.
    // Nếu `m` lớn, ta chỉ cần lưu theo hàng.
    // Code Solution 1 là ví dụ tối ưu cho ràng buộc `n` nhỏ.

    return 0;
}