#include <bits/stdc++.h>

using namespace std;
typedef long long ll;

#define REP(i,n) for(ll i=0;i<n;++i)
#define SORT(name) sort(name.begin(), name.end())
#define ZERO(p) memset(p, 0, sizeof(p))
#define MINUS(p) memset(p, -1, sizeof(p))

#define MOD 1000000007
#define INF 1000000000

// second の小さい順にソート
struct ll_pair_less {
    bool operator()(const pair<ll, ll>& x, const pair<ll, ll>& y) const {
        return x.second < y.second;
    }
};

ll N, K;
vector< pair<ll, ll> > Pos;
ll ans;

int main()
{
    ans = -1;
    cin >> N >> K;
    REP(i, N) {
        ll x, y;
        cin >> x >> y;
        Pos.push_back(make_pair(x, y));
    }

    REP(i, Pos.size()) {
        for(ll j = i + 1; j < Pos.size(); ++j) {
            ll cnt2 = 0;
            // 2 点
            ll min_x2 = min(Pos[i].first, Pos[j].first);
            ll max_x2 = max(Pos[i].first, Pos[j].first);
            ll min_y2 = min(Pos[i].second, Pos[j].second);
            ll max_y2 = max(Pos[i].second, Pos[j].second);
            REP(k, Pos.size()) {
                if(Pos[k].first >= min_x2  && Pos[k].first <= max_x2 &&
                        Pos[k].second >= min_y2 && Pos[k].second <= max_y2 ) {
                    cnt2++;
                }
            }
            if(K <= cnt2) {
                ll w = abs(max_x2 - min_x2);
                ll h = abs(max_y2 - min_y2);
                if(ans == -1) { ans = w * h; }
                else { ans = min(ans, w * h); }
            }
            for(ll k = j + 1; k < Pos.size(); ++k) {
                ll cnt3 = 0;
                // 3 点
                ll min_x3 = min({Pos[i].first, Pos[j].first, Pos[k].first});
                ll max_x3 = max({Pos[i].first, Pos[j].first, Pos[k].first});
                ll min_y3 = min({Pos[i].second, Pos[j].second, Pos[k].second});
                ll max_y3 = max({Pos[i].second, Pos[j].second, Pos[k].second});
                REP(k, Pos.size()) {
                    if(Pos[k].first >= min_x3  && Pos[k].first <= max_x3 &&
                            Pos[k].second >= min_y3 && Pos[k].second <= max_y3 ) {
                        cnt3++;
                    }
                }
                if(K <= cnt3) {
                    ll w = abs(max_x3 - min_x3);
                    ll h = abs(max_y3 - min_y3);
                    if(ans == -1) { ans = w * h; }
                    else { ans = min(ans, w * h); }
                }
                for(ll l = k + 1; l < Pos.size(); ++l) {
                    ll cnt4 = 0;
                    // 4 点
                    ll min_x4 = min({Pos[i].first, Pos[j].first, Pos[k].first, Pos[l].first});
                    ll max_x4 = max({Pos[i].first, Pos[j].first, Pos[k].first, Pos[l].first});
                    ll min_y4 = min({Pos[i].second, Pos[j].second, Pos[k].second, Pos[l].second});
                    ll max_y4 = max({Pos[i].second, Pos[j].second, Pos[k].second, Pos[l].second});
                    REP(k, Pos.size()) {
                        if(Pos[k].first >= min_x4  && Pos[k].first <= max_x4 &&
                           Pos[k].second >= min_y4 && Pos[k].second <= max_y4 ) {
                            cnt4++;
                        }
                    }
                    if(K <= cnt4) {
                        ll w = abs(max_x4 - min_x4);
                        ll h = abs(max_y4 - min_y4);
                        if(ans == -1) { ans = w * h; }
                        else { ans = min(ans, w * h); }
                    }
                }
            }
        }
    }

    printf("%lld\n", ans);

    return 0;
}


Measured memory_bytes: 256