output_description: Print the minimum possible area of a rectangle that satisfies the condition.
  
  * * *
input_description: Input is given from Standard Input in the following format:
  
      
      
      N K  
      x_1 y_1
      :  
      x_{N} y_{N}
attempt: n, K = map(int, input().split())
  v = []
  for i in range(0, n):
      x, y = map(int, input().split())
      v.append((x, y))
  v.sort()
  X = []
  Y = []
  for i in range(0, n):
      x, y = v[i]
      X.append(x)
      Y.append(y)
  
  
  def init_min(init_min_val):
      # set_val
      for i in range(n):
          seg_min[i + num_min - 1] = init_min_val[i]
      # built
      for i in range(num_min - 2, -1, -1):
          seg_min[i] = min(seg_min[2 * i + 1], seg_min[2 * i + 2])
  
  
  def update_min(k, x):
      k += num_min - 1
      seg_min[k] = x
      while k:
          k = (k - 1) // 2
          seg_min[k] = min(seg_min[k * 2 + 1], seg_min[k * 2 + 2])
  
  
  def query_min(p, q):
      if q <= p:
          return ide_ele_min
      p += num_min - 1
      q += num_min - 2
      res = ide_ele_min
      while q - p > 1:
          if p & 1 == 0:
              res = min(res, seg_min[p])
          if q & 1 == 1:
              res = min(res, seg_min[q])
              q -= 1
          p = p // 2
          q = (q - 1) // 2
      if p == q:
          res = min(res, seg_min[p])
      else:
          res = min(min(res, seg_min[p]), seg_min[q])
      return res
  
  
  #####単位元######
  ide_ele_min = 10**10
  
  # num_min:n以上の最小の2のべき乗
  num_min = 2 ** (n - 1).bit_length()
  seg_min = [ide_ele_min] * 2 * num_min
  
  
  def init_max(init_max_val):
      # set_val
      for i in range(n):
          seg_max[i + num_max - 1] = init_max_val[i]
      # built
      for i in range(num_max - 2, -1, -1):
          seg_max[i] = max(seg_max[2 * i + 1], seg_max[2 * i + 2])
  
  
  def update_max(k, x):
      k += num_max - 1
      seg_max[k] = x
      while k:
          k = (k - 1) // 2
          seg_max[k] = max(seg_max[k * 2 + 1], seg_max[k * 2 + 2])
  
  
  def query_max(p, q):
      if q <= p:
          return ide_ele_max
      p += num_max - 1
      q += num_max - 2
      res = ide_ele_max
      while q - p > 1:
          if p & 1 == 0:
              res = max(res, seg_max[p])
          if q & 1 == 1:
              res = max(res, seg_max[q])
              q -= 1
          p = p // 2
          q = (q - 1) // 2
      if p == q:
          res = max(res, seg_max[p])
      else:
          res = max(max(res, seg_max[p]), seg_max[q])
      return res
  
  
  #####単位元######
  ide_ele_max = -(10**10)
  
  # num_max:n以上の最小の2のべき乗
  num_max = 2 ** (n - 1).bit_length()
  seg_max = [ide_ele_max] * 2 * num_max
  
  ans = 10**20
  init_min(Y)
  init_max(Y)
  for i in range(0, n - K + 1):
      w = X[K - 1 + i] - X[i]
      h = query_max(i, K + i) - query_min(i, K + i)
      if ans > h * w:
          ans = h * w
  print(ans)
  
problem_description: Statement
  
  We have N points in a two-dimensional plane.  
  The coordinates of the i-th point (1 \leq i \leq N) are (x_i,y_i).  
  Let us consider a rectangle whose sides are parallel to the coordinate axes
  that contains K or more of the N points in its interior.  
  Here, points on the sides of the rectangle are considered to be in the
  interior.  
  Find the minimum possible area of such a rectangle.
samples: [{"input": "4 4\n    1 4\n    3 3\n    6 2\n    8 1", "output": "21\n    \n\nOne rectangle that satisfies the condition with the minimum possible area has\nthe following vertices: (1,1), (8,1), (1,4) and (8,4).  \nIts area is (8-1) \u00d7 (4-1) = 21.\n\n* * *"}, {"input": "4 2\n    0 0\n    1 1\n    2 2\n    3 3", "output": "1\n    \n\n* * *"}, {"input": "4 3\n    -1000000000 -1000000000\n    1000000000 1000000000\n    -999999999 999999999\n    999999999 -999999999", "output": "3999999996000000001\n    \n\nWatch out for integer overflows."}]