#include <iostream>
#include <vector>
#include <algorithm>
using namespace std;
#define ll long long
#define inf 30000000000

ll abc (ll x, ll y) {
  if (x > y) { 
    return x - y;  
  }  
  return y - x;
}

int main () {
  ll N, k;
  cin >> N >> k;
  ll x[N], y[N];
  for (ll i = 0; i < N; i++) {
    cin >> x[i] >> y[i]; 
  }  
  ll min = -1;
  for (ll i = 0; i < N; i++) {
    for (ll j = (i + 1); j < N; j++) {
      // ueに広げるパターン
      ll ue = y[j];
      ll si = y[i];
      ll mi = x[i];
      ll hi = x[j];
      if (ue < si) {
        swap(ue, si);  
      }  
      if (mi < hi) {
        swap(mi, hi);  
      }
      ll num = 0;
      vector<ll> up, bo;
      for (ll l = 0; l < N; l++) {
        if (l != i && l != j) {
          if (x[l] >= hi && x[l] <= mi) {
            if (y[l] > ue) {
              up.push_back(y[l] - ue);  
            }  
            if (y[l] < si) {
              bo.push_back(si - y[l]);  
            }
            if (y[l] < ue && y[l] > si) {
              num++;  
            }
          }
        }  
      }
      if (num >= k - 2) {
        if (min == -1 || min > (ue - si) * (mi - hi)) {
          min = (ue - si) * (mi - hi);  
        }  
      }
      else {
        sort(up.begin(), up.end());
        sort(bo.begin(), bo.end());
        num += 2;
        for (ll p = 0; p <= up.size(); p++) {
          ll q = k - num - p;
          if (q >= 0 && q <= bo.size()) {
            // pについて
            ll uu, bb;
            if (p == 0) {
              uu = 0;    
            }  
            else {
              uu = up[p - 1];  
            }
            if (q == 0) {
              bb = 0;  
            }
            else {
              bb = bo[q - 1];  
            }
            if ((ue + uu + bb - si) * (mi - hi) < min || min == -1) {
              min = (ue + uu + bb - si) * (mi - hi);  
            }
          }
        }  
      }
      vector<ll> le, ri;
      num = 0;
      for (ll l = 0; l < N; l++) {
        if (l != i && l != j) {
          if (y[l] >= si && y[l] <= ue) {
            if (x[l] > mi) {
              ri.push_back(x[l] - mi);  
            }  
            if (x[l] < hi) {
              le.push_back(hi - x[l]);  
            }
            if (x[l] < mi && x[l] > hi) {
              num++;  
            }
          }
        }  
      }
      if (num >= k - 2) {
        if (min == -1 || min > (ue - si) * (mi - hi)) {
          min = (ue - si) * (mi - hi);  
        }  
      }
      else {
        sort(le.begin(), le.end());
        sort(ri.begin(), ri.end());
        num += 2;
        for (ll p = 0; p <= ri.size(); p++) {
          ll q = k - num - p;
          if (q >= 0 && q <= le.size()) {
            // pについて
            ll uu, bb;
            if (p == 0) {
              uu = 0;    
            }  
            else {
              uu = ri[p - 1];  
            }
            if (q == 0) {
              bb = 0;  
            }
            else {
              bb = le[q - 1];  
            }
            if ((ue - si) * (mi + uu + bb - hi) < min || min == -1) {
              min = (ue - si) * (mi + uu + bb - hi);  
            }
          }
        }  
      }
 
    }  
  }

  cout << min << endl;
}

Measured memory_bytes: 256