#include <fstream>
#include <iostream>
#include <cstdlib>
 
#define nullptr NULL
 
using namespace std;
 
typedef unsigned char uint8;
     
template<uint8 N, char prev>
struct LookupTable;
 
template<char prev>
struct LookupTable<255, prev>
{
    LookupTable() :
        value(prev)
    {}
    char value;
};
 
template<uint8 N, char prev>
struct LookupTable
{
    LookupTable() :
        value(prev)
    {}
 
    char value;
    LookupTable<N+1, prev + (((N+1) & N) == 0)> next;
};
 
template<char prev>
struct LookupTable<0, prev>
{
    LookupTable() :
        value(prev)
    {}
    char value;
    LookupTable<1, 0> next;
};
 
class Log2Helper
{
public:
 
    static int Log2Of(int n)
    {
        /*if (ptr[n >> 24] > -1)
        {
            return ptr[n >> 24] + 24;
        }
        else if (ptr[n >> 16] > -1)
        {
            return ptr[n >> 16] + 16;
        }
        else*/ if (ptr[n >> 8] > -1)
        {
            return ptr[n >> 8] + 8;
        }
         
        return ptr[n];
    }
 
    static LookupTable<0, -1> Log2LookupTable;
    static char* ptr;
};
 
LookupTable<0, -1> Log2Helper::Log2LookupTable;
char* Log2Helper::ptr = reinterpret_cast<char*>(&Log2LookupTable);
 
class CMatrixNxN
{
public:
 
    CMatrixNxN(int n) :
        m_iSize(n),
        m_pRawMatrix(new int[n*n])
    {}
     
    CMatrixNxN(const CMatrixNxN& other, int skipAhead)
    {
        m_iSize = other.size() - skipAhead;
         
        m_pRawMatrix = new int[m_iSize*m_iSize];
         
        for (int i=0; i<m_iSize; ++i)
        {
            for (int j=0; j<m_iSize; ++j)
            {
                (*this)[i][j] = std::max(std::max(other[i][j], other[i][j+skipAhead]),
                                         std::max(other[i+skipAhead][j], other[i+skipAhead][j+skipAhead]));
            }
        }
    }
     
    int* operator [] (int index)
    {
        return &m_pRawMatrix[index * m_iSize];
    }
     
    const int* operator [] (int index) const
    {
        return &m_pRawMatrix[index * m_iSize];
    }
     
    int size() const
    {
        return m_iSize;
    }
     
    ~CMatrixNxN()
    {
        if (m_pRawMatrix != nullptr)
        {
            delete m_pRawMatrix;
        }
    }
     
    void print() const
    {
        for (int i=0; i<m_iSize; ++i)
        {
            for (int j=0; j<m_iSize; ++j)
            {
                cout << (*this)[i][j] << " ";
            }
            cout << endl;
        }
    }
     
private:
    int m_iSize;
    int *m_pRawMatrix;
};
 
typedef CMatrixNxN* PCMatrixNxN;
 
int Query(const PCMatrixNxN* vppPlantation, int row, int col, int size)
{
    const int log2OfSize = Log2Helper::Log2Of(size);
     
    int max1 = std::max((*vppPlantation[log2OfSize])[row][col], (*vppPlantation[log2OfSize])[row][col + size - (1<<log2OfSize)]);
    int max2 = std::max((*vppPlantation[log2OfSize])[row + size - (1<<log2OfSize)][col], (*vppPlantation[log2OfSize])[row + size - (1<<log2OfSize)][col + size - (1<<log2OfSize)]);
     
    return std::max(max1, max2);
}
 
int main()
{
    int n, m;
    fstream fin("plantatie.in", fstream::in);
    fstream fout("plantatie.out", fstream::out);
     
    fin >> n >> m;
    //cout << n << " " << m << endl;
     
    PCMatrixNxN* vppPlantation = new PCMatrixNxN[Log2Helper::Log2Of(n) + 1];
 
    vppPlantation[0] = new CMatrixNxN(n);
     
    for (int i=0; i<n; ++i)
    {
        for (int j=0; j<n; ++j)
        {
            fin >> (*vppPlantation[0])[i][j];
             
            //cout << (*vppPlantation[0])[i][j] << " ";
        }
        //cout << endl;
    }
    //cout << endl;
 
    for (int i=1; (1<<i)<=n; ++i)
    {
        vppPlantation[i] = new CMatrixNxN(*vppPlantation[i-1], 1<<(i-1));
        //vppPlantation[i]->print();
        //cout << endl;
    }
     
    for (int i=0; i<m; ++i)
    {
        int row, col, size;
        fin >> row >> col >> size;
         
        //cout << row-1 << " " << col-1 << " " << size << endl;
        fout << Query(vppPlantation, row-1, col-1, size) << "\n";
    }
     
    /*for (int i=0; i<256; ++i)
    {
        cout << i << "  " << Log2Helper::Log2Of(i) << endl;
    }*/
    return 0;
}