#include <fstream>
#include <algorithm>
 
using namespace std;
 
#define MAXN 310
#define MAXX 90010
#define MAXQ 20010
#define MAXL 4
 
const int dirx[MAXL] = {-1, 0, 1, 0};
const int diry[MAXL] = {0, 1, 0, -1};
 
int N, Q, L;
char B[MAXN][MAXN];
int W[MAXN][MAXN];
int X[MAXX], Y[MAXX], C[MAXX], P[MAXX];
int G[MAXX];
int Sol[MAXQ];
int Query[MAXQ], P2[MAXQ];
int X1[MAXQ], Y1[MAXQ], X2[MAXQ], Y2[MAXQ];
 
inline int cmp(int x, int y)
{
    return C[x] > C[y];
}
 
inline int cmp2(int x, int y)
{
    return Query[x] > Query[y];
}
 
inline int find_dad(int x)
{
    if (x != G[x]) G[x] = find_dad(G[x]);
    return G[x];
}
 
int main()
{
    ifstream fin("matrice2.in");
    ofstream fout("matrice2.out");
 
    int i, j, k, p, step, cx, cy;
 
    fin >> N >> Q;
 
    for (i = 1; i <= N; i++)
        for (j = 1; j <= N; j++)
        {
            L++;
            W[i][j] = L;
            X[L] = i, Y[L] = j;
            fin >> C[L];
            P[L] = L;
        }
 
    for (i = 1; i <= Q; i++) fin >> X1[i] >> Y1[i] >> X2[i] >> Y2[i];
 
    sort(P+1, P+L+1, cmp);
 
    for (step = 1; step < C[P[1]]; step <<= 1);
 
    for (; step; step >>= 1)
    {
        for (i = 1; i <= Q; i++)
        {
            Query[i] = Sol[i] + step;
            P2[i] = i;
        }
 
        sort(P2+1, P2+Q+1, cmp2);
 
        for (i = 1; i <= L; i++) G[i] = i;
 
        for (i = 1; i <= N; i++)
            for (j = 1; j <= N; j++) B[i][j] = 0;
 
        for (i = 1, j = 1; i <= L; )
        {
            for (k = j; j <= Q && Query[P2[j]] > C[P[i]]; j++)
                if (find_dad( W[X1[P2[j]]][Y1[P2[j]]] ) == find_dad( W[X2[P2[j]]][Y2[P2[j]]] )) Sol[P2[j]] += step;
 
            for (k = i; i <= L && C[P[i]] == C[P[k]]; i++)
            {
                B[X[P[i]]][Y[P[i]]] = 1;
 
                for (p = 0; p < MAXL; p++)
                {
                    cx = X[P[i]] + dirx[p];
                    cy = Y[P[i]] + diry[p];
 
                    if (cx > 0 && cy > 0 && cx <= N && cy <= N && B[cx][cy])
                        G[G[ find_dad(W[cx][cy]) ]] = G[P[i]];
                }
            }
        }
 
        for (; j <= Q; j++)
            if (find_dad( W[X1[P2[j]]][Y1[P2[j]]] ) == find_dad( W[X2[P2[j]]][Y2[P2[j]]] )) Sol[P2[j]] += step;
    }
 
    for (i = 1; i <= Q; i++) fout << Sol[i] << "\n";
 
    return 0;
}