Buggy python submission (verdict: Time Limit Exceeded):
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()

Fixed submission:
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()

Buggy python submission (verdict: Time Limit Exceeded):
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 = []
    y_list = []
    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.append(x)
        y_list.append(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


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

                    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()


Fixed submission:
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()

Buggy python submission (verdict: Time Limit Exceeded):
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 = []
    y_list = []
    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.append(x)
        y_list.append(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, N):
            for m in range(N):
                for n in range(m, 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()


Fixed submission:
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()

Buggy python submission (verdict: Time Limit Exceeded):
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 = []
    y_list = []
    for i in range(N):
        input_raw = read_func().strip().split()
        [x, y] =  [long(input_raw[0]), long(input_raw[1])]
        x_list.append(x)
        y_list.append(y)

    min_S = long(sys.maxint) * long(sys.maxint)
    for i in range(N):
        for j in range(i, N):
            for m in range(N):
                for n in range(m, N):
                    x1 = x_list[i]
                    x2 = x_list[j]
                    y1 = y_list[m]
                    y2 = y_list[n]
                    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()


Fixed submission:
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()

Buggy python submission (verdict: Time Limit Exceeded):
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 = []
    y_list = []
    for i in range(N):
        input_raw = read_func().strip().split()
        [x, y] =  [long(input_raw[0]), long(input_raw[1])]
        x_list.append(x)
        y_list.append(y)

    min_S = long(sys.maxint) * long(sys.maxint)
    for i in range(N):
        for j in range(N):
            for m in range(N):
                for n in range(N):
                    x1 = x_list[i]
                    x2 = x_list[j]
                    y1 = y_list[m]
                    y2 = y_list[n]
                    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()

Fixed submission:
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()