#include <fstream>
#include <map>
#include <vector>
#include <algorithm>
#include <functional>
#include <limits>

using namespace std;


int main()
{
	ifstream cin("struti.in");
	ofstream cout("struti.out");
	int M, N, P;
	cin >> M >> N >> P;
	vector< vector<short> > height(M, vector<short>(N));
	vector<int> LOG2(1 << 10, 0);
	static vector<short> rmq[2][10][1 << 10];
	for (int i = 2; i < (1 << 10); i++) {
		LOG2[i] = LOG2[i >> 1] + 1;
	}

	for (int i = 0; i < 10; i++) {
	for (int k = 0; k <= M;k++) {
			rmq[0][i][k].resize(N + 1, numeric_limits<short> ::max());
			rmq[1][i][k].resize(N + 1, 0);
		}
	}

	for (int i = 0; i < M; i++) {
		for (int j = 0; j < N; j++) {
			cin >> height[i][j];
			for (int p = 0; p < 2; p++) {
				rmq[p][0][i + 1][j + 1] = height[i][j];

			}
		}
	}

	vector< function< short(short, short) > > f;
	f.push_back([](const short &a, const short &b) { return a < b ? a : b; });
	f.push_back([](const short &a, const short &b) { return a > b ? a : b; });

	for (int p = 0; p < 2; p++) {
		for (int i = 1; (1 << i) <= N; i++) {
			for (int k = 1; k <= M; k++) {
				for (int w = 1; w <= N - (1 << i) + 1; w++) {
					rmq[p][i][k][w] = f[p](rmq[p][i - 1][k][w],rmq[p][i - 1][k][w + (1 << (i - 1))]);
				}
			}
		}
	}


	auto query = [&](int p, int a, int b, int c, int d) {
		int l = LOG2[d - b + 1];
		short ret = p == 0 ? numeric_limits<short> :: max() : numeric_limits<short> ::min();
		for (int i = a; i <= c; i++) {
			ret = f[p](ret, f[p](rmq[p][l][i][b], rmq[p][l][i][d - (1 << l) + 1]));
		}

		return ret;
	};

	for (int t = 1; t <= P; t++) {
		int d[2];
		cin >> d[0] >> d[1];
		int zoneCount = 0;
		int ans = numeric_limits<int> ::max();
		int dmax;
		for (int i = 1; i <= M; i++) {
			for (int j = 1; j <= N; j++) {
				if (i >= d[0] && j >= d[1]) {
					dmax = query(1, i - d[0] + 1, j - d[1] + 1, i, j) - query(0, i - d[0] + 1, j - d[1] + 1, i, j);
					if (dmax < ans) {
						ans = dmax;
						zoneCount = 1;
					}
					else
					if (dmax == ans) {
						zoneCount++;
					}
				}

				if (d[0] != d[1] && i >= d[1] && j >= d[0]) {
					dmax = query(1, i - d[1] + 1, j - d[0] + 1, i, j) - query(0, i - d[1] + 1, j - d[0] + 1, i, j);
					if (dmax < ans) {
						ans = dmax;
						zoneCount = 1;
					}
					else
					if (dmax == ans) {
						zoneCount++;
					}
				}
			}
		}

		cout << ans << " " << zoneCount << "\n";
	}
	return 0;
}