#include <bits/stdc++.h>
#include <atcoder/all>
using namespace atcoder;
#define rep(i, n) for (int i = 0; i < (n); ++i)

using namespace std;

const int di[] = {-1, 0, 1, 0};
const int dj[] = {0, 1, 0, -1};

int main() {
    int h, w;
    cin >> h >> w;
    
    vector<tuple<int, int, int>> buildings;
    rep(i, h)rep(j, w) {
        int f;
        cin >> f;
        buildings.emplace_back(f, i, j);
    }
    int n = h*w;
    
    ranges::sort(buildings);
    
    int q;
    cin >> q;
    vector<tuple<int, int, int, int>> qs;
    rep(qi, q) {
        int a, b, c, d;
        cin >> a >> b >> c >> d;
        --a; --b; --c; --d;
        qs.emplace_back(a, b, c, d);
    }
    
    vector<int> ac(q, n-1), wa(q, -1);
    rep(ti, 20) {
        vector<vector<int>> qis(n);
        rep(qi, q) {
            if (wa[qi]+1 < ac[qi]) {
                int wj = (ac[qi]+wa[qi])/2;
                qis[wj].push_back(qi);
            }
        }
        
        dsu uf(n);
        vector<bool> canPass(n);
        rep(bi, n) {
            auto [f, i, j] = buildings[bi];
            int v = i*w+j;
            canPass[v] = true;
            rep(dir, 4) {
                int ni = i+di[dir], nj = j+dj[dir];
                if (ni < 0 or nj < 0 or ni >= h or nj >= w) continue;
                int u = ni*w+nj;
                if (!canPass[u]) continue;
                uf.merge(v, u);
            }
            
            for (int qi : qis[bi]) {
                auto [a, b, c, d] = qs[qi];
                int s = a*w+b, t = c*w+d;
                if (uf.same(s, t)) ac[qi] = bi; else wa[qi] = bi;
            }
        }
    }
    
    rep(qi, q) {
        auto [a, b, c, d] = qs[qi];
        int ans = get<0>(buildings[ac[qi]]);
        cout << ans << '\n';
    }
    
    return 0;
}