#include <fstream>
#include <algorithm>
#include <queue>
#include <bitset>

class InParser
{
#pragma warning(disable:4996)
private:
    FILE* fin;
    char* buff;
    int sp;
    char read()
    {
        ++sp;
        if (sp == 4096)
        {
            sp = 0;
            fread(buff, 1, 4096, fin);
        }
        return buff[sp];
    }
public:
    InParser(const char* nume)
    {
        sp = 4095;
        buff = new char[4096];
        fin = fopen(nume, "r");
    }
    InParser& operator >> (int& n)
    {
        int sgn = 1;
        char c;
        while (!isdigit(c = read()) && c != '-');
        if (c == '-')
        {
            n = 0;
            sgn = -1;
        }
        else
            n = c - '0';
        while (isdigit(c = read()))
            n = n * 10 + c - '0';
        n *= sgn;
        return *this;
    }
};

InParser fin("matrice2.in");
std::ofstream fout("matrice2.out");

const int NMAX = 301;

int n, q, X1, Y1, X2, Y2, a[NMAX][NMAX];

std::bitset <NMAX> used[NMAX];

inline bool inside(int x, int y)
{
    return x && y && x <= n && y <= n && used[x][y] == 0;
}

typedef std::pair <int, int> p;

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

bool solve(int val)
{
    for (int i = 1; i <= n; ++i)
        used[i].reset();
    
    std::queue <p> q;
    q.push({ X1, Y1 });

    while (!q.empty())
    {
        p crt = q.front();
        
        if (crt.first == X2 && crt.second == Y2)
            return 1;

        q.pop();
        
        used[crt.first][crt.second] = 1;

        for (int i = 0; i < 4; ++i)
        {
            int nx = crt.first + dx[i], ny = crt.second + dy[i];
            if (inside(nx, ny) && a[nx][ny] >= val)
            {
                q.push({ nx, ny });
                used[nx][ny] = 1;
            }
        }
    }
    
    return 0;
}

int binarySearch(int dr)
{
    int res = 0, st = 0;

    while (st <= dr)
    {
        int mid = (st + dr) >> 1;

        if (solve(mid))
        {
            if (mid > res)
                res = mid;
            st = mid + 1;
        }

        else
            dr = mid - 1;
    }
    return res;
}

int main()
{
    fin >> n >> q;
    for (int i = 1; i <= n; ++i)
        for (int j = 1; j <= n; ++j)
            fin >> a[i][j];

    while (q--)
    {
        fin >> X1 >> Y1 >> X2 >> Y2;
        fout << binarySearch(std::min(a[X1][Y1], a[X2][Y2])) << "\n";
    }

	fout.close();
	return 0;
}