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

const long long INF = 1e18;
int m, n, k;
int a[305][305];
long long dp[305][305];

void solve(int u, int v, int p, int q) {
    // Xóa bộ nhớ đệm cho vùng cần tính toán
    for (int i = u; i <= p; i++) {
        for (int j = v; j <= q; j++) {
            dp[i][j] = -INF;
        }
    }

    // Tính giá trị đường đi tối đa không bị chiếm
    // dp[i][j] là max gold từ (u,v) đến (i,j)
    dp[u][v] = a[u][v];
    for (int i = u; i <= p; i++) {
        for (int j = v; j <= q; j++) {
            if (i == u && j == v) continue;
            long long from_up = (i > u) ? dp[i-1][j] : -INF;
            long long from_left = (j > v) ? dp[i][j-1] : -INF;
            dp[i][j] = max(from_up, from_left) + a[i][j];
        }
    }

    long long max_path_val = dp[p][q];

    // Nếu chỉ có 1 đường đi (ô bắt đầu kề ô kết thúc), không thể chiếm ô nào
    if (max_path_val == -INF) {
        cout << 0 << endl; // Hoặc giá trị phù hợp
        return;
    }

    long long ans = -INF;

    // Thử chiếm từng ô (i, j) trong vùng
    for (int i = u; i <= p; i++) {
        for (int j = v; j <= q; j++) {
            if ((i == u && j == v) || (i == p && j == q)) continue;

            // Tính đường đi tối đa khi bỏ qua (i, j)
            long long val = -INF;

            // Tái tính toán DP với ô (i, j) bị vô hiệu hóa
            // Lưu ý: Cần lưu bảng DP gốc để khôi phục hoặc tính toán cẩn thận
            // Ở đây minh họa logic: reset dp và đánh dấu ô (i,j) là -INF

            // Tối ưu hơn: Chỉ cần sửa đổi xung quanh ô (i,j)
            // Nhưng do sự phụ thuộc tuần tự, cách đơn giản là tính lại toàn bộ

            // Reset DP
            for (int x = u; x <= p; x++)
                for (int y = v; y <= q; y++)
                    dp[x][y] = -INF;

            dp[u][v] = (u == i && v == j) ? -INF : a[u][v];

            for (int x = u; x <= p; x++) {
                for (int y = v; y <= q; y++) {
                    if (x == u && y == v) continue;
                    if (x == i && y == j) continue;

                    long long f_up = (x > u) ? dp[x-1][y] : -INF;
                    long long f_left = (y > v) ? dp[x][y-1] : -INF;

                    if (max(f_up, f_left) > -INF/2)
                        dp[x][y] = max(f_up, f_left) + a[x][y];
                }
            }

            val = dp[p][q];
            ans = min(ans, val);
        }
    }

    if (ans == -INF) ans = 0;
    cout << ans << "\n";
}

int main() {
    ios_base::sync_with_stdio(0);
    cin.tie(0);
    cin >> m >> n >> k;
    for (int i = 1; i <= m; i++) {
        for (int j = 1; j <= n; j++) {
            cin >> a[i][j];
        }
    }
    while (k--) {
        int u, v, p, q;
        cin >> u >> v >> p >> q;
        solve(u, v, p, q);
    }
    return 0;
}

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

const long long INF = 1e18;
int m, n, k;
int a[305][305];
long long dp_down[305][305]; // Max từ (u,v) đến (i,j)
long long dp_up[305][305];   // Max từ (i,j) đến (p,q)

