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

using namespace std;

ifstream fin ("matrice2.in");
ofstream fout ("matrice2.out");

const int dl[] = { -1, 0, 1, 0 };
const int dc[] = { 0, 1, 0, -1 };
class TDD1 { public : int x, y; };
class TDD2 { public : int x1, y1, x2, y2, index; };
int n, q, h_max, M[310][310], Val[310][310], Sol[20010], C[90010];
vector < TDD1 > V;
vector < TDD2 > Q;
bool F[310][310];
class TDD1_CMP { public : bool operator () (const TDD1 &a, const TDD1 &b) { return (M[a.x][a.y] > M[b.x][b.y]); } };
class TDD2_CMP { public : bool operator () (const TDD2 &a, const TDD2 &b) { return (Sol[a.index] > Sol[b.index]); } };

int Contr(int i)
{
    if (C[i] == i) return i;
    C[i] = Contr(C[i]);
    return C[i];
}

int main()
{
    fin >> n >> q;
    for (int i = 1; i <= n; i ++)
    {
        for (int j = 1; j <= n; j ++)
        {
            fin >> M[i][j];
            if (M[i][j] > h_max) h_max = M[i][j];
            Val[i][j] = (i - 1) * n + j - 1;
            V.push_back( { i, j } );
        }
    }

    sort(V.begin(), V.end(), TDD1_CMP());

    for (int i = 1, x1, y1, x2, y2; i <= q; i ++)
    {
        fin >> x1 >> y1 >> x2 >> y2;
        Q.push_back( { x1, y1, x2, y2, i } );
    }

    for (int step = (1 << 20); step; step >>= 1)
    {
        sort(Q.begin(), Q.end(), TDD2_CMP());
        memset(F, false, sizeof(F));
        for (int i = 0; i < n * n; i ++) C[i] = i;

        for (int i = 0, j = 0; j < Q.size(); j ++)
        {
            while (i < V.size() && Sol[Q[j].index] + step <= M[V[i].x][V[i].y])
            {
                F[V[i].x][V[i].y] = true;
                for (int k = 0; k < 4; k ++)
                {
                    int new_x = V[i].x + dl[k];
                    int new_y = V[i].y + dc[k];

                    if (F[new_x][new_y])
                    {
                        C[Contr(Val[V[i].x][V[i].y])] = Contr(Val[new_x][new_y]);
                    }
                }

                i ++;
            }

            if (Contr(Val[Q[j].x1][Q[j].y1]) == Contr(Val[Q[j].x2][Q[j].y2]))
            {
                Sol[Q[j].index] += step;
            }
        }
    }

    for (int i = 1; i <= q; i ++)
    {
        fout << Sol[i] << '\n';
    }

    fout.close();
    return 0;
}