#include <fstream>
#include <deque>

using namespace std;

#define inf 9999

    int v[1002][1002];
    int matrice_min[1002][1002];
    int matrice_max[1002][1002];

    deque <int> coada_min;
    deque <int> coada_max;
    deque <int> coada_min_f;
    deque <int> coada_max_f;

    int h_max=inf,cate=0;
    int n,m;

    void prelucreaza(int dx,int dy)
    {
        int j,k;
        for(j=0;j<n;j++)
        {
            for(k=0;k<m;k++)
            {
                //////////////////////////////////////////////////min
                //Etapa micsorativa
                while(!coada_min.empty())
                    if((k-coada_min.front())>=dx)
                        coada_min.pop_front();
                    else
                        break;

                while(!coada_min.empty())
                    if(v[j][coada_min.back()]>=v[j][k])
                        coada_min.pop_back();
                    else
                        break;
                coada_min.push_back(k);

                //////////////////////////////////////////////max

                //Etapa micsorativa
                while(!coada_max.empty())
                    if((k-coada_max.front())>=dx)
                        coada_max.pop_front();
                    else
                        break;
                while(!coada_max.empty())
                    if(v[j][coada_max.back()]<=v[j][k])
                        coada_max.pop_back();
                    else
                        break;
                coada_max.push_back(k);
                if(k+1>=dx)
                {
                    matrice_min[j][k+1-dx]=v[j][coada_min.front()];
                    matrice_max[j][k+1-dx]=v[j][coada_max.front()];
                }
            }
            while(!coada_min.empty())
                coada_min.pop_front();
            while(!coada_max.empty())
                coada_max.pop_front();
        }

        for(j=0;j<=(m-dx);j++)
        {
            for(k=0;k<n;k++)
            {
                /////////////////////////////////////////////////////////////////
                //////////////////////////////////////////////////min
                //Etapa micsorativa
                while(!coada_min_f.empty())
                    if((k-coada_min_f.front())>=dy)
                        coada_min_f.pop_front();
                    else
                        break;

                while(!coada_min_f.empty())
                    if(matrice_min[coada_min_f.back()][j]>=matrice_min[k][j])
                        coada_min_f.pop_back();
                    else
                        break;
                coada_min_f.push_back(k);

                //////////////////////////////////////////////////max
                //Etapa micsorativa
                while(!coada_max_f.empty())
                    if((k-coada_max_f.front())>=dy)
                        coada_max_f.pop_front();
                    else
                        break;

                while(!coada_max_f.empty())
                    if(matrice_max[coada_max_f.back()][j]<=matrice_max[k][j])
                        coada_max_f.pop_back();
                    else
                        break;
                coada_max_f.push_back(k);

                if(k+1>=dy)
                {
                    if((matrice_max[coada_max_f.front()][j]-matrice_min[coada_min_f.front()][j])<h_max)
                    {
                        h_max=(matrice_max[coada_max_f.front()][j]-matrice_min[coada_min_f.front()][j]);
                        cate=1;
                    }
                    else if((matrice_max[coada_max_f.front()][j]-matrice_min[coada_min_f.front()][j])==h_max)
                        cate++;
                }
            }
            while(!coada_min_f.empty())
                coada_min_f.pop_front();
            while(!coada_max_f.empty())
                coada_max_f.pop_front();
        }
    }

int main()
{
    ifstream cin("struti.in");
    ofstream cout("struti.out");

    int p,i,j,dx,dy;
    cin>>n>>m>>p;

    for(i=0;i<n;i++)
        for(j=0;j<m;j++)
            cin>>v[i][j];

    for(i=0;i<p;i++)
    {
        h_max=inf;
        cate=0;
        cin>>dx>>dy;
        prelucreaza(dx,dy);
        if(dx!=dy)
            prelucreaza(dy,dx);
        cout<<h_max<<' '<<cate<<endl;
    }
    cin.close();
    cout.close();
    return 0;
}