Problem: 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.

Examples

Input

4 4
1 4
3 3
6 2
8 1


Output

21


Input

4 2
0 0
1 1
2 2
3 3


Output

1


Input

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


Output

3999999996000000001

Solution (in JAVA):

Solution:
import java.util.*;
public class Main {
	
	static Map<Integer,Integer> x2y;
	static int xl[];
	static int yl[];
	static Map<Integer, Integer> deleteY;
	static Map<Integer, Integer> deleteX;
	static int sum ,rsum,usum,  N, K;
	public static void main(String[] args) {		
		Scanner sc = new Scanner(System.in);
		N = sc.nextInt(); K = sc.nextInt();
		x2y = new HashMap<Integer,Integer>();
		int xlm[] = new int[N];
		int ylm[] = new int[N];
		for(int i=0;i<N;i++) {
			int x = sc.nextInt(), y = sc.nextInt();
			xlm[i]=x; ylm[i]=y;
			x2y.put(x,y); 
		}
		sc.close();
		Arrays.sort(xlm);
		Arrays.sort(ylm);
			
		long ans = Long.MAX_VALUE;
		for(int l=0;l<N;l++) {
			sum = N;
			xl = xlm.clone();
			yl = ylm.clone();
			deleteY = new HashMap<Integer, Integer>();;
			
			int lmin = xl[l];	
			removeY(l,true);//plus:true
			sum -= l;
			rsum = sum;
			if(sumOut()) break;
			for(int r=0;r+l<N;r++) {
				sum = rsum;
				int rmax = xl[N-1-r];
				removeY(r,false);//plus:true
				if(r!=0)sum -=r;
				if(sumOut()) break;
				boolean firstChoice = true;
				usum = sum;
				for(int u=0;u<N;u++) {
					sum = usum;
					int umax = yl[N-1-u];
					if(deleteY.containsKey(umax)) continue;
					if(!firstChoice)usum --;
					else firstChoice = false;
					if(sumOut()) break;
					sum = usum;
					boolean firstChoiceD = true;
					for(int d=0;u+d<N;d++) {	
						int dmin = yl[d];
						if(deleteY.containsKey(dmin)) continue;
						if(!firstChoiceD)sum --;
						else firstChoiceD = false;
						if(sumOut()) break;
						
						long Squ = ((long)rmax - lmin)*((long)umax-dmin);
 						ans = Math.min(ans, Squ);
						
					}
				}
			}
		}
		System.out.println(ans);
	}


	static void removeY(int times, boolean plus) {
		if(plus) {
			for(int i=0;i<times;i++) {
				int keyX = xl[i];
				int valueY = x2y.get(keyX);
				if(!deleteY.containsKey(keyX))deleteY.put(valueY, 1);
			}
		}else {
			for(int i=0;i<times;i++) {
				int keyX = xl[N-1-i];
				int valueY = x2y.get(keyX);
				if(!deleteY.containsKey(keyX))deleteY.put(valueY, 1);
			}
		}
	}
	static boolean sumOut() {
		return sum<K;
	}

}