Problem:
Score : 400 points

Problem Statement

We have N points in a two-dimensional plane.

The coordinates of the i-th point (1 \leq i \leq N) are (x_i,y_i).

Let us consider a rectangle whose sides are parallel to the coordinate axes that contains K or more of the N points in its interior.

Here, points on the sides of the rectangle are considered to be in the interior.

Find the minimum possible area of such a rectangle.

Constraints

2 \leq K \leq N \leq 50

-10^9 \leq x_i,y_i \leq 10^9 (1 \leq i \leq N)

x_i≠x_j (1 \leq i<j \leq N)

y_i≠y_j (1 \leq i<j \leq N)

All input values are integers. (Added at 21:50 JST)

Input

Input is given from Standard Input in the following format:

N K
x_1 y_1
:
x_{N} y_{N}

Output

Print the minimum possible area of a rectangle that satisfies the condition.

Sample Input 1

4 4
1 4
3 3
6 2
8 1

Sample Output 1

21

One rectangle that satisfies the condition with the minimum possible area has the following vertices: (1,1), (8,1), (1,4) and (8,4).

Its area is (8-1) × (4-1) = 21.

Sample Input 2

4 2
0 0
1 1
2 2
3 3

Sample Output 2

1

Sample Input 3

4 3
-1000000000 -1000000000
1000000000 1000000000
-999999999 999999999
999999999 -999999999

Sample Output 3

3999999996000000001

Watch out for integer overflows.

Solution in C++14 (GCC 5.4.1) (judge verdict: Wrong Answer)

#include <iostream>
#include <string>
#include <vector>
#include <algorithm>
#include <cmath>
#include <cstdio>
#include <functional>
#include <numeric>
#include <stack>
#include <queue>
#include <map>
#include <set>
#include <utility>
#include <sstream>
#include <complex>
#include <fstream>
#include <bitset>
#include <time.h>
#include <tuple>

using namespace std;

typedef long long ll;
typedef pair<ll, ll> P;
typedef vector<ll> V;
typedef complex<double> Point;

#define PI acos(-1.0)
#define EPS 1e-10
const ll INF = 1e12;
const ll MOD = 1e9 + 7;

#define FOR(i,a,b) for(int i=(a);i<(b);i++)
#define rep(i,N) for(int i=0;i<(N);i++)
#define ALL(s) (s).begin(),(s).end()
#define EQ(a,b) (abs((a)-(b))<EPS)
#define EQV(a,b) ( EQ((a).real(), (b).real()) && EQ((a).imag(), (b).imag()) )
#define fi first
#define se second
#define N_SIZE (1LL << 20)
#define NIL -1

int n, k;
P p[100];


int main() {
	cin >> n >> k;
	rep(i, n) {
		cin >> p[i].first >> p[i].second;
	}
	sort(p, p + n);
	ll ans = (1LL << 62);
	rep(i, n - k) {
		ll MINX = INF, MINY = INF, MAXX = -INF, MAXY = -INF;
		rep(j, k) {
			MAXX = max(MAXX, p[i + j].first);
			MINX = min(MINX, p[i + j].first);
			MAXY = max(MAXY, p[i + j].second);
			MINY = min(MINY, p[i + j].second);
		}
		ans = min((MAXX - MINX)*(MAXY - MINY), ans);
	}
	rep(i, n) {
		swap(p[i].first, p[i].second);
	}
	sort(p, p + n);
	rep(i, n - k + 1) {
		ll MINX = INF, MINY = INF, MAXX = 0, MAXY = 0;
		rep(j, k) {
			MAXX = max(MAXX, p[i + j].first);
			MINX = min(MINX, p[i + j].first);
			MAXY = max(MAXY, p[i + j].second);
			MINY = min(MINY, p[i + j].second);
		}
		ans = min((MAXX - MINX)*(MAXY - MINY), ans);
	}
	cout << ans << endl;
}