#include <iostream>
#include <fstream>

#include <algorithm>
#include <vector>

#define GET(a, i, j, k) 

short int max[1000][1000][10];
short int min[1000][1000][10];

int main()
{
  std::ifstream in("struti.in");
  std::ofstream out("struti.out");

  int n, m, p;
  in >> n >> m >> p;
  // Fill out the initial min and max.
  for (int i = 0; i < n; ++i) {
    for (int j = 0; j < m; ++j) {
      in >> max[i][j][0];
      min[i][j][0] = max[i][j][0];
    }
  }

  // Fill out the rest.
  for (int k = 1; k <= 9; ++k) {
    for (int i = 0; i < n; ++i) {
      for (int j = 0; j < m; ++j) {
        // Max
        max[i][j][k] = max[i][j][k - 1];
        if (i - (1 << (k - 1)) >= 0) {
          max[i][j][k] =
              std::max(max[i][j][k], max[i - (1 << (k - 1))][j][k - 1]);
        }
        if (j - (1 << (k - 1)) >= 0) {
          max[i][j][k] =
              std::max(max[i][j][k], max[i][j - (1 << (k - 1))][k - 1]);
        }
        if (i - (1 << (k - 1)) >= 0 && j - (1 << (k - 1)) >= 0) {
          max[i][j][k] =
              std::max(max[i][j][k],
                       max[i - (1 << (k - 1))][j - (1 << (k - 1))][k - 1]);
        }
        // Min
        min[i][j][k] = min[i][j][k - 1];
        if (i - (1 << (k - 1)) >= 0) {
          min[i][j][k] =
              std::min(min[i][j][k], min[i - (1 << (k - 1))][j][k - 1]);
        }
        if (j - (1 << (k - 1)) >= 0) {
          min[i][j][k] =
              std::min(min[i][j][k], min[i][j - (1 << (k - 1))][k - 1]);
        }
        if (i - (1 << (k - 1)) >= 0 && j - (1 << (k - 1)) >= 0) {
          min[i][j][k] =
              std::min(min[i][j][k],
                       min[i - (1 << (k - 1))][j - (1 << (k - 1))][k - 1]);
        }
      }
    }
  }

//  for (int i = 0; i < p; ++i) {
//    int dx, dy;
//    in >> dx >> dy;
//    int sol = 1000000;
//    int count = 0;
//    for (int i = 1; i <= n; ++i) {
//      for (int j = 1; j <= m; ++j) {
//        if (i >= dx && j >= dy) {
//          int dif = max.get(i - dx + 1, i, j - dy + 1, j) -
//                    min.get(i - dx + 1, i, j - dy + 1, j);
//          if (dif == sol) {
//            count++;
//          } else if (dif < sol) {
//            count = 1;
//            sol = dif;
//          }
//        }
//        if (i >= dy && j >= dx && dy != dx) {
//          int dif = max.get(i - dy + 1, i, j - dx + 1, j) -
//                    min.get(i - dy + 1, i, j - dx + 1, j);
//          if (dif == sol) {
//            count++;
//          } else if (dif < sol) {
//            count = 1;
//            sol = dif;
//          }
//        }
//      }
//    }
//    out << sol << " " << count << std::endl;
//  }
//
  in.close();
  out.close();

  return 0;
}