#include <fstream>

#define INF 10000
#define DIM 1005

using namespace std;

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

int mat[DIM][DIM] , dmn[DIM][DIM] , dmx[DIM][DIM] , smin[DIM][DIM] , smax[DIM][DIM];
int dq[DIM];

int n , m , p , ans , nr;


void solve (int dx , int dy) {
    for (int i = 1; i <= n; ++i) {
        int dr = 1 , st = 1;
        dmn[i][1] = -INF;
        dq[1] = 1;

        for (int j = 2; j <= dx; ++j) {
            ++dr;
            int k = dr - 1;

            while (k > 0 && mat[i][j] <= mat[i][dq[k]]) {
                --k;
            }

            dr = k + 1;
            dq[dr] = j;

            dmn[i][j] = -INF;
        }

        dmn[i][dx] = mat[i][dq[st]];
        for (int j = dx + 1; j <= m; ++j) {
            while (dq[st] < j - dx + 1) {
                ++st;
            }

            int k = dr;
            while (k >= st && mat[i][j] <= mat[i][dq[k]]) {
                --k;
            }

            dr = k + 1;
            dq[dr] = j;

            dmn[i][j] = mat[i][dq[st]];
        }
    }

    for (int i = 1; i <= n; ++i) {
        int dr = 1 , st = 1;
        dmx[i][1] = INF;
        dq[1] = 1;

        for (int j = 2; j <= dx; ++j) {
            ++dr;
            int k = dr - 1;

            while (k > 0 && mat[i][j] >= mat[i][dq[k]]) {
                --k;
            }

            dr = k + 1;
            dq[dr] = j;

            dmx[i][j] = INF;
        }

        dmx[i][dx] = mat[i][dq[st]];
        for (int j = dx + 1; j <= m; ++j) {
            while (dq[st] < j - dx + 1) {
                ++st;
            }

            int k = dr;
            while (k >= st && mat[i][j] >= mat[i][dq[k]]) {
                --k;
            }

            dr = k + 1;
            dq[dr] = j;

            dmx[i][j] = mat[i][dq[st]];
        }
    }

    for (int j = 1; j <= m; ++j) {
        int dr = 1 , st = 1;
        smin[1][j] = -INF;
        dq[1] = 1;

        for (int i = 2; i <= dy; ++i) {
            ++dr;
            int k = dr - 1;

            while (k > 0 && dmn[i][j] <= dmn[dq[k]][j]) {
                --k;
            }

            dr = k + 1;
            dq[dr] = i;

            smin[i][j] = -INF;
        }

        smin[dy][j] = dmn[dq[st]][j];
        for (int i = dy + 1; i <= n; ++i) {
            while (dq[st] < i - dy + 1) {
                ++st;
            }

            int k = dr;
            while (k >= st && dmn[i][j] <= dmn[dq[k]][j]) {
                --k;
            }

            dr = k + 1;
            dq[dr] = i;

            smin[i][j] = dmn[dq[st]][j];
        }
    }

    for (int j = 1; j <= m; ++j) {
        int dr = 1 , st = 1;
        smax[1][j] = INF;
        dq[1] = 1;

        for (int i = 2; i <= dy; ++i) {
            ++dr;
            int k = dr - 1;

            while (k > 0 && dmx[i][j] >= dmx[dq[k]][j]) {
                --k;
            }

            dr = k + 1;
            dq[dr] = i;

            smax[i][j] = INF;
        }

        smax[dy][j] = dmx[dq[st]][j];
        for (int i = dy + 1; i <= n; ++i) {
            while (dq[st] < i - dy + 1) {
                ++st;
            }

            int k = dr;
            while (k >= st && dmx[i][j] >= dmx[dq[k]][j]) {
                --k;
            }

            dr = k + 1;
            dq[dr] = i;

            smax[i][j] = dmx[dq[st]][j];
        }
    }

    for (int i = 1; i <= n; ++i) {
        for (int j = 1; j <= m; ++j) {
            int aux = smax[i][j] - smin[i][j];
            if (aux == ans) {
                ++nr;
            }

            if (aux < ans) {
                ans = aux;
                nr = 1;
            }
        }
    }
}

int main() {
    f >> n >> m >> p;
    for (int i = 1; i <= n; ++i) {
        for (int j = 1; j <= m; ++j) {
            f >> mat[i][j];
        }
    }

    int x , y;
    for (int i = 1; i <= p; ++i) {
        f >> x >> y;

        ans = INF , nr = 0;
        solve (x , y);

        if (x != y)
            solve (y , x);

        g << ans << " " << nr << '\n';
    }

    return 0;
}