/* 
 * File:   struti.cpp
 * Author: mindyou
 *
 * Created on December 11, 2011, 12:38 PM
 */

#include <cstdio>
#include <vector>

using namespace std;

class deque
{
protected:
    int* D;
    int* time;
    int b, e;
public:
    deque() : b(0), e(0), D(NULL), time(NULL)
    {
    }
    
    void initialize(int N)
    {
        if(D == NULL && time == NULL)
        {
                D = new int[N];
                time = new int[N];
        }
        b = e = 0;
    }
    
    ~deque()
    {
        delete D;
        delete time;
    }
    
    virtual void insert(int val, int time) = 0;
    
    void delete_elem(int time)
    {
        while(b < e && this->time[b] <= time) b++;
    }
    
    int get_lowest()
    {
        if(b < e) return D[b];
        else return -1;
    }
    
    void clear()
    {
        b = e = 0;
    }
};

class min_deque: public deque
{
public:
    void insert(int val, int time)
    {
        while(e > b && D[e - 1] > val) e--;
        
        D[e] = val;
        this->time[e] = time;
        e++;
    }
};

class max_deque: public deque
{
public:
    void insert(int val, int time)
    {
        while(e > b && D[e - 1] < val) e--;
        
        D[e] = val;
        this->time[e] = time;
        e++;
    }
};

const int NMAX = 1000;
int N, M, P;
int A[NMAX][NMAX];

min_deque min_d1[NMAX], min_d2[NMAX];
max_deque max_d1[NMAX], max_d2[NMAX]; 

void solve(int dx, int dy)
{   
    if(dx != dy)
    {
        for(int i = 0; i < M; i++)
        {
                min_d1[i].initialize(N);
                max_d1[i].initialize(N);
                min_d2[i].initialize(N);
                max_d2[i].initialize(N);
        }
    
        min_deque hor_min_d1, hor_min_d2;
        hor_min_d1.initialize(M);
        hor_min_d2.initialize(M);
        max_deque hor_max_d1, hor_max_d2;
        hor_max_d1.initialize(M);
        hor_max_d2.initialize(M);

        int global_min = 8000;
        int nr = 0;

        for(int i = 0; i < N; i++)
        {
            hor_min_d1.clear();
            hor_max_d1.clear();
            hor_min_d2.clear();
            hor_max_d2.clear();

            for(int j = 0; j < M; j++)
            {
                min_d1[j].delete_elem(i - dx);
                max_d1[j].delete_elem(i - dx);
                min_d2[j].delete_elem(i - dy);
                max_d2[j].delete_elem(i - dy);

                hor_min_d1.delete_elem(j - dy);
                hor_max_d1.delete_elem(j - dy);
                hor_min_d2.delete_elem(j - dx);
                hor_max_d2.delete_elem(j - dx);


                min_d1[j].insert(A[i][j], i);
                max_d1[j].insert(A[i][j], i);
                min_d2[j].insert(A[i][j], i);
                max_d2[j].insert(A[i][j], i);

                hor_min_d1.insert(min_d1[j].get_lowest(), j);
                hor_max_d1.insert(max_d1[j].get_lowest(), j);

                hor_min_d2.insert(min_d2[j].get_lowest(), j);
                hor_max_d2.insert(max_d2[j].get_lowest(), j);

                int a = hor_min_d1.get_lowest();
                int b = hor_max_d1.get_lowest();

                if(i - dx + 1 >= 0 && j - dy + 1 >= 0)
                {

                    if(b - a < global_min)
                    {
                            global_min = b - a;
                            nr = 1;
                        }
                        else if(b - a == global_min) nr++;
                        else;
                }
                a = hor_min_d2.get_lowest();
                b = hor_max_d2.get_lowest();

                if(i - dy + 1 >= 0 && j - dx + 1 >= 0)
                {

                    if(b - a < global_min)
                    {
                            global_min = b - a;
                            nr = 1;
                        }
                        else if(b - a == global_min) nr++;
                        else;
                }
            }
        }
        printf("%d %d\n", global_min, nr);
    }
    else
    {
        for(int i = 0; i < M; i++)
        {
                min_d1[i].initialize(N);
                max_d1[i].initialize(N);
        }
    
        min_deque hor_min_d1;
        hor_min_d1.initialize(M);
        max_deque hor_max_d1;
        hor_max_d1.initialize(M);

        int global_min = 8000;
        int nr = 0;

        for(int i = 0; i < N; i++)
        {
            hor_min_d1.clear();
            hor_max_d1.clear();

            for(int j = 0; j < M; j++)
            {
                min_d1[j].delete_elem(i - dx);
                max_d1[j].delete_elem(i - dx);

                hor_min_d1.delete_elem(j - dy);
                hor_max_d1.delete_elem(j - dy);


                min_d1[j].insert(A[i][j], i);
                max_d1[j].insert(A[i][j], i);

                hor_min_d1.insert(min_d1[j].get_lowest(), j);
                hor_max_d1.insert(max_d1[j].get_lowest(), j);


                int a = hor_min_d1.get_lowest();
                int b = hor_max_d1.get_lowest();

                if(i - dx + 1 >= 0 && j - dy + 1 >= 0)
                {

                    if(b - a < global_min)
                    {
                            global_min = b - a;
                            nr = 1;
                        }
                        else if(b - a == global_min) nr++;
                        else;
                }
            }
        }
        printf("%d %d\n", global_min, nr);
    }
    
    
}
/*
 * 
 */
int main(int argc, char** argv) {

    freopen("struti.in", "r", stdin);
    freopen("struti.out", "w", stdout);
    
    scanf("%d %d %d ", &N, &M, &P);
    for(int i = 0; i < N; i++)
        for(int j = 0; j < M; j++)
            scanf("%d ", &A[i][j]);
    
    for(int i = 0; i < P; i++)
    {
        int dx, dy;
        
        scanf("%d %d ", &dx, &dy);
         solve(dx, dy);
    }
    
    return 0;
}