output_description: For each dataset, output a single line containing the largest possible
  capacity of a pond that can be built in the garden site described in the
  dataset. If no ponds can be built, output a single line containing a zero.
input_description: The input consists of at most 100 datasets, each in the following format.
  
      
      
      _d w_
      _e_ 1, 1 ... _e_ 1, _w_
      ...
      _e_ _d_ , 1 ... _e d, w_
      
  
  The first line contains _d_ and _w_ , representing the depth and the width,
  respectively, of the garden site described in the map. They are positive
  integers between 3 and 10, inclusive. Each of the following _d_ lines contains
  _w_ integers between 0 and 9, inclusive, separated by a space. The _x_ -th
  integer in the _y_ -th line of the _d_ lines is the elevation of the unit
  square cell with coordinates (_x, y_).
  
  The end of the input is indicated by a line containing two zeros separated by
  a space.
attempt: def area(x_s, x_e, y_s, y_e):
      return int((x_e - x_s - 1) * (y_e - y_s - 1))
  
  
  def minimum_border(A, x_s, x_e, y_s, y_e):
      min = A[x_s][y_s]
      for i in range(x_s, x_e + 1):
          for j in range(y_s, y_e + 1):
              if A[i][j] < min:
                  min = A[i][j]
      return min
  
  
  def maximum_inter(A, x_s, x_e, y_s, y_e):
      max = A[x_s + 1][y_s + 1]
      for i in range(x_s + 1, x_e):
          for j in range(y_s + 1, y_e):
              if A[i][j] > max:
                  max = A[i][j]
      return max
  
  
  A = [[0 for i in range(10)] for j in range(10)]
  ans = []
  
  while True:
      n, m = map(int, input().split())
  
      if n == m == 0:
          break
      for i in range(n):
          tmp = []
          tmp = list(map(int, input().split()))
          tmp.reverse()
          for j in range(m):
              A[i][j] = tmp.pop()
  
      flag = 0
      max_s = 0
      for y_s in range(m - 2):
          for y_e in range(m - 3, m):
              for x_s in range(n - 2):
                  for x_e in range(n - 3, n):
                      if y_e - y_s < 2 or x_e - x_s < 2:
                          pass
                      else:
                          # print(area(x_s,x_e,y_s,y_e))
                          if minimum_border(A, x_s, x_e, y_s, y_e) > maximum_inter(
                              A, x_s, x_e, y_s, y_e
                          ):
                              if flag == 0:
                                  print("=====")
                                  max_s = area(x_s, x_e, y_s, y_e)
                              else:
                                  if area(x_s, x_e, y_s, y_e) > max_s:
                                      max_s = area(x_s, x_e, y_s, y_e)
                              ans.append(max_s)
  
  ans.reverse()
  for i in range(len(ans)):
      print(ans.pop())
  
problem_description: _A Garden with Ponds_
  
  Mr. Gardiner is a modern garden designer who is excellent at utilizing the
  terrain features. His design method is unique: he first decides the location
  of ponds and design them with the terrain features intact.
  
  According to his unique design procedure, all of his ponds are rectangular
  with simple aspect ratios. First, Mr. Gardiner draws a regular grid on the map
  of the garden site so that the land is divided into cells of unit square, and
  annotates every cell with its elevation. In his design method, a pond occupies
  a rectangular area consisting of a number of cells. Each of its outermost
  cells has to be higher than all of its inner cells. For instance, in the
  following grid map, in which numbers are elevations of cells, a pond can
  occupy the shaded area, where the outermost cells are shaded darker and the
  inner cells are shaded lighter. You can easily see that the elevations of the
  outermost cells are at least three and those of the inner ones are at most
  two.
  
  ![](https://judgeapi.u-aizu.ac.jp/resources/images/IMAGE2_ICPCDomestic2017_C1)
  
  A rectangular area on which a pond is built must have at least one inner cell.
  Therefore, both its width and depth are at least three.
  
  When you pour water at an inner cell of a pond, the water can be kept in the
  pond until its level reaches that of the lowest outermost cells. If you
  continue pouring, the water inevitably spills over. Mr. Gardiner considers the
  larger _capacity_ the pond has, the better it is. Here, the capacity of a pond
  is the maximum amount of water it can keep. For instance, when a pond is built
  on the shaded area in the above map, its capacity is (3 − 1) + (3 − 0) + (3 −
  2) = 6, where 3 is the lowest elevation of the outermost cells and 1, 0, 2 are
  the elevations of the inner cells. Your mission is to write a computer program
  that, given a grid map describing the elevation of each unit square cell,
  calculates the largest possible capacity of a pond built in the site.
  
  Note that neither of the following rectangular areas can be a pond. In the
  left one, the cell at the bottom right corner is not higher than the inner
  cell. In the right one, the central cell is as high as the outermost cells.
  
  ![](https://judgeapi.u-aizu.ac.jp/resources/images/IMAGE2_ICPCDomestic2017_C2)
samples: [{"input": "3\n    2 3 2\n    2 1 2\n    2 3 1\n    3 5\n    3 3 4 3 3\n    3 1 0 2 3\n    3 3 4 3 2\n    7 7\n    1 1 1 1 1 0 0\n    1 0 0 0 1 0 0\n    1 0 1 1 1 1 1\n    1 0 1 0 1 0 1\n    1 1 1 1 1 0 1\n    0 0 1 0 0 0 1\n    0 0 1 1 1 1 1\n    6 6\n    1 1 1 1 2 2\n    1 0 0 2 0 2\n    1 0 0 2 0 2\n    3 3 3 9 9 9\n    3 0 0 9 0 9\n    3 3 3 9 9 9\n    0 0", "output": "3\n    1\n    9"}]