// Original C++ solution (slower):
//    https://youtu.be/N3oCS85HvpY



#include<bits/stdc++.h>

using namespace std;



typedef long long ll;

typedef long double ld;

typedef long long unsigned llu;

typedef pair<long long, long long> pll;

const long long inf = 2000000000000000000LL;	// 2e18

#define pi                  acos(-1.0)

#define fast                ios_base::sync_with_stdio(0);cin.tie(0);cout.tie(0)

#define shesh               "\n"

#define ff                  first

#define ss                  second

#define pb                  push_back

#define bp                  pop_back

#define pf                  push_front

#define fp                  pop_front

#define ub                  upper_bound

#define lb                  lower_bound

#define all(x)              x.begin(), x.end()

#define debug(x)            cout<<"debug "<<x<<"\n"

#define mest(a,b)           memset(a,b,sizeof(a))



int main()

{

    fast;

    llu ans=5000000000000000000;

    ll t,n,m,i,j,l,k,temp,flag,x,y,x1,x2,y1,y2;

    cin>>n>>k;

    vector<pair<ll,ll> >v;

    vector<ll>X,Y;

    for(i=0; i<n; i++)

    {

        cin>>x>>y;

        v.pb({x,y});

        X.pb(x);

        Y.pb(y);

    }

    sort(all(X));

    sort(all(Y));

    for(j=0; j<n; j++)

    {

        for(x=j+1; x<n; x++)

        {

            for(y=0; y<n; y++)

            {

                for(t=y+1,temp=0; t<n; t++)

                {

                    x1=min(X[j],X[x]);

                    x2=max(X[j],X[x]);

                    y1=min(Y[y],Y[t]);

                    y2=max(Y[y],Y[t]);

                    for(l=0,temp=0; l<n; l++)

                    {

                        if(v[l].ff>=x1 && v[l].ff<=x2 && v[l].ss>=y1 && v[l].ss<=y2)

                            temp++;

                    }

                    if(temp>=k)

                    {

                        if(ans>((llu)abs(x1-x2))*((llu)abs(y1-y2)))

                            ans=((llu)abs(x1-x2))*((llu)abs(y1-y2));

                    }

                }

            }

        }

    }

    cout<<ans;

    return 0;

}


// Optimized solution to the same problem (faster):
#include <cstdio>

#include <cctype>

#include <algorithm>

#define int long long

using namespace std;



struct Node {

    int x, y;

} a[233];



int n, num, ans = 0x7fffffffffffffff;



int read() {

    int ret, f = 1;

    char ch;

    while(!isdigit(ch = getchar())) (ch == '-') && (f = -1);

    for(ret = ch - '0'; isdigit(ch = getchar()); ret *= 10, ret += ch - '0');

    return ret * f;

}



void print(int x) {

    if(x < 0) putchar('-'), x = -x;

    if(x > 9) print(x / 10);

    putchar(x % 10 + '0');

}



bool cmp(Node a, Node b) {

    return a.x < b.x;

}



signed main() {

    n = read(), num = read();

    for(int i = 1; i <= n; ++i) a[i].x = read(), a[i].y = read();

    std::sort(a + 1, a + n + 1, cmp);

    for(int i = 1; i <= n; ++i)

        for(int j = i + 1; j <= n; ++j) {

            int tmx = std::max(a[i].y, a[j].y),

                tmn = std::min(a[i].y, a[j].y);

            for(int k = 1; k <= n; ++k) {

                if(a[k].y > tmx || a[k].y < tmn) continue;

                int cnt = 0;

                for(int l = k; l <= n; ++l) {

                    if(a[l].y > tmx || a[l].y < tmn) continue;

                    if(++cnt >= num) ans = min(ans, (tmx - tmn) * (a[l].x - a[k].x));

                }

            }

        }

    print(ans);

    return 0;

}

// Fastest known solution for this problem: