#include <vector>
#include <list>
#include <map>
#include <set>
#include <deque>
#include <queue>
#include <stack>
#include <bitset>
#include <algorithm>
#include <functional>
#include <numeric>
#include <utility>
#include <sstream>
#include <iostream>
#include <iomanip>
#include <cstdio>
#include <cmath>
#include <cstdlib>
#include <cctype>
#include <string>
#include <cstring>
#include <cstdio>
#include <cmath>
#include <cstdlib>
#include <ctime>
#include <fstream>
#include <iterator>
#include <random>
#include <assert.h>
using namespace std;


const string file = "struti";

const string infile = file + ".in";
const string outfile = file + ".out";

const int INF = 0x3f3f3f3f;


bool asc(int a, int b)
{
	return a < b;
}

bool desc(int a, int b)
{
	return a > b;
}

template <class P>
void update(deque<pair<int, int> >& deck, int index, int K, int element, P pred)
{

	while(deck.size() > 0 && pred(deck.back().first, element))
	{
		deck.pop_back();
	}

	while(deck.size() > 0 && deck.front().second <= index - K)
	{
		deck.pop_front();
	}

	deck.push_back(make_pair(element, index));

}


void Solve(int dx, int dy, int& mini, int& nr, int N, int M, vector<vector<int> >& A)
{

	vector<vector<pair<int, int> > > D;
	D.resize(N, vector<pair< int, int> >(M - dy + 1));

	
	deque<pair<int, int> > dMax;
	deque<pair<int, int> > dMin;

	for(int i = 0; i < N; i++)
	{
		dMax.clear();
		dMin.clear();
		for(int j = 0; j < M; j++)
		{
			update(dMax, j, dy, A[i][j], asc);
			update(dMin, j, dy, A[i][j], desc);

			if(j >= dy - 1)
			{
				D[i][j - dy + 1].first = dMax.front().first;
				D[i][j - dy + 1].second = dMin.front().first;

			}

		}
	}


	mini = INF;

	for(int j = 0; j < M - dy + 1; j++)
	{
		dMax.clear();
		dMin.clear();

		for(int i = 0; i < N; i++)
		{
			update(dMax, i, dx, D[i][j].first, asc);
			update(dMin, i, dx, D[i][j].second, desc);

			if(i >= dx - 1)
			{
				D[i - dx + 1][j].first = dMax.front().first;
				D[i - dx + 1][j].second = dMin.front().first;

				if(D[i - dx + 1][j].first - D[i - dx + 1][j].second < mini)
				{
					mini = D[i - dx + 1][j].first - D[i - dx + 1][j].second;
					nr = 1;
				}
				else if( D[i -dx + 1][j].first - D[i - dx + 1][j].second == mini)
				{
					nr++;
				}
			}
		}
	}

}

int main()
{
#ifdef ONLINE_JUDGE
	ostream &fout = cout;
	istream &fin = cin;
#else
	fstream fout(outfile.c_str(), ios::out);
	fstream fin(infile.c_str(), ios::in);
#endif	


	int N, M, P;
	fin >> N >> M >> P;
	vector<vector<int> > A;
	A.resize(N, vector<int>(M, 0));
	for(int i = 0; i < N; i++)
	{
		for(int j = 0; j < M; j++)
		{
			fin >> A[i][j];
		}
	}

	for(int i = 0; i < P; i++)
	{
		int dx, dy;
		fin >> dx >> dy;

		int mini;
		int nr;

		Solve(dx, dy, mini, nr, N, M, A);

		if(dx != dy)
		{

			int mini2;
			int nr2;

			Solve(dy, dx, mini2, nr2, N, M, A);
			if(mini == mini2)
			{
				nr += nr2;
			}
			else if(mini2 < mini)
			{
				mini = mini2;
				nr = nr2;
			}
		}


		fout << mini << " " << nr << "\n";
	}

#ifdef ONLINE_JUDGE
#else

	fin.close();
	fout.close();
#endif
}