#include <iostream>
#include <fstream>
#include <vector>
#include <deque>
#include <algorithm>

using namespace std;

const int MAX = 1005;
int M, N, P;
int grid[MAX][MAX];
int rowMin[MAX][MAX], rowMax[MAX][MAX];

struct Result {
    int val, count;
};

Result compute(int DX, int DY) {

    for (int i = 1; i <= M; ++i) {
        deque<int> dqMin, dqMax;
        for (int j = 1; j <= N; ++j) {
            while (!dqMin.empty() && grid[i][dqMin.back()] >= grid[i][j]) dqMin.pop_back();
            while (!dqMax.empty() && grid[i][dqMax.back()] <= grid[i][j]) dqMax.pop_back();
            dqMin.push_back(j);
            dqMax.push_back(j);
            
            if (dqMin.front() <= j - DY) dqMin.pop_front();
            if (dqMax.front() <= j - DY) dqMax.pop_front();
            
            if (j >= DY) {
                rowMin[i][j] = grid[i][dqMin.front()];
                rowMax[i][j] = grid[i][dqMax.front()];
            }
        }
    }

    int minDiff = 2000000000;
    int count = 0;

    for (int j = DY; j <= N; ++j) {
        deque<int> dqMin, dqMax;
        for (int i = 1; i <= M; ++i) {
            while (!dqMin.empty() && rowMin[dqMin.back()][j] >= rowMin[i][j]) 
                dqMin.pop_back();
            while (!dqMax.empty() && rowMax[dqMax.back()][j] <= rowMax[i][j]) 
                dqMax.pop_back();
            dqMin.push_back(i);
            dqMax.push_back(i);
            
            if (dqMin.front() <= i - DX) 
                dqMin.pop_front();
            if (dqMax.front() <= i - DX) 
                dqMax.pop_front();

            if (i >= DX) {
                int diff = rowMax[dqMax.front()][j] - rowMin[dqMin.front()][j];

                if (diff < minDiff) {
                    minDiff = diff;
                    count = 1;
                } else if (diff == minDiff) {
                    count++;
                }
            }
        }
    }
    return {minDiff, count};
}

int main() {
    ifstream fin("struti.in");
    ofstream fout("struti.out");

    if (!(fin >> M >> N >> P)) return 0;

    for (int i = 1; i <= M; ++i)
        for (int j = 1; j <= N; ++j)
            fin >> grid[i][j];

    while (P--) {
        int dx, dy;
        fin >> dx >> dy;

        Result res = compute(dx, dy);

        if (dx != dy) {
            Result resRotated = compute(dy, dx);
            
            if (resRotated.val < res.val) {
                res = resRotated;
            } else if (resRotated.val == res.val) {
                res.count += resRotated.count;
            }
        }

        fout << res.val << " " << res.count << "\n";
    }

    return 0;
}