/* 
 * 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)
{   
    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;
            }
        }
    }
    
    if(dx == dy) nr >>= 1;
    
    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;
}