#include <bits/stdc++.h>
#pragma GCC optimize("O2", "unroll-loops", "inline", "-ffast-math")
#pragma GCC target("avx,sse2,sse3,sse4,mmx")
using namespace std;
#define fastio ios::sync_with_stdio(false); cin.tie(nullptr); cout.tie(nullptr);
#define ll long long
#define int ll
#define ld long double
#define eps 1e-12
#define MOD ((int)1e9+7)
int sqr(int x) {
    int l(0), r(x);
    int a(x), b((x + 1) >> 1);
    while (a > b)
        a = b, b = (b + x / b) >> 1;
    return a;
}
namespace nCr
{
    int fastpo(int base, int exp) {
        int ans = 1;
        while(exp)
        {
            if(exp&1) ans = (1ll * ans * base) % MOD;
            base = (1ll * base * base) % MOD;
            exp >>= 1;
        }
        return ans;
    }
    vector<int> fac, inv, finv;
    void sz(int n) {
        fac.resize(n+3),inv.resize(n+3),finv.resize(n+3);
        fac[0]=inv[0]=inv[1]=finv[0]=finv[1]=1;
        for(int i(1); i<=n; ++i) fac[i]=fac[i-1]*i%MOD;
        for(int i(2); i<=n; ++i) inv[i]=MOD-MOD/i*inv[MOD%i]%MOD;
        for(int i(2); i<=n; ++i) finv[i]=finv[i-1]*inv[i]%MOD;
    }
    int C(int n, int r) {
        if(n<0 or r>n) return 0;
        return(fac[n]*finv[r]%MOD*finv[n-r]%MOD);
    }
}
const int C = (1ll << 30) % MOD;
struct FenwickTree {
    int size;
    vector<int> tree;
    FenwickTree(int n) : size(n), tree(n+1) {}

    void add(int idx, int delta){
        while (idx <= size){
            tree[idx] += delta;
            idx += idx & -idx;
        }
    }

    int query(int idx) const{
        int res(0), i(idx);
        while (i > 0)
            res += tree[i], i -= i & -i;
        return res;
    }

    void reset(){
        fill(tree.begin(), tree.end(), 0);
    }
};

void GETAC() {

    int n, k, c(0), m, q, r, x, f, ans(0);
    int A, B, M, R, C;
    cin >> R >> C >> k;
    vector<vector<pair<int, int>>> vp;
    int mxown(0);
    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];
            if(grid[i][j] > mxown)
                mxown = grid[i][j];
        }
    }
    vp.assign(mxown+1, vector<pair<int, int>>());
    for(int i(0); i < R; ++i){
        for(int j(0), idx; j < C; ++j){
            idx = grid[i][j],
            vp[idx].emplace_back(make_pair(i+1, j+1));
        }
    }
    vector<vector<pair<int, int>>> p(mxown);
    for (int o(1); o <= mxown; ++o){
        if (vp[o].size() > 1){
            sort(vp[o].begin(), vp[o].end(), [&](const pair<int,int> &a, const pair<int,int> &b) -> bool{
                if(a.first ^ b.first) return a.first < b.first;
                else return a.second < b.second;
            });
            p.emplace_back(vp[o]);
        }
    }
    int l(0), h(max(R, C));
    while (l < h){
        m = (l + ((h-l) >> 1));
        int s(0);
        for (int i(1), ai; i <= R; ++i){
            ai = min(R, i+m) - max(1ll, i-m) + 1;
            s += ai;
        }
        int sb(0);
        for(int j(1), bj; j <= C; ++j){
            bj = min(C, j + m) - max(1ll, j-m) + 1;
            sb += bj;
        }
        int pot(s*sb - R*C), same(0);
        FenwickTree ft(C);
        for(auto &cell : p){
            int n(cell.size()), l(0), r(0);
            ft.reset();
            for(int i(0); i < n; ++i){
                int curx(cell[i].first), cury(cell[i].second);
                while (r < n and cell[r].first <= curx+m)
                    ft.add(cell[r].second, 1), ++r;
                while (l < n and cell[l].first < curx-m)
                    ft.add(cell[l].second, -1), ++l;
                int cl(max(1ll, (int)(cury-m))), cr(min((int)C, (int)(cury+m))),
                f(ft.query(cr) - ft.query(cl-1));
                same += f-1;
            }
        }
        (pot >= k+same)? h=m : (l=m+1, ans = l);
    }
    cout << ans;
}


static void run_with_stack_size(void (*func)(void), size_t stsize) {
    char *stack, *send;
    stack = (char *)malloc(stsize);
    if (!stack) {
        exit(1);
    }
    send = stack + stsize - 16;
    send = (char *)((uintptr_t)send & -16L);

    asm volatile(
            "mov %%rsp, (%0)\n"
            "mov %0, %%rsp\n"
            :
            : "r"(send)
            : "memory"
            );

    func();

    asm volatile(
            "mov (%0), %%rsp\n"
            :
            : "r"(send)
            : "memory"
            );

    free(stack);
}

signed main() {
    fastio
freopen("D:\\META\\bunny_hopscotch_input.txt", "r", stdin);
    freopen("D:\\META\\OUT1.txt", "w", stdout);
    int T;
    cin >> T;

    for (int tc(1); tc <= T; ++tc){
        cout << "Case #" << tc << ": ";
        run_with_stack_size(GETAC, 1024 * 1024 * 1024);
        cout << "\n";
    }

    return 0;
}