#include <bits/stdc++.h>

using namespace std;

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

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

int n , m;
struct ura
{
    int bval , x , y , val;
};

bool mat[305][305];

vector<ura>v;

struct query
{
    int x1 , y1 , x2 , y2 , poz;
    bool operator < (const query q) const {
  return poz < q.poz;
}
};


set<query> q[90005];
vector<query> descos;
int rez     [90005];

int parent[90005];

int Find(int node)
{
    if(parent[node] == node)
        return node;
    return parent[node] = Find(parent[node]);
}

///int nrQ[90005]; /// number of q's in group parent

bool xort1(ura a , ura b)
{
    return a.bval < b.bval;
}

bool xort2(ura a , ura b)
{
    if(a.x == b.x)
        return a.y < b.y;
    return a.x < b.x;
}

int main()
{
    int val;
    in >> n >> m;
    for(int i = 1; i <= n; ++i)
    {
        for(int j = 1; j <= n; ++j)
        {
            in >> val;
            v.push_back({val , i , j , 0});
        }
    }
    sort(v.begin(),v.end(),xort1);
    int ac = 1;
    v[0].val = ac;
    for(int i = 1; i < v.size(); ++i)
    {
        if(v[i].bval > v[i-1].bval)
            ++ac;
        v[i].val = ac;
    }
    reverse(v.begin(),v.end());
    for(int i = 1; i <= n*n; ++i)
        parent[i] = i;
    for(int i = 1; i <= m; ++i)
    {
        int x1 , y1 , x2 , y2;
        in >> x1 >> y1 >> x2 >> y2;
        int node = (x1 - 1) * n + y1;
        q[node].insert({x1,y1,x2,y2,i}); /// <----------
        node = (x2 - 1) * n + y2;
        q[node].insert({x1,y1,x2,y2,i}); /// <----------
    }
    for(auto &i:v)
    {
        int newparent = (i.x - 1) * n + i.y;
        mat[i.x][i.y] = 1;
        set<int> parents;
        parents.insert(Find((i.x - 1) * n + i.y));
        for(int dir = 0 ; dir < 4; ++dir)
        {
            int x = i.x + dx[dir];
            int y = i.y + dy[dir];
            int node = (x - 1) * n + y;
            if(mat[x][y] == 1)
            {
                parents.insert(Find(node));
            }
        }
            priority_queue<pair<int , int> >nrofq; ///--start mic mare la gratar la costinesti buff
            for(auto &j:parents)
            {
                nrofq.push({-q[j].size() , j});
            }
            while(nrofq.size() > 1)
            {
                int node1 = nrofq.top().second;
                nrofq.pop();
                int node2 = nrofq.top().second;
                for(auto &j:q[node1])
                    if(q[node2].find(j) != q[node2].end())
                    {
                        rez[j.poz] = i.bval;
                        descos.push_back(j);
                    }
                for(auto &j: descos)
                {
                    q[node1].erase(j);
                    q[node2].erase(j);
                }
                descos.clear();
                while(q[node1].size())
                {
                    q[node2].insert(*q[node1].begin());
                    q[node1].erase(q[node1].begin());
                }
                nrofq.pop();
                nrofq.push({-q[node2].size(),node2});
                newparent = node2;

            }  ///end--
            parent[Find((i.x-1)*n+i.y)] = newparent;
        for(int dir = 0 ;dir < 4; ++dir)
        {
            int x = i.x + dx[dir];
            int y = i.y + dy[dir];
            int node = (x - 1)  * n + y;
            if(mat[x][y] == 1)
            {
                parent[Find(node)] = newparent;
            }
        }

    }
    for(int i = 1; i <= m; ++i)
        out << rez[i] << '\n';

    return 0;
}