#include <bits/stdc++.h>
#define INF 0x3f3f3f3f

using namespace std;

class InParser {
private:
    FILE *fin;
    char *buff;
    int sp;

    char read_ch() {
        ++sp;
        if (sp == 4096) {
            sp = 0;
            fread(buff, 1, 4096, fin);
        }
        return buff[sp];
    }

public:
    InParser(const char* nume) {
        fin = fopen(nume, "r");
        buff = new char[4096]();
        sp = 4095;
    }

    InParser& operator >> (int &n) {
        char c;
        while (!isdigit(c = read_ch()) && c != '-');
        int sgn = 1;
        if (c == '-') {
            n = 0;
            sgn = -1;
        } else {
            n = c - '0';
        }
        while (isdigit(c = read_ch())) {
            n = 10 * n + c - '0';
        }
        n *= sgn;
        return *this;
    }
};

InParser fin("struti.in");
ofstream fout("struti.out");

const int NMAX = 1001;
int N, M, Q, a[NMAX][NMAX], n, m, dif_min, cnt, maxA[NMAX][NMAX], minA[NMAX][NMAX];

void solve() {
    deque<int> maxQ, minQ;
    for(int j = 1; j <= M; ++j) {
        maxQ.clear(), minQ.clear();
        for(int i = 1; i <= N; ++i) {
            if(!maxQ.empty() && maxQ.front() == i - n)
                maxQ.pop_front();
            if(!minQ.empty() && minQ.front() == i - n)
                minQ.pop_front();
            while(!maxQ.empty() && a[maxQ.back()][j] <= a[i][j])
                maxQ.pop_back();
            while(!minQ.empty() && a[minQ.back()][j] >= a[i][j])
                minQ.pop_back();
            maxQ.emplace_back(i), minQ.emplace_back(i);
            maxA[i][j] = a[maxQ.front()][j], minA[i][j] = a[minQ.front()][j];
        }
    }
    for(int i = n; i <= N; ++i) {
        maxQ.clear(), minQ.clear();
        for(int j = 1; j <= M; ++j) {
            if(!maxQ.empty() && maxQ.front() == j - m)
                maxQ.pop_front();
            if(!minQ.empty() && minQ.front() == j - m)
                minQ.pop_front();
            while(!maxQ.empty() && maxA[i][maxQ.back()] <= maxA[i][j])
                maxQ.pop_back();
            while(!minQ.empty() && minA[i][minQ.back()] >= minA[i][j])
                minQ.pop_back();
            maxQ.emplace_back(j), minQ.emplace_back(j);
            if(j >= m) {
                int dif = maxA[i][maxQ.front()] - minA[i][minQ.front()];
                if(dif < dif_min) {
                    dif_min = dif;
                    cnt = 1;
                }
                else
                    if(dif == dif_min)
                        ++cnt;
            }
        }
    }
}

int main() {
    fin >> N >> M >> Q;
    for(int i = 1; i <= N; ++i)
        for(int j = 1; j <= M; ++j)
            fin >> a[i][j];
    while(Q--) {
        fin >> n >> m;
        dif_min = INF, cnt = 0;
        solve();
        if(n != m) {
            swap(n, m);
            solve();
        }
        fout << dif_min << ' ' << cnt << '\n';
    }
}