#include <iostream>
#include <string>
#include <cstdlib>
#include <cstdio>
#include <queue>
#include <stack>
#include <list>
#include <utility>
#include <vector>
#include <set>
#include <algorithm>
#include <cmath>
#include <climits>
#include <map>
#include <unordered_map>
#include <string.h>
#include<iomanip>
#include <iterator>
#include <locale>

#define all(a) a.begin(),a.end()
#define VV(T) vector<vector< T > >
#define rep(i,N) for(int i = 0; i <N; i++)
#define repsg(i,s,g) for(int i = s; i <g; i++)
#define name(x) #x
using namespace std;

const int INF = INT_MAX;
const long long INFL =LONG_LONG_MAX;
const double PI = atan(1)*4;
const int MOD = pow(10,9)+7;
int dy[]={0, 0, 1, -1, 0};
int dx[]={1, -1, 0, 0, 0};

typedef long long ll,LL;
typedef vector<int> vint;
typedef vector<vector<int> > vvint;
typedef vector<long long> vll, vLL;
typedef vector<vector<long long> > vvll, vvLL;
typedef pair<int,int> pii;
typedef pair<LL, LL> pLL;


// vector入力
template<typename T>
istream& operator >> (istream& is, vector<T>& vec){
    for(T& x: vec) is >> x;
    return is;
}
// vector出力
template<typename T>
ostream& operator << (ostream& os, vector<T>& vec){
    for(int i=0; i<vec.size(); i++){
        os << vec[i] << ( i+1 == vec.size() ? "" : " " );
    }
    return os;
}


template< typename T >
struct edge{
    int src, to;T cost;
    edge(int to,T cost) :src(-1),to(to),cost(cost){}
    edge(int src, int to, T cost) :src(src),to(to),cost(cost){}edge
    &operator=(const int &x){
        to =x;
        return *this;
    }
    operator int() const{ return to;}
};

template< typename T >
using Edges =vector< edge<T> >;
template< typename T >
using WeightedGraph =vector< Edges<T> >;
using UnWeightedGraph =vector< vector<int> >;
template< typename T >
using Matrix =vector< vector<T> >;


template< typename T >
///与えられた隣接行列を用いてワーシャルフロイド法によりノード間最短距離を求める。閉路がある場合、ループ後にg[k][k] < 0なるノードkが存在
///gでエッジのない部分をINFにしておくことを忘れないように！
void warshall_floyd(Matrix< T > &g, T INF) {
    for(int k = 0; k < g.size(); k++) {
        for(int i = 0; i < g.size(); i++) {
            for(int j = 0; j < g.size(); j++) {
                if(g[i][k] == INF || g[k][j] == INF) continue;
                g[i][j] = min(g[i][j], g[i][k] + g[k][j]);
            }
        }
    }
}

vector<int> r;

int main() {
    int n,k;cin>>n>>k;
    vector<pLL> p(n);
    rep(i,n){
        ll a, b;cin>>a>>b;
        p[i] =make_pair(a,b);
    }
    
    vector<ll>x,y;
    rep(i,n){
        x.push_back(p[i].first);
        y.push_back(p[i].second);
    }
    sort(all(x));sort(all(y));
    x.erase(unique(all(x)),x.end());
    y.erase(unique(all(y)),y.end());
    
    ll ans =  LONG_LONG_MAX;
    int count;
    
    for(auto i=0;i<x.size();i++){
         for(auto j=i;j<x.size();j++){
             for(auto iy=0;iy<y.size();iy++){
                 for(auto jy=iy;jy<y.size();jy++){
                     count = 0;
                     for(auto q:p){
                         if(x[i]<=q.first && q.first<=x[j] && y[iy]<=q.second && q.second <= y[jy]) count++;
                     }
                     
                     if(count>=k) ans = min(ans, (y[jy]-y[iy])*(x[j]-x[i]));
                     
                 }
             }
         }
    }
    
    cout<<ans<<endl;
    
    
    
    return 0;
}










Measured memory_bytes: 256