#include <bits/stdc++.h>
#define pb push_back

using namespace std;

class Parser {
  private:
    static const int SIZE = 1e5;
    char str[SIZE];

    int ptr;
    FILE *fin;

    char getChar() {
        if (ptr == SIZE) {
            fread(str, sizeof(char), SIZE, fin);
            ptr = 0;
        }
        return str[ptr++];
    }

    int getInt() {
        char chr = getChar();
        while (!isdigit(chr) && chr != '-')
            chr = getChar();

        int sgn = +1;
        if (chr == '-') {
            sgn = -1;
            chr = getChar();
        }

        int nr = 0;
        while (isdigit(chr)) {
            nr = nr * 10 + chr - '0';
            chr = getChar();
        }
        return nr * sgn;
    }

  public:
    Parser(const char* str) :
        ptr(SIZE), fin(fopen(str, "r")) { }

    ~Parser() {
        fclose(fin);
    }

    friend Parser& operator>>(Parser& in, int& nr) {
        nr = in.getInt();
        return in;
    }
};

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

void debug_out() { cerr << '\n'; }
template <typename Head, typename... Tail> void debug_out(Head H, Tail... T) { cerr << " " << H; debug_out(T...);}
#define dbg(...) cerr << #__VA_ARGS__ << " ->", debug_out(__VA_ARGS__)
#define dbg_v(x, n) do{cerr<<#x"[]: ";for(int _=0;_<n;++_)cerr<<x[_]<<" ";cerr<<'\n';}while(0)
#define dbg_ok cerr<<"OK!\n"

typedef pair<int,int> pii;
typedef long long int ll;
typedef long double ld;

const int DMAX = 310;
const int QMAX = 2e4+10;

struct nume{
    int val,x,y;
};
inline bool operator<(nume x,nume y){
    return x.val>y.val;
}

vector <nume> vec;
set <int> query[DMAX*DMAX];

int M[DMAX][DMAX];

int tata[DMAX*DMAX];
int cates[DMAX*DMAX];
int ans[QMAX];

int dl[]={-1,0,1,0};
int dc[]={0,1,0,-1};

int n,q;

int transf(int x,int y){
    return (x-1)*301+y;
}
bool ok(int x,int y){
    if(x == 0 || x == n+1)
        return 0;
    if(y == 0 || y == n+1)
        return 0;
    return 1;
}

int findd(int node);
void uneste(int x,int y,int val);

int main(){
    int t,i,j,k;
    int x,y,xx,yy;

    fin>>n>>q;
    for(i=1;i<=n;i++)
        for(j=1;j<=n;j++){
            fin>>M[i][j];
            vec.pb({M[i][j],i,j});
        }
    sort(vec.begin(),vec.end());

    for(i=1;i<=q;i++){
        fin>>x>>y>>xx>>yy;
        query[transf(x,y)].insert(i);
        query[transf(xx,yy)].insert(i);
        cates[transf(x,y)]++;
        cates[transf(xx,yy)]++;
    }
    int rez=0;
    for(auto& it:vec){
        for(k=0;k<4;k++){
            x=it.x+dl[k];
            y=it.y+dc[k];
            if(!ok(x,y) || M[x][y] < M[it.x][it.y])
                continue;
            uneste(transf(x,y),transf(it.x,it.y),it.val);
        }
    }

    for(i=1;i<=q;i++)
        fout<<ans[i]<<'\n';
    return 0;
}
int findd(int node){
    int ans=node;
    while(tata[ans])
        ans=tata[ans];
    int aux;
    while(tata[node]){
        aux=node;
        node=tata[node];
        tata[aux]=ans;
    }
    return ans;
}
void uneste(int x,int y,int val){
    x=findd(x);
    y=findd(y);

    if(x == y)
        return;
    if(cates[x] > cates[y]){
        tata[y]=x;
        for(auto& it:query[y]){
            auto pos=query[x].upper_bound(it);
            if(pos != query[x].begin())
                pos=prev(pos);
            if(*pos == it){
                ans[it]=val;
                query[x].erase(pos);
                cates[x]--;
                continue;
            }
            cates[x]++;
            query[x].insert(it);
        }
        query[y].clear();
        return;
    }
    tata[x]=y;
    for(auto& it:query[x]){
        auto pos=query[y].upper_bound(it);
        if(pos != query[y].begin())
            pos=prev(pos);
        if(*pos == it){
            ans[it]=val;
            query[y].erase(pos);
            cates[y]--;
            continue;
        }
        cates[y]++;
        query[y].insert(it);
    }
    query[x].clear();
}