#include <bits/stdc++.h>

using namespace std;

struct Query {
    int x, y, u, v, id;
};

const int D[4][2] = {{-1,0},{1,0},{0,-1},{0,1}};
const int N = 307;
const int Q = 2e4+7;
int n, q, a[N][N];
Query ques[Q];

bool inside(int x, int y) {
    return x >= 1 && x <= n && y >= 1 && y <= n;
}

namespace sub1 {
    int dist[N][N];
    int dijkstra(int su, int sv, int tu, int tv) {
        priority_queue<pair<int, pair<int,int>>> heap;
        memset(dist, 0, sizeof dist);
        dist[su][sv] = a[su][sv];
        heap.emplace(dist[su][sv], make_pair(su,sv));
        while (!heap.empty()) {
            int u = heap.top().second.first;
            int v = heap.top().second.second;
            int w = heap.top().first;
            heap.pop();
            if (w != dist[u][v]) continue;
            // if (u == tu && v == tv) 
            //     return dist[u][v];
            for (int i = 0; i < 4; ++i) {
                int x = u + D[i][0];
                int y = v + D[i][1];
                if (inside(x,y)) {
                    if (dist[x][y] < min(dist[u][v], a[x][y])) {
                        dist[x][y] = min(dist[u][v], a[x][y]);
                        heap.emplace(dist[x][y], make_pair(x,y));
                    }
                }
            }
        }
        return dist[tu][tv];
    }
    void solve() {
        for (int i = 1; i <= q; ++i) {
            cout << dijkstra(ques[i].x, ques[i].y, ques[i].u, ques[i].v) << '\n';
        }
    }
}

namespace sub2 {
    bool mark[N][N];
    bool bfs(int su, int sv, int tu, int tv, int k) {
        queue<pair<int,int>> q;
        memset(mark, false, sizeof mark); // giam ve n
        mark[su][sv] = true;
        q.emplace(su, sv);
        while (!q.empty()) {
            int u = q.front().first;
            int v = q.front().second;
            q.pop();
            if (u == tu && v == tv) 
                return true;
            for (int i = 0; i < 4; ++i) {
                int x = u + D[i][0];
                int y = v + D[i][1];
                if (inside(x,y) && a[x][y] >= k && !mark[x][y]) {
                    mark[x][y] = true;
                    q.emplace(x,y);
                }
            }
        }
        return false;
    }
    void solve() {
        for (int i = 1; i <= q; ++i) {
            int l = 1;
            int r = min(a[ques[i].x][ques[i].y], a[ques[i].u][ques[i].v]);
            while (l < r) {
                int m = l+r+1>>1;
                if (bfs(ques[i].x,ques[i].y,ques[i].u,ques[i].v, m))
                    l = m;
                else r = m-1;
            }
            cout << l << '\n';
        }
    }
}

int main() {
    cin.tie(nullptr)->sync_with_stdio(false);
    #ifdef NHPHUCQT
    freopen("demo.inp", "r", stdin);
    freopen("demo.out", "w", stdout);
    #else 
    freopen("matrice2.in", "r", stdin);
    freopen("matrice2.out", "w", stdout);
    #endif

    cin >> n >> q;
    for (int i = 1; i <= n; ++i)
    for (int j = 1; j <= n; ++j) {
        cin >> a[i][j];
    }
    for (int i = 1; i <= q; ++i) {
        cin >> ques[i].x >> ques[i].y >> ques[i].u >> ques[i].v;
        ques[i].id = i;
    }

    sub2::solve();

    return 0;
}