#include<stdio.h>
#include<string.h>
#define N 1020

int v[N][N], n, m, a, b, k, minim, nr;

struct coord{int min,max;} sol[N][N];

void rezolva();

int main(){
int i, j;
    freopen("struti.in","r",stdin);
    freopen("struti.out","w",stdout);

    scanf("%d %d %d",&n ,&m, &k);
    for (i = 1; i <= n; i++)
        for (j = 1; j <= m; j++)
            scanf("%d ",&v[i][j]);
int minim1, nr1, aux;
    for ( ; k; k--){
        scanf("%d %d", &a, &b);

        minim = 100000; nr = 0;

        rezolva();

        nr1 = nr; minim1 = minim;

        if (a!=b){
            minim = 100000; nr = 0;
            aux = a; a = b; b = aux;

            rezolva();

            if (minim < minim1) minim1 = minim, nr1 = nr;
            else if (minim == minim1) nr1 += nr;
        }
        printf("%d %d\n", minim1, nr1);

    }

    return 0;
}

void rezolva(){
int i, j, dmin, dmax, smin, smax, dqmin[N], dqmax[N];

    memset(dqmin,0,sizeof(dqmin));
    memset(dqmax,0,sizeof(dqmax));
    memset(sol,0,sizeof(sol));
    for (i = 1; i <= n; i++){
            smin = 1; dmin = 1; dqmin[1] = 1;
            smax = 1; dmax = 1; dqmax[1] = 1;
            if (b==1){ sol[i][1].max = v[i][1];
                       sol[i][1].min = v[i][1];
                     }
            for (j = 2; j <= m; j++){
                    if (dqmin[smin] <= j-b && smin <= dmin) smin++;
                    if (dqmax[smax] <= j-b && smax <= dmax) smax++;
                for ( ; v[i][dqmax[dmax]] <= v[i][j] && smax <= dmax; dmax--);
                for ( ; v[i][dqmin[dmin]] >= v[i][j] && smin <= dmin; dmin--);

                dqmin[++dmin] = j;
                dqmax[++dmax] = j;

                if (j >= b) sol[i][j].max = v[i][dqmax[smax]],
                            sol[i][j].min = v[i][dqmin[smin]];
            }
    }

    memset(dqmin,0,sizeof(dqmin));
    memset(dqmax,0,sizeof(dqmax));

    for (j = b; j <= m; j++){
        smin = 1; dmin = 1; dqmin[1] = 1;
        smax = 1; dmax = 1; dqmax[1] = 1;
        if (a==1){
                    if (sol[1][j].max - sol[1][j].min == minim) nr++;
                    if (sol[1][j].max - sol[1][j].min < minim)
                        minim = sol[1][j].max - sol[1][j].min, nr = 1;
                }
        for (i = 2; i <= n; i++){
                if (dqmin[smin] <= i-a && smin <= dmin) smin++;
                if (dqmax[smax] <= i-a && smax <= dmax) smax++;
            for ( ; sol[dqmin[smin]][j].min >= sol[i][j].min && smin <= dmin; dmin--);
            for ( ; sol[dqmax[smax]][j].max <= sol[i][j].max && smax <= dmax; dmax--);

            dqmin[++dmin] = i;
            dqmax[++dmax] = i;

            if (i >= a){
                    if (sol[dqmax[smax]][j].max - sol[dqmin[smin]][j].min == minim) nr++;
                    if (sol[dqmax[smax]][j].max - sol[dqmin[smin]][j].min < minim)
                        minim = sol[dqmax[smax]][j].max - sol[dqmin[smin]][j].min, nr=1;
            }
        }
    }
}