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 static java.lang.Math.*;

import java.io.BufferedReader;
import java.io.IOException;
import java.io.InputStream;
import java.io.InputStreamReader;
import java.io.OutputStream;
import java.io.PrintWriter;
import java.util.InputMismatchException;
import java.util.StringTokenizer;

public class Main {

	public static void main(String[] args) throws IOException {
		InputStream inputStream = System.in;
		OutputStream outputStream = System.out;
		InputReader in = new InputReader(inputStream);
		PrintWriter out = new PrintWriter(outputStream);
		TaskX solver = new TaskX();
		solver.solve(1, in, out);
		out.close();
	}

	static class TaskX {
		public void solve(int testNumber, InputReader in, PrintWriter out) {

			int n = in.nextInt();
			int k = in.nextInt();
			P[] ps = new P[n];
			long[] xs = new long[n];
			long[] ys = new long[n];

			for (int i = 0; i < n; i++) {
				long x = in.nextLong();
				long y = in.nextLong();
				ps[i] = new P(x, y);
				xs[i] = x;
				ys[i] = y;
			}

			long sum = Long.MAX_VALUE;
			for (int x1 = 0; x1 < n; x1++) {
				for (int x2 = 0; x2 < n; x2++) {
					for (int y1 = 0; y1 < n; y1++) {
						for (int y2 = 0; y2 < n; y2++) {
							int count = 0;
							long xl = min(xs[x1], xs[x2]);
							long xr = max(xs[x1], xs[x2]);
							long yd = min(ys[y1], ys[y2]);
							long yu = max(ys[y1], ys[y2]);

							for (int i = 0; i < n; i++) {
								if (xl <= ps[i].x && ps[i].x <= xr
										&& yd <= ps[i].y && ps[i].y <= yu) {
									count++;
								}
								if (count >= k) {
									sum = min(sum, abs(xr-xl)*abs(yu-yd));
								}
							}
						}
					}
				}
			}
			out.println(sum);
		}
	}

	static class P {
		long x, y;
		P(long x, long y) {
			this.x = x;
			this.y = y;
		}
	}

	static class InputReader {
		BufferedReader in;
		StringTokenizer tok;

		public String nextString() {
			while (!tok.hasMoreTokens()) {
				try {
					tok = new StringTokenizer(in.readLine(), " ");
				} catch (IOException e) {
					throw new InputMismatchException();
				}
			}
			return tok.nextToken();
		}

		public int nextInt() {
			return Integer.parseInt(nextString());
		}

		public long nextLong() {
			return Long.parseLong(nextString());
		}

		public int[] nextIntArray(int n) {
			int[] res = new int[n];
			for (int i = 0; i < n; i++) {
				res[i] = nextInt();
			}
			return res;
		}

		public long[] nextLongArray(int n) {
			long[] res = new long[n];
			for (int i = 0; i < n; i++) {
				res[i] = nextLong();
			}
			return res;
		}

		public InputReader(InputStream inputStream) {
			in = new BufferedReader(new InputStreamReader(inputStream));
			tok = new StringTokenizer("");
		}

	}

}