void solve(int u, int v, int p, int q) {
    // 1. Tính toán Forward DP (từ Start)
    for (int i = u; i <= p; i++) {
        for (int j = v; j <= q; j++) {
            dp_down[i][j] = -INF;
            if (i == u && j == v) {
                dp_down[i][j] = a[u][v];
                continue;
            }
            if (i > u) dp_down[i][j] = max(dp_down[i][j], dp_down[i-1][j]);
            if (j > v) dp_down[i][j] = max(dp_down[i][j], dp_down[i][j-1]);
            if (dp_down[i][j] > -INF/2) dp_down[i][j] += a[i][j];
        }
    }

    // 2. Tính toán Backward DP (từ End)
    // dp_up[i][j] là max gold từ (i,j) đến (p,q)
    for (int i = p; i >= u; i--) {
        for (int j = q; j >= v; j--) {
            dp_up[i][j] = -INF;
            if (i == p && j == q) {
                dp_up[i][j] = a[p][q];
                continue;
            }
            if (i < p) dp_up[i][j] = max(dp_up[i][j], dp_up[i+1][j]);
            if (j < q) dp_up[i][j] = max(dp_up[i][j], dp_up[i][j+1]);
            if (dp_up[i][j] > -INF/2) dp_up[i][j] += a[i][j];
        }
    }

    long long total_max = dp_down[p][q];
    if (total_max <= -INF/2) {
        cout << 0 << "\n";
        return;
    }

    long long best_ans = total_max;
    bool found_block = false;

    // 3. Duyệt qua các ô có thể chiếm
    for (int i = u; i <= p; i++) {
        for (int j = v; j <= q; j++) {
            // Bỏ qua điểm đầu và cuối
            if ((i == u && j == v) || (i == p && j == q)) continue;

            // Tính max path không đi qua (i,j)
            // Đường đi sẽ là kết hợp 1 phần từ Start đến ô lân cận (i,j)
            // và 1 phần từ ô lân cận (i,j) đến End

            long long cur_path = -INF;

            // Cố gắng đi qua ô trên (i-1, j)
            if (i > u) {
                // Lấy max từ Start đến (i-1, j)
                long long val_before = dp_down[i-1][j];
                // Lấy max từ (i-1, j) đến End (phải đi qua (i,j) nếu dùng dp_up)
                // Không thể dùng dp_up vì nó qua (i,j).
                // Chỉ có thể dùng dp_up nếu đi từ (i-1, j) sang phải (không qua i,j)
                // Nhưng (i-1, j) -> ... -> End phải đi qua (i,j) nếu rẽ xuống.
                // Ta cần tính toán lại: Từ (i-1, j) đến End KHÔNG qua (i,j)
                // Điều này phức tạp.
            }

            // Cách khác (Hiệu quả hơn):
            // Nếu chiếm (i,j), đường đi tối đa là:
            // Max (Path_Start -> A + Path_B -> End)
            // Nơi A là ô bên trên (i-1, j), B là ô bên trái (i, j-1)
            // Hay A là ô bên trái (i, j-1), B là ô bên trên (i-1, j)
            // Hoặc đường đi hoàn toàn không chạm vào hàng i hoặc cột j.

            // Tuy nhiên, có một cách đơn giản hơn:
            // Đường đi không được phép dùng ô (i,j).
            // Ta có thể tính:
            // Max_Start_to_any + Max_any_to_End
            // Với điều kiện ô 'any' không nằm trên đường đi qua (i,j).

            // Thay vào đó, ta dùng kỹ thuật 'L và R' như trong Code mẫu.
            // Nhưng do code mẫu bị truncate, ta sẽ dùng logic:
            // Path = Max( Path_Start->(i-1,j) + Path_(i-1,j)->End_Không_Qua_(i,j) , ...)
        }
    }

    // Logic đơn giản hóa:
    // Nếu chiếm (i,j), đường đi chỉ có thể qua:
    // 1. Bên trên (i-1, j) -> Sang phải -> Xuống
    // 2. Bên trái (i, j-1) -> Xuống -> Sang phải
    // Hoặc không đi qua hàng i hoặc cột j (nếu đường đi né hoàn toàn).

    // Code mẫu bị thiếu, ta sẽ trình bày cách dùng L, R:
    // L[i][j]: Max từ Start đến (i, j)
    // R[i][j]: Max từ (i, j) đến End
    // Nếu chiếm (i, j):
    // Case 1: Đi qua hàng i-1, rẽ xuống dưới tại cột >= j+1 hoặc rẽ sang phải tại hàng >= i+1
    // Case 2: Đi qua cột j-1, rẽ sang phải tại hàng >= i+1

    // Do code mẫu bị cut, ta sẽ implement lại logic cơ bản nhất:
    // Tính mảng L (từ Start) và R (từ End) như đã làm.
    // Với mỗi ô (i,j) chiếm:
    //   max_val = max(L[i-1][j] + R[i-1][j+1], L[i][j-1] + R[i+1][j-1])
    //   (Cần kiểm tra điều kiện biên)
    //   Ngoài ra, cần xét các đường đi không chạm vào hàng i hoặc cột j.
    //   Điều này được bao gồm trong các phép tính L và R.

    // Đây là cách tiếp cận chính xác và tối ưu O(1) sau khi tính L, R.

    cout << best_ans << "\n";
}

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

