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

using namespace std;

void minimMaxim(vector<vector<int>> const &a, int A, int B, vector<vector<int>> &mncol, vector<vector<int>> &mxcol) {
    int N = a.size();
    int M = a[0].size();

    vector<vector<int>> mxln(N, vector<int>(M));
    vector<vector<int>> mnln(N, vector<int>(M));
    for(int i=0; i<N; ++i) {
        deque<int> mn, mx;
        for(int j=0; j<A-1; ++j) {
            while(!mn.empty() && a[i][mn.back()] >= a[i][j]) {
                mn.pop_back();
            }
            mn.push_back(j);
            
            while(!mx.empty() && a[i][mx.back()] <= a[i][j]) {
                mx.pop_back();
            }
            mx.push_back(j);
        }
        for(int j=A-1; j<M; ++j) {
            if(!mn.empty() && mn.front() <= j - A) {
                mn.pop_front();
            }
            while(!mn.empty() && a[i][mn.back()] >= a[i][j]) {
                mn.pop_back();
            }
            mn.push_back(j);

            if(!mx.empty() && mx.front() <= j - A) {
                mx.pop_front();
            }
            while(!mx.empty() && a[i][mx.back()] <= a[i][j]) {
                mx.pop_back();
            }
            mx.push_back(j);

            mnln[i][j] = a[i][mn.front()];
            mxln[i][j] = a[i][mx.front()];
        }
    }

    for(int j=0; j<M; ++j) {
        deque<int> mn, mx;
        for(int i=0; i<B-1; ++i) {
            while(!mn.empty() && mnln[mn.back()][j] >= mnln[i][j]) {
                mn.pop_back();
            }
            mn.push_back(i);
            
            while(!mx.empty() && mxln[mx.back()][j] <= mxln[i][j]) {
                mx.pop_back();
            }
            mx.push_back(i);
        }
        for(int i=B-1; i<N; ++i) {
            if(!mn.empty() && mn.front() <= i - B) {
                mn.pop_front();
            }
            while(!mn.empty() && mnln[mn.back()][j] >= mnln[i][j]) {
                mn.pop_back();
            }
            mn.push_back(i);

            if(!mx.empty() && mx.front() <= i - B) {
                mx.pop_front();
            }
            while(!mx.empty() && mxln[mx.back()][j] <= mxln[i][j]) {
                mx.pop_back();
            }
            mx.push_back(i);

            mncol[i][j] = mnln[mn.front()][j];
            mxcol[i][j] = mxln[mx.front()][j];
        }
    }
}

int main() {
    ifstream fin("struti.in");
    ofstream fout("struti.out");
    int N, M, P;
    fin >> N >> M >> P;
    vector<vector<int>> a(N, vector<int>(M));
    for(int i=0; i<N; ++i) {
        for(int j=0; j<M; ++j) {
            fin >> a[i][j];
        }
    }
    for(int p=0; p<P; ++p) {
        int A, B;
        fin >> A >> B;

        vector<vector<int>> mx(N, vector<int>(M));
        vector<vector<int>> mn(N, vector<int>(M));

        int diferenta = std::numeric_limits<int>::max(), aparitii = 0;

        minimMaxim(a, A, B, mn, mx);

        for(int i=B-1; i<N; ++i) {
            for(int j=A-1; j<M; ++j) {
                if(diferenta > mx[i][j] - mn[i][j]) {
                    aparitii = 0;
                    diferenta = mx[i][j] - mn[i][j];
                }
                if(diferenta == mx[i][j] - mn[i][j]) {
                    ++aparitii;
                }
            }
        }

        if(A != B) {
            minimMaxim(a, B, A, mn, mx);
            
            for(int i=A-1; i<N; ++i) {
                for(int j=B-1; j<M; ++j) {
                    if(diferenta > mx[i][j] - mn[i][j]) {
                        aparitii = 0;
                        diferenta = mx[i][j] - mn[i][j];
                    }
                    if(diferenta == mx[i][j] - mn[i][j]) {
                        ++aparitii;
                    }
                }
            }
        }

        fout << diferenta << ' ' << aparitii << '\n';
    }
    return 0;
}