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 PYTHON):

Solution:
import sys
from collections import deque
import copy
 
from math import *
 
def get_read_func(fileobject):
    if fileobject == None :
        return raw_input
    else:
        return fileobject.readline
 
def main():
    if len(sys.argv) > 1:
        f = open(sys.argv[1])
    else:
        f = None
    read_func = get_read_func(f);
    input_raw = read_func().strip().split()
    [N, K] =  [long(input_raw[0]), long(input_raw[1])]
    x_list = [0 for i in range(N)]
    y_list = [0 for i in range(N)]
    point_set = set([])
    for i in range(N):
        input_raw = read_func().strip().split()
        [x, y] =  [long(input_raw[0]), long(input_raw[1])]
        x_list[i] = x
        y_list[i] = y
        point_set.add((x, y))
    h = {}
    gx = {}
    gy = {}
    for x in x_list:
        for y in y_list:
            num = 0
            num_gx = 0
            num_gy = 0
            for i in range(N):
                if x <= x_list[i] and y <= y_list[i]:
                    num += 1
                if x == x_list[i] and y <= y_list[i]:
                    num_gx += 1
                if y == y_list[i] and x <= x_list[i]:
                    num_gy += 1
            h[(x, y)] = num
            gx[(x, y)] = num_gx
            gy[(y, x)] = num_gy
##    for point in point_set:
##        for y in y_list: #count x point num of more y
##            if (point[0], y) not in gx:
##                gx[(point[0], y)] = 0
##            if point[1] >= y:
##                gx[(point[0], y)] += 1L
##
##    for point in point_set:
##        for x in x_list: #count y point num of more x
##            if (point[1], x) not in gy:
##                gy[(point[1], x)] = 0
##            if point[0] >= x:
##                gy[(point[1], x)] += 1L
 
 
    min_S = long(sys.maxint) * long(sys.maxint)
    for i in range(N):
        for j in range(i + 1, N):
            for m in range(N):
                for n in range(m + 1, N):
                    x1 = min(x_list[i], x_list[j])
                    x2 = max(x_list[i], x_list[j])
                    y1 = min(y_list[m], y_list[n])
                    y2 = max(y_list[m], y_list[n])
                    in_num =  (h[(x1, y1)] - h[(x2, y1)] - h[(x1, y2)] + h[(x2, y2)] +
                                gx[(x2, y1)] - gx[(x2, y2)] + gy[(y2, x1)] - gy[(y2, x2)] +
                                  (1 if (x2, y2) in point_set else 0))
##                    in_num = 0
##                    for k in range(N):
##                        xk = x_list[k]
##                        yk = y_list[k]
##                        if (xk <= max(x1, x2) and xk >= min(x1, x2) and
##                            yk <= max(y1, y2) and yk >= min(y1, y2)):
##                                in_num += 1
##                        if in_num >= K:
##                            break
                    if in_num >= K:
                        S= abs(x1 - x2) * abs(y1 - y2)
                        if S < min_S:
                            min_S = S
    print min_S
 
 
 
if __name__ == '__main__':
    main()