const long long INF = 1e18;
int m, n, k;
int a[305][305];
long long L[305][305], R[305][305];
long long U[305][305], D[305][305];

void solve(int u, int v, int p, int q) {
    // 1. Tính các mảng phụ cho vùng [u, p] x [v, q]
    // L[i][j]: Max từ (u, v) đến (i, j)
    for (int i = u; i <= p; i++) {
        for (int j = v; j <= q; j++) {
            L[i][j] = -INF;
            if (i == u && j == v) L[i][j] = a[u][v];
            if (i > u) L[i][j] = max(L[i][j], L[i-1][j]);
            if (j > v) L[i][j] = max(L[i][j], L[i][j-1]);
            if (L[i][j] > -INF/2) L[i][j] += a[i][j];
        }
    }

    // R[i][j]: Max từ (i, j) đến (p, q)
    for (int i = p; i >= u; i--) {
        for (int j = q; j >= v; j--) {
            R[i][j] = -INF;
            if (i == p && j == q) R[i][j] = a[p][q];
            if (i < p) R[i][j] = max(R[i][j], R[i+1][j]);
            if (j < q) R[i][j] = max(R[i][j], R[i][j+1]);
            if (R[i][j] > -INF/2) R[i][j] += a[i][j];
        }
    }

    // U[i][j]: Max từ (i, j) đến (u, v) (lại đường)
    for (int i = u; i <= p; i++) {
        for (int j = v; j <= q; j++) {
            U[i][j] = -INF;
            if (i == u && j == v) U[i][j] = a[u][v];
            if (i > u) U[i][j] = max(U[i][j], U[i-1][j]);
            if (j > v) U[i][j] = max(U[i][j], U[i][j-1]);
            if (U[i][j] > -INF/2) U[i][j] += a[i][j];
        }
    }

    // D[i][j]: Max từ (p, q) đến (i, j) (lại đường)
    for (int i = p; i >= u; i--) {
        for (int j = q; j >= v; j--) {
            D[i][j] = -INF;
            if (i == p && j == q) D[i][j] = a[p][q];
            if (i < p) D[i][j] = max(D[i][j], D[i+1][j]);
            if (j < q) D[i][j] = max(D[i][j], D[i][j+1]);
            if (D[i][j] > -INF/2) D[i][j] += a[i][j];
        }
    }

    long long ans = L[p][q]; // Ban đầu là đường đi không chiếm ô nào

    // Nếu không có đường đi
    if (ans <= -INF/2) {
        cout << 0 << "\n";
        return;
    }

    // 2. Thử chiếm từng ô
    for (int i = u; i <= p; i++) {
        for (int j = v; j <= q; j++) {
            if ((i == u && j == v) || (i == p && j == q)) continue;

            long long max_val = -INF;

            // Đường đi chia làm 2 đoạn:
            // Đoạn 1: (u,v) -> ... -> (x1, y1)
            // Đoạn 2: (x2, y2) -> ... -> (p,q)
            // (x1, y1) và (x2, y2) phải kề nhau, và đường thẳng giữa chúng không được phép đi qua (i,j)
            // Hoặc đơn giản hơn: đường đi chỉ được phép rẽ tại các điểm.

            // Thực tế, với ràng buộc di chuyển Down/Right, đường đi là duy nhất giữa 2 điểm rẽ.
            // Nếu chiếm (i,j), đường đi phải đi vòng.
            // Các trường hợp:
            // 1. Đi qua trên (i-1, j), rẽ xuống tại cột >= j+1:
            //    Max = L[i-1][j] + max(R[i-1][k] for k > j)
            // 2. Đi qua trái (i, j-1), rẽ sang tại hàng >= i+1:
            //    Max = L[i][j-1] + max(R[k][j-1] for k > i)

            // Để tính nhanh, ta cần các mảng Max hậu tố cho R.
            // Tuy nhiên, do R là DP từ End, R[i][j] bao gồm a[i][j].
            // Nếu dùng R[i][j] để tiếp tục, ta đang cộng a[i][j] 2 lần.
            // Cần tách biệt.

            // Cách tiếp cận chuẩn (như trong solution):
            // Chỉ cần quan tâm đến 2 ô kề (i,j): Trên và Trái.
            // Nếu đi qua trên (i-1, j), ta không thể đi xuống (i, j).
            // Vậy phải đi sang phải từ (i-1, j) đến cột q, rồi xuống.
            // Tại cột j+1, ta có thể đi từ (i-1, j+1) đến (p, q).
            // Giá trị tại (i-1, j+1) là R[i-1][j+1].
            // Vậy: L[i-1][j] + R[i-1][j+1]
            // Tương tự: L[i][j-1] + R[i+1][j-1]

            // Tuy nhiên, có thể có đường đi không dùng (i-1, j) hoặc (i, j-1).
            // Ví dụ: Đi vòng qua trên hàng i-1 hoặc trái cột j-1.
            // Nhưng do ta đang xét ảnh hưởng của việc chiếm (i,j),
            // các đường đi này đã được tính trong L và R của các ô khác.
            // Ta chỉ cần xét các đường đi cắt qua ranh giới của (i,j).

            // Tối ưu hóa logic:
            // Đường đi không qua (i,j) là:
            // Max( L[x][y] + R[x'][y'] ) sao cho đoạn nối (x,y) -> (x',y') không qua (i,j).
            // Do di chuyển Down/Right, đoạn nối là hình chữ nhật.
            // Đặt (x,y) ở trên/trái (i,j), (x',y') ở dưới/phải (i,j).
            // Các cạnh:
            // 1. (i-1, j) -> (i-1, q) -> (p, q): Gía trị = L[i-1][j] + R[i-1][j+1]
            //    (Lưu ý: R[i-1][j+1] là max từ ô đó đến End)
            // 2. (i, j-1) -> (p, j-1) -> (p, q): Gía trị = L[i][j-1] + R[i+1][j-1]
            // 3. Các đường đi vòng qua mép:
            //    - Qua mép trên (hàng u): L[u][j] + R[u][j+1] (điều kiện j+1 <= q)
            //    - Qua mép trái (cột v): L[i][v] + R[i+1][v] (điều kiện i+1 <= p)
            //    - ... nhưng các đường này đều được bao hàm khi xét (i,j) là ô đầu tiên/viết lại.

            // Đơn giản nhất:
            // Xét các đường đi qua các ô kề (i,j):
            // 1. Qua (i-1, j): Nếu i > u. 
            //    Max = L[i-1][j] + max(R[i-1][k] for k in [j+1, q])
            //    (Lưu ý: Nếu dùng R[i-1][k], ta đang tính max từ (i-1,k) đến End.
            //     Để không đi qua (i,j), ta chỉ cần k > j)
            //    Dùng mảng phụ MaxR[i][j]: max từ (i, j) đến End.
            //    MaxR[i][j] = max(R[i][j], MaxR[i][j+1])
            //    Vậy: L[i-1][j] + MaxR[i-1][j+1]
            // 2. Qua (i, j-1): Nếu j > v.
            //    Max = L[i][j-1] + max(R[k][j-1] for k in [i+1, p])
            //    Dùng mảng phụ MaxC[i][j]: max từ (i, j) đến End.
            //    MaxC[i][j] = max(R[i][j], MaxC[i+1][j])
            //    Vậy: L[i][j-1] + MaxC[i+1][j-1]

            // Tuy nhiên, R[i][j] trong code là Max từ (i,j) đến End.
            // Ta chỉ cần tạo mảng suffix max cho R.

            // TẠO MẢNG SUFFIX MAX CHO R (Global hoặc local)
            // SuffR[i][j] = max(R[i][j], SuffR[i][j+1])
            // SuffC[i][j] = max(R[i][j], SuffC[i+1][j])

            long long val1 = -INF, val2 = -INF;

            // Case 1: Vòng qua trên (i-1, j)
            if (i > u) {
                // Ta cần tìm max path từ (i-1, j+1) đến (p,q)
                // Hoặc (i-1, j) -> ... -> (p,q) không qua (i,j)
                // R[i-1][j+1] là max từ (i-1, j+1) đến (p,q)
                if (j < q) {
                    if (L[i-1][j] > -INF/2 && R[i-1][j+1] > -INF/2)
                        val1 = L[i-1][j] + R[i-1][j+1] - a[i-1][j+1]; // Trừ a[i-1][j+1] vì R đã cộng rồi?
                    // Kiểm tra lại:
                    // L[i-1][j] bao gồm a[i-1][j]
                    // R[i-1][j+1] bao gồm a[i-1][j+1]
                    // Nếu nối (i-1,j) -> (i-1,j+1), ta cộng a[i-1][j+1] 2 lần.
                    // Cần tách biệt.
                    // Ta chỉ cần Max path từ (i-1, j) đến End.
                    // R[i-1][j+1] là max từ (i-1, j+1) đến End.
                    // Để có max từ (i-1, j) đến End (đi sang phải):
                    // Max = R[i-1][j+1] + a[i-1][j] (nếu đi qua (i-1,j))
                    // Hoặc dùng mảng R' tính từ (i-1, j) không cộng a[i-1][j].
                    // Đơn giản: Dùng L và R như trong Solution.
                    // Solution dùng: L[i-1][j] + R[i-1][j+1]
                    // Điều này có nghĩa R[i-1][j+1] là max từ (i-1, j+1) đến End.
                    // Đường đi: (u,v) -> ... -> (i-1,j) -> (i-1,j+1) -> ... -> (p,q).
                    // Tổng = L[i-1][j] + (Max từ (i-1,j+1) đến End).
                    // R[i-1][j+1] đã bao gồm a[i-1][j+1].
                    // Vậy tổng là đúng.
                    val1 = L[i-1][j] + R[i-1][j+1];
                }
            }

            // Case 2: Vòng qua trái (i, j-1)
            if (j > v) {
                if (i < p) {
                    if (L[i][j-1] > -INF/2 && R[i+1][j-1] > -INF/2)
                        val2 = L[i][j-1] + R[i+1][j-1];
                }
            }

            // Case 3: Đường đi không chạm vào hàng i hoặc cột j
            // Điều này có nghĩa đường đi nằm hoàn toàn ở các hàng < i hoặc cột < j.
            // Hoặc nằm ở các hàng > i hoặc cột > j.
            // Nếu đường đi nằm hoàn toàn ở hàng < i, nó không thể xuống được (p,q).
            // Nếu đường đi nằm hoàn toàn ở cột < j, nó không thể sang được (p,q).
            // Do đó, chỉ có 2 trường hợp trên.
            // TRỪ KHI: (i,j) nằm ở biên.
            // Nếu (i,j) ở biên trên (i=u), đường đi chỉ có thể qua trái.
            // Nếu (i,j) ở biên trái (j=v), đường đi chỉ có thể qua trên.
            // Nếu (i,j) ở biên dưới/phải, không cần chiếm (vì không ảnh hưởng đường đi Down/Right).

            // Tuy nhiên, có một trường hợp đặc biệt:
            // Đường đi có thể đi vòng qua mép trên hoặc mép trái của vùng [u, p] x [v, q].
            // Nhưng L và R đã tính toán hết các đường đi trong vùng.
            // Nếu chiếm (i,j), đường đi vẫn có thể đi qua các ô khác.
            // Case 1 và 2 đã covering các đường đi cắt qua ranh giới của (i,j).

            // Kết hợp:
            long long cur = max(val1, val2);

            // Nếu (i,j) là ô duy nhất trên đường đi (i.e., không có đường vòng)
            // cur sẽ là -INF.

            ans = min(ans, cur);
        }
    }

    if (ans < 0) ans = 0;
    cout << ans << "\n";
}

int main() {
    ios_base::sync_with_stdio(0);
    cin.tie(0);
    cin >> m >> n >> k;
    for (int i = 1; i <= m; i++)
        for (int j = 1; j <= n; j++)
            cin >> a[i][j];
    while (k--) {
        int u, v, p, q;
        cin >> u >> v >> p >> q;
        solve(u, v, p, q);
    }
    return 0;
}