// https://atcoder.jp/contests/abc075/tasks/abc075_d
#include <bits/stdc++.h>
using namespace std;
using ll = long long;
#define REP(i, n) FOR(i, 0, n)
#define FOR(i, s, n) for (int i = (s), i##_len = (n); i < i##_len; ++i)
#define ALL(obj) (obj).begin(), (obj).end()
#define ALLR(obj) (obj).rbegin(), (obj).rend()

// 座標圧縮
template <typename T> struct Compress {
    vector<T> xs;

    Compress() = default;

    Compress(const vector<T> &vs) { add(vs); }

    Compress(const initializer_list<vector<T>> &vs) {
        for (auto &p : vs)
            add(p);
    }

    void add(const vector<T> &vs) {
        copy(begin(vs), end(vs), back_inserter(xs));
    }

    void add(const T &x) { xs.emplace_back(x); }

    void build() {
        sort(begin(xs), end(xs));
        xs.erase(unique(begin(xs), end(xs)), end(xs));
    }

    vector<int> get(const vector<T> &vs) const {
        vector<int> ret;
        transform(begin(vs), end(vs), back_inserter(ret), [&](const T &x) {
            return lower_bound(begin(xs), end(xs), x) - begin(xs);
        });
        return ret;
    }

    int get(const T &x) const {
        return lower_bound(begin(xs), end(xs), x) - begin(xs);
    }

    const T &operator[](int k) const { return xs[k]; }
};

// 二次元累積和
template <class T> class CulSum2D {
  private:
    // original
    int H, W;

    // original+1
    vector<vector<T>> data;

  public:
    /// @param _H original
    /// @param _W original
    CulSum2D(int _H, int _W) : H(_H), W(_W) { reset(); }

    void reset() { data = vector<vector<T>>(H + 1, vector<T>(W + 1, T{})); }

    /// 0-index
    /// @param y original
    /// @param x original
    /// @param d original
    void add(T y, T x, T d) {
        y++;
        x++;
        if (y >= H + 1 || x >= W + 1)
            return;
        data[y][x] += d;
    }

    void build() {
        for (int i = 0; i < H; i++) {
            for (int j = 0; j < W; j++) {
                data[i + 1][j + 1] +=
                    data[i + 1][j] + data[i][j + 1] - data[i][j];
            }
        }
    }

    /// 0-index
    /// @param sy original close
    /// @param sx original close
    /// @param ty original open
    /// @param tx original open
    T get(int sy, int sx, int ty, int tx) {
        return data[ty][tx] - data[ty][sx] - data[sy][tx] + data[sy][sx];
    }
};

int main() {
    ios::sync_with_stdio(false);
    cin.tie(0);
    int N, K;
    cin >> N >> K;
    vector<int> vx(N), vy(N);
    REP(i, N) cin >> vx[i] >> vy[i];
    // 始点、終点を追加
    Compress<int> cp;
    cp.add(vx);
    cp.add(vy);
    cp.build();
    CulSum2D<int> sum(cp.xs.size(), cp.xs.size());
    REP(i, N) { sum.add(cp.get(vx[i]), cp.get(vy[i]), 1); }
    sum.build();
    ll ans = INT64_MAX;
    REP(i, N) FOR(j, i + 1, N) REP(k, N) FOR(l, k + 1, N) {
        int x1 = cp.get(vx[i]);
        int x2 = cp.get(vx[j]);
        if (x1 > x2)
            swap(x1, x2);
        int y1 = cp.get(vy[k]);
        int y2 = cp.get(vy[l]);
        if (y1 > y2)
            swap(y1, y2);
        int t = sum.get(x1, y1, x2 + 1, y2 + 1);
        if (t >= K) {
            ll u = (ll)abs(vx[i] - vx[j]) * abs(vy[k] - vy[l]);
            ans = min(ans, u);
        }
    }

    cout << ans << endl;
    return 0;
}


Measured memory_bytes: 256