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.io.BufferedReader;
import java.io.IOException;
import java.io.InputStreamReader;
import java.util.Arrays;


public class Main {

	/**
	 * @param args
	 * @throws IOException 
	 */
	public static void main(String[] args) throws IOException {
		// TODO Auto-generated method stub
		BufferedReader br = new BufferedReader(new InputStreamReader(System.in));

		String[] tmpArray = br.readLine().split(" ");
		
		int n = Integer.parseInt(tmpArray[0]);
		int K = Integer.parseInt(tmpArray[1]);
		
		Point[] points = new Point[n];
		long x[] = new long[n];
		long y[] = new long[n];
		
		for(int i = 0; i < n; i++){
			tmpArray = br.readLine().split(" ");
			points[i] = new Point(Long.parseLong(tmpArray[0]), Long.parseLong(tmpArray[1]));
			x[i] = Long.parseLong(tmpArray[0]);
			y[i] = Long.parseLong(tmpArray[1]);
		}	
		
//		Arrays.sort(points);
		Arrays.sort(x);
		Arrays.sort(y);
		
		//長方形を探索
		long minArea = Long.MAX_VALUE;
//		for(int i = 0; i + k - 1< n ; i++){
//			System.out.println("range "+i+" to "+(i + k - 1));
//			long tmpArea = (points[i + k - 1].x - points[i].x)*
//					(maxY(points, i, i + k - 1) - minY(points, i, i + k - 1));
////			System.out.println("dx "+(points[i + k - 1].x - points[i].x));
//			System.out.println("i = " + i + " area "+ tmpArea);
//			if(tmpArea < minArea){
//				minArea = tmpArea;
//			}
//		}
		
		//ガチの全探索
		for(int i = 0; i < n - 1; i++){
			for(int j = i + 1; j < n; j++){
				for(int k = 0; k < n - 1; k++){
					for(int l = 0; l < n; l++){
						long left = x[i];
						long right = x[j];
						long bottom = y[k];
						long top = y[l];
						
						int count = pointInRect(left, right, top, bottom, points);
//						System.out.println(count);
						if(count >= K){
							long tmpArea = (right - left)*(top - bottom);
							
							if(tmpArea < minArea){
								minArea = tmpArea;
							}
						}
					}
				}
			}
		}
		
		System.out.println(minArea);
	}
	
	static int pointInRect(long left, long right, long top, long bottom, Point[] points){
		int result = 0;
		
//		System.out.println(left+" "+right+" "+top+" "+bottom);
		
		for(int i = 0; i < points.length ; i++){
			if(points[i].x >= left && points[i].x <= right
					&& points[i].y >= bottom && points[i].y <= top ){
				result++;
			}
		}
		
		return result;
	}

	static long minY(Point[] points, int start, int end){
		long min = points[start].y;

		for(int i = start + 1; i <= end; i++){
			if(min > points[i].y){
				min = points[i].y;
			}
		}
		
		return min;
	}
	
	static long maxY(Point[] points, int start, int end){
		long max = points[start].y;

		for(int i = start + 1; i <= end; i++){
			if(max < points[i].y){
				max = points[i].y;
			}
		}
		
		return max;
	}

}

class Point implements Comparable<Point>{

	long x;
	long y;
	
	public Point(long x, long y){
		this.x = x;
		this.y = y;
	}
	
	public int compareTo(Point p) {
		// TODO Auto-generated method stub
		if(this.x > p.x){
			return 1;
		}
		else if(this.x == p.x){
			return 0;
		}
		else {
			return -1;
		}
	}
	
}