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

using namespace std;

ifstream cin ("matrice2.in");
ofstream cout ("matrice2.out");

const int M = 300;
const int MAX_NODES = M * M;
const int N = 2e4;
int a[M + 1][M + 1];

int sol[N + 1], tata[MAX_NODES + 1];

int n, q, x, y, xx, yy;

int dx[] = {-1, 0, 1, 0};
int dy[] = {0, 1, 0, -1};

map <int, int> m[MAX_NODES + 1];

struct ceva
{
    int x, y, cost;
    bool operator < (const ceva &a)const
    {
        return cost > a.cost;
    }
};

vector <ceva> edges;

int cheie (int x, int y)
{
    return (x - 1) * n + y;
}

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

namespace DSU
{
    int rad (int node)
    {
        if (node == tata[node])return node;
        return tata[node] = rad (tata[node]);
    }
    void unite (ceva a)
    {
        int rx = rad (a.x);
        int ry = rad (a.y);
        if (rx != ry)
        {
            if (m[rx].size() > m[ry].size())
                swap(rx, ry);
            tata[rx] = ry;
            //cout << a.x << ' ' << a.y << ' ' << a.cost << '\n';
            for (auto it : m[rx])
            {
                if (m[ry].find(it.first) != m[ry].end())
                    sol[it.first] = min (sol[it.first], a.cost);
                m[ry][it.first]++;
            }
            m[rx].clear();
        }
    }
}

int main()
{
    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 >> x >> y >> xx >> yy;
        int val = cheie(x, y);
        m[val][i]++;
        val = cheie(xx, yy);
        m[val][i]++;
        sol[i] = min (a[x][y], a[xx][yy]);
    }
    for (int i = 1; i <= n; ++i)
        for (int j = 1; j <= n; ++j)
            for (int k = 0; k < 4; ++k)
            {
                int ii = i + dx[k];
                int jj = j + dy[k];
                int val1 = cheie(i, j);
                int val2 = cheie(ii, jj);
                if (inside (ii, jj))
                    edges.push_back({val1, val2, min (a[ii][jj], a[i][j])});
            }
    for (int i = 1; i <= n * n; ++i)
        tata[i] = i;
    sort (edges.begin(), edges.end());
    for (auto it : edges)
        DSU::unite(it);
    for (int i = 1; i <= q; ++i)
        cout << sol[i] << '\n';
    return 0;
}