#include <utility>
#include <vector>
#include <fstream>
#include <deque>
#include <functional>
#include <numeric>

using namespace std;
using Matrix = vector<vector<int>>;
using Vector = vector<int>;

int n, m;

class Deque {
private:
    using Comparator = function<bool(int, int)>;
    deque<pair<int, int>> Q;
    int k;
    Comparator comparator;
public:
    Deque(Comparator comparator, int k) : comparator(std::move(comparator)), k(k) {};

    void add(const int &p, const int &val) {
        while (!Q.empty() && comparator(val, Q.back().first))
            Q.pop_back();

        Q.emplace_back(val, p);
        if (!Q.empty() && Q.front().second == p - k)
            Q.pop_front();
    }

    [[nodiscard]] int getFront() const {
        return Q.front().first;
    }
};

pair<int, int> solve(const int &x, const int &y, const Matrix &mat) {
    vector<vector<int>> amaxi(n, Vector(m)), amini(n, Vector(m));

    for (int j = 0; j < m; ++j) {
        Deque Max((greater_equal<>()), x);
        Deque Min((less_equal<>()), x);

        for (int i = 0; i < n; ++i) {
            Max.add(i, mat[i][j]);
            Min.add(i, mat[i][j]);

            if (i >= x - 1) {
                amaxi[i][j] = Max.getFront();
                amini[i][j] = Min.getFront();
            }
        }
    }


    int minim = numeric_limits<int>::max(), cnt = 0;
    for (int i = x - 1; i < n; ++i) {

        Deque Max((greater_equal<>()), y);
        Deque Min((less_equal<>()), y);

        for (int j = 0; j < m; ++j) {
            Max.add(j, amaxi[i][j]);
            Min.add(j, amini[i][j]);

            if (j >= y - 1) {
                int diff = Max.getFront() - Min.getFront();

                if (diff == minim) {
                    ++cnt;
                } else if (diff < minim) {
                    minim = diff;
                    cnt = 1;
                }
            }
        }
    }

    return {minim, cnt};
}

int main() {
    ifstream f("struti.in");
    ofstream g("struti.out");

    int t;
    f >> n >> m >> t;

    Matrix mat(n, Vector(m));
    for (auto &it: mat) {
        for (auto &it2: it) {
            f >> it2;
        }
    }

    while (t--) {
        int a, b;
        f >> a >> b;
        auto ans = solve(a, b, mat);
        if (b != a) {
            auto ans2 = solve(b, a, mat);

            if (ans.first == ans2.first)
                ans.second += ans2.second;
            else if (ans2.first < ans.first)
                ans = std::move(ans2);
        }

        g << ans.first << ' ' << ans.second << '\n';
    }
}