#include "bits/stdc++.h"
#ifndef err
#define err(...)(void)0
#endif
using namespace std;
using ll = long long;
using ull = decltype(1ull);
template<class T>int size(T&&a) { return a.size(); }
#define REP(t,a)for(typename make_signed<decltype(a.second)>::type t=a.first,_l##t=a.second;t<_l##t;t++)
#define RREP(t,a)for(typename make_signed<decltype(a.second)>::type t=a.second-1,_l##t=a.first;t>=_l##t;t--)
template<class B>pair<int, B>make_pair(B b) { return{ 0,b }; }
#define rep(t,...)REP(t,make_pair(__VA_ARGS__))
#define rrep(t,...)RREP(t,make_pair(__VA_ARGS__))
#define all(a)begin(a),end(a)
#define rall(a)a.rbegin(),a.rend()
#define var(t, ...) t __VA_ARGS__;in,__VA_ARGS__;

void Calc();
int main() {
  ios::sync_with_stdio(false); cin.tie(nullptr);
  cin.exceptions(istream::failbit | istream::badbit);
  cout << fixed << setprecision(15); Calc(); cout.flush(); return 0;
}
template<class A>void amax(A&a, A b) { a = max(a, b); }
template<class A>void amin(A&a, A b) { a = min(a, b); }
template<class A>int comp(A a, A b) { return a < b ? 1 : b < a ? -1 : 0; }
struct Scanner {
  template<class A = string>A Next() { A a; cin >> a; return a; }
  template<class A = int>vector<A>Array(int n) { vector<A>a(n); for (A&i : a) cin >> i; return a; }
  string Line() const { string s; getline(cin, s); return s; }
  template<class A>Scanner&operator,(A&a) { a = Next<A>(); return *this; }
  template<class A>operator A() { return Next<A>(); }
}in;

/*---------------------------------------------------------------------*/

template<class T> struct Compression : public vector<T> {
  Compression(const vector<T>&a) :vector<T>(a) {
    sort(this->begin(), this->end());
    this->erase(unique(this->begin(), this->end()), this->end());
  }
  int index(T num) {
    return lower_bound(this->begin(), this->end(), num) - this->begin();
  }
  T reverse(int index) {
    return ((vector<T>&)*this)[index];
  }
};
template<class T, class O = int> struct CumulativeSum {
  Compression<T> x, y;
  vector<vector<O>> s;
  CumulativeSum(const vector<T>& xa, const vector<T>& ya) :x(xa), y(ya) {
    s.resize(y.size() + 1);
    for (auto& i : s) i.resize(x.size() + 1);
    rep(i, xa.size()) {
      int xs = x.index(xa[i]);
      int ys = y.index(ya[i]);
      s[ys + 1][xs + 1]++;
    }
    rep(i, y.size())rep(j, x.size()) {
      s[i + 1][j + 1] += s[i][j + 1] + s[i + 1][j] - s[i][j];
    }
  }
  O sum(T lx, T ly, T rx, T ry) {
    lx = x.index(lx);
    rx = x.index(rx + 1);
    ly = y.index(ly);
    ry = y.index(ry + 1);
    return s[ry][rx] - s[ly][rx] - s[ry][lx] + s[ly][lx];
  }

  O sumIndex(T lx, T ly, T rx, T ry) {
    return s[ry][rx] - s[ly][rx] - s[ry][lx] + s[ly][lx];
  }

  void reverse(T& lx, T& ly, T& rx, T& ry) {
    lx = x.reverse(lx);
    rx = x.reverse(rx);
    ly = y.reverse(ly);
    ry = y.reverse(ry);
  }
};



void Calc() {

  var(int, n, k);
  vector<ll> xa(n), ya(n);
  rep(i, n)in, xa[i], ya[i];

  CumulativeSum<ll, ll> sum(xa, ya);

  ll m = (ll)1e18 * 9;
  int mx = size(sum.x);
  int my = size(sum.y);
  rep(ix, mx)rep(iy, my)rep(jx, mx)rep(jy, my) {
    if (sum.sumIndex(ix, iy, jx + 1, jy + 1) >= k) {
      ll cix = ix, ciy = iy, cjx = jx, cjy = jy;
      sum.reverse(cix, ciy, cjx, cjy);
      amin(m, abs(cix - cjx)*abs(ciy - cjy));
    }
  }

  cout << (m) << endl;



}


Measured memory_bytes: 256