#include <iostream>
#include <fstream>
#include <deque>
#include <vector>
#include <algorithm>
#include <utility>
using namespace std;

// Deschidere fisier in / out
ifstream in("struti.in");
ofstream out("struti.out");

const int INF = 8001; // Valoare maxima a diferentei + 1
const int MAX_NR = 1001;

int mat[MAX_NR][MAX_NR];
int min_final[MAX_NR][MAX_NR];
int max_final[MAX_NR][MAX_NR];
int temp_min[MAX_NR][MAX_NR];
int temp_max[MAX_NR][MAX_NR];

int m,n,p; // Eliminam A, B, min_global_diff, nr_total globale

void citire(){
    // Optimizare I/O (pt. citirea initiala)
    ios_base::sync_with_stdio(false);
    in.tie(NULL); 
    
    in>>m>>n>>p;
    for(int i=1;i<=m;i++)
        for(int j=1;j<=n;j++)
            in>>mat[i][j]; // Citire corecta din 'in'
}

pair<int,int> proceseaza_dimensiunea(int DX,int DY){
    // LOGICA SW 2D E CORECTA (Pasul 1 & 2)
    // ... (corpul functiei de procesare ramane neschimbat) ...
    int N_max=n-DY+1;
    for(int i=1;i<=m;i++){
        deque<int>dq_min,dq_max;
        for(int j=1;j<=n;j++){
            while(!dq_min.empty() && dq_min.front()<=j-DY) dq_min.pop_front();
            while(!dq_min.empty() && mat[i][j]<=mat[i][dq_min.back()]) dq_min.pop_back();
            while(!dq_max.empty() && dq_max.front()<=j-DY) dq_max.pop_front();
            while(!dq_max.empty() && mat[i][j]>=mat[i][dq_max.back()]) dq_max.pop_back();

            dq_min.push_back(j);
            dq_max.push_back(j);

            if(j>=DY){
                temp_min[i][j-DY+1]=mat[i][dq_min.front()];
                temp_max[i][j-DY+1]=mat[i][dq_max.front()];
            }
        }
    }
    int M_max=m-DX+1;
    for(int j=1;j<=N_max;j++){
        deque<int>dq_min,dq_max;
        for(int i=1;i<=m;i++){
            while(!dq_min.empty() && dq_min.front()<=i-DX) dq_min.pop_front();
            while(!dq_min.empty() && temp_min[i][j]<=temp_min[dq_min.back()][j]) dq_min.pop_back();
            while(!dq_max.empty() && dq_max.front()<=i-DX) dq_max.pop_front();
            while(!dq_max.empty() && temp_max[i][j]>=temp_max[dq_max.back()][j]) dq_max.pop_back();
            
            dq_min.push_back(i);
            dq_max.push_back(i);

            if(i>=DX){
                min_final[i-DX+1][j]=temp_min[dq_min.front()][j];
                max_final[i-DX+1][j]=temp_max[dq_max.front()][j];
            }
        }
    }
    
    // Pasul 3: Folosim variabile LOCALE și inițializare cu INF
    int min_diff_local = INF; 
    int nr_local = 0;
    
    for(int i=1;i<=M_max;i++){
        for(int j=1;j<=N_max;j++){
            int dif=max_final[i][j]-min_final[i][j];
            if(dif<min_diff_local){
                min_diff_local=dif;
                nr_local=1;
            } else if(dif==min_diff_local){
                nr_local++;
            }
        }
    }
    return {min_diff_local,nr_local};
}

int main(){
    // Optimizare I/O pt. main
    ios_base::sync_with_stdio(false);
    out.tie(NULL); 
    
    citire();
    
    vector<pair<int,int>>rez_final;
    
    for(int k=1;k<=p;k++){
        int dx,dy;
        in>>dx>>dy;
        
        pair<int,int> rez1=proceseaza_dimensiunea(dx,dy);
        int min_global=rez1.first;
        int nr_total=rez1.second;
        
        if(dx!=dy){
            pair<int,int> rez2=proceseaza_dimensiunea(dy,dx);
            if(rez2.first<min_global){
                min_global=rez2.first;
                nr_total=rez2.second;
            } else if(rez2.first==min_global){ // Folosim else if pentru a asigura ca min_global e cel minim
                nr_total+=rez2.second;
            }
        }
        
        rez_final.push_back({min_global,nr_total});
    }
    
    for(const auto& rez : rez_final){
        out<<rez.first<<" "<<rez.second<<"\n";
    }
    
    return 0;
}