#include <bits/stdc++.h>

using namespace std;

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

const int NMAX = 300;
const int QMAX = 20000;

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

int N, Q, cnt;
int dim[NMAX * NMAX + 5];
int tata[NMAX * NMAX + 5];
int matrix[NMAX + 5][NMAX + 5];

bool verifica(int i, int j)
{
    if(i < 1 || j < 1 || i > N || j > N)
        return false;
    return true;
}

int tata_multime(int x)
{
    if(x != tata[x])
    {
        return tata_multime(tata[x]);
    }
    return x;
}

void unire(int x, int y)
{
    x = tata_multime(x);
    y = tata_multime(y);
    if(x == y)
    {
        return ;
    }
    if(dim[x] >= dim[y])
    {
        dim[x] += dim[y];
        tata[y] = x;
    }
    else
    {
        dim[y] += dim[x];
        tata[x] = y;
    }
}

bool check(int a, int b, int c, int d)
{
    int x = (a - 1) * N + b;
    int y = (c - 1) * N + d;
    return (tata_multime(x) == tata_multime(y));
}

struct elem
{
    int val, lin, col, idx;
    bool operator < (const elem &other) const
    {
        return val > other.val;
    }
};
elem v[NMAX * NMAX + 5];

struct queries
{
    int a, b, c, d, ans, idx;
    bool operator < (const queries &other) const
    {
        return ans > other.ans;
    }
};
queries ask[QMAX + 5];

inline bool cmp (const queries &a, const queries &b)
{
    return a.idx < b.idx;
}

void marcheaza(elem x)
{
    int lin = x.lin;
    int col = x.col;
    for(int i = 0; i < 4; i ++)
    {
        int lin_nou = lin + di[i];
        int col_nou = col + dj[i];
        if(verifica(lin_nou, col_nou && matrix[lin_nou][col_nou] >= matrix[lin][col]))
        {
            int frst = (lin - 1) * N + col;
            int scnd = (lin_nou - 1) * N + col_nou;
            unire(frst, scnd);
        }
    }
}

void reseteaza()
{
    for(int i = 1; i <= N * N; i ++)
    {
        dim[i] = 1;
        tata[i] = i;
    }
}

int main()
{
    fin >> N >> Q;
    for(int i = 1; i <= N; i ++)
    {
        for(int j = 1; j <= N; j ++)
        {
            fin >> matrix[i][j];
            cnt++;
            v[cnt] = {matrix[i][j], i, j, cnt};
        }
    }
    for(int i = 1; i <= Q; i ++)
    {
        fin >> ask[i].a >> ask[i].b >> ask[i].c >> ask[i].d;
        ask[i].ans = 0;
        ask[i].idx = i;
    }
    sort(v + 1, v + cnt + 1);
    for(int i = 20; i >= 0; i --)
    {
        int bit = (1 << i);
        sort(ask + 1, ask + Q + 1);
        int poz = 1;
        reseteaza();
        for(int j = 1; j <= Q; j ++)
        {
            while(poz <= cnt && v[poz].val >= bit + ask[j].ans)
            {
                marcheaza(v[poz]);
                poz++;
            }
            if(check(ask[j].a, ask[j].b, ask[j].c, ask[j].d) == true)
            {
                ask[j].ans += bit;
            }
        }
    }
    sort(ask + 1, ask + Q + 1, cmp);
    for(int i = 1; i <= Q; i ++)
    {
        fout << ask[i].ans << '\n';
    }
    return 0;
}