#include <fstream>
#include <algorithm>
#include <vector>

using namespace std;

struct query
{
    int i1, j1, i2, j2;
    int st, dr, ans;
};

struct nr
{
    int i, j, val;
};

ifstream in("matrice2.in");
ofstream out("matrice2.out");
int n, q;
int v[305][305];
nr w[90005];
query qs[20005];
pair<int, int> tata[305][305];
int dim[305][305];
vector<int> vec[90005];
int di[] = {1, -1, 0, 0};
int dj[] = {0, 0, 1, -1};

bool cmp(const nr &a, const nr &b)
{
    return a.val > b.val;
}

pair<int, int> rad(pair<int, int> x)
{
    if(tata[x.first][x.second] == x)
    {
        return x;
    }

    pair<int, int> r = rad(tata[x.first][x.second]);
    tata[x.first][x.second] = r;
    return r;
}

void uneste(pair<int, int> x, pair<int, int> y)
{
    pair<int, int> rx = rad(x);
    pair<int, int> ry = rad(y);

    if(rx == ry)
    {
        return;
    }

    if(dim[ry.first][ry.second] > dim[rx.first][rx.second])
    {
        swap(rx, ry);
    }

    tata[ry.first][ry.second] = {rx.first, rx.second};
    dim[rx.first][rx.second] += dim[ry.first][ry.second];
}

int main()
{
    in>>n>>q;
    for(int i = 1; i<=n; i++)
    {
        for(int j = 1; j<=n; j++)
        {
            in>>v[i][j];

            w[(i - 1) * n + j] = {i, j, v[i][j]};
        }
    }

    for(int i = 1; i<=q; i++)
    {
        in>>qs[i].i1>>qs[i].j1>>qs[i].i2>>qs[i].j2;
        qs[i].st = 1;
        qs[i].dr = n * n;
        qs[i].ans = -1;
    }

    sort(w + 1, w + n * n + 1, cmp);

    for(int t = 1; t<=20; t++)
    {
        for(int i = 1; i<=n*n; i++)
        {
            vec[i].clear();
        }

        for(int i = 1; i<=n; i++)
        {
            for(int j = 1; j<=n; j++)
            {
                tata[i][j] = {-1, -1};
                dim[i][j] = -1;
            }
        }

        for(int i = 1; i<=q; i++)
        {
            if(qs[i].st <= qs[i].dr)
            {
                int mij = (qs[i].st + qs[i].dr) / 2;

                vec[mij].push_back(i);
            }
        }

        for(int i = 1; i<=n*n; i++)
        {
            tata[w[i].i][w[i].j] = {w[i].i, w[i].j};
            dim[w[i].i][w[i].j] = 1;

            for(int k = 0; k<4; k++)
            {
                int iv = w[i].i + di[k];
                int jv = w[i].j + dj[k];

                if(iv >= 1 && iv <= n && jv >= 1 && jv <= n && tata[iv][jv].first != -1)
                {
                    uneste({w[i].i, w[i].j}, {iv, jv});
                }
            }

            for(auto it: vec[i])
            {
                if(tata[qs[it].i1][qs[it].j1].first == -1 || tata[qs[it].i2][qs[it].j2].first == -1)
                {
                    qs[it].st = i + 1;

                    continue;
                }


                if(rad({qs[it].i1, qs[it].j1}) == rad({qs[it].i2, qs[it].j2}))
                {
                    qs[it].dr = i - 1;
                    qs[it].ans = i;
                }
                else
                {
                    qs[it].st = i + 1;
                }
            }
        }
    }

    for(int i = 1; i<=q; i++)
    {
        out<<w[qs[i].ans].val<<'\n';
    }

    return 0;
}