void main()
{
    long n, k;
    rdVals(n, k);
    Coord[] p = n.rdCol!Coord;

    long[] xlist = new long[n], ylist = new long[n];
    foreach (i; 0 .. n)
    {
        xlist[i] = p[i].x, ylist[i] = p[i].y;
    }
    xlist.sort!"a < b", ylist.sort!"a < b";

    long result = (xlist[$-1] - xlist[0]) * (ylist[$-1] - ylist[0]);
    foreach (i; 0 .. n-1)
    {
        foreach (j; i+1 .. n)
        {
            foreach (s; 0 .. n-1)
            {
                foreach (t; s+1 .. n)
                {
                    Coord u = Coord(xlist[i], ylist[s]);
                    Coord v = Coord(xlist[j], ylist[t]);
                    long cnt;
                    foreach (d; p)
                    {
                        if (d.check(u, v)) ++cnt;
                    }
                    if (cnt >= k)
                    {
                        Coord diff = v - u;
                        result = min(result, diff.area);
                    }
                }
            }
        }
    }

    result.writeln;
}


struct Coord
{
    long x, y;

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

    Coord opBinary(string op)(Coord that)
    if (op == "+")
    {
        return Coord(this.x + that.x, this.y + that.y);
    }

    Coord opBinary(string op)(Coord that)
    if (op == "-")
    {
        return Coord(this.x - that.x, this.y - that.y);
    }

    bool check(Coord l, Coord r)
    {
        return l.x <= this.x && this.x <= r.x && l.y <= this.y && this.y <= r.y;
    }

    long area()
    {
        return this.x * this.y;
    }
}

enum long mod = 10^^9 + 7;
enum long inf = 1L << 60;

T rdElem(T = long)()
if (!is(T == struct))
{
    return readln.chomp.to!T;
}

alias rdStr = rdElem!string;
alias rdDchar = rdElem!(dchar[]);

T rdElem(T)()
if (is(T == struct))
{
    T result;
    string[] input = rdRow!string;
    assert(T.tupleof.length == input.length);
    foreach (i, ref x; result.tupleof)
    {
        x = input[i].to!(typeof(x));
    }
    return result;
}

T[] rdRow(T = long)()
{
    return readln.split.to!(T[]);
}

T[] rdCol(T = long)(long col)
{
    return iota(col).map!(x => rdElem!T).array;
}

T[][] rdMat(T = long)(long col)
{
    return iota(col).map!(x => rdRow!T).array;
}

void rdVals(T...)(ref T data)
{
    string[] input = rdRow!string;
    assert(data.length == input.length);
    foreach (i, ref x; data)
    {
        x = input[i].to!(typeof(x));
    }
}

void wrMat(T = long)(T[][] mat)
{
    foreach (row; mat)
    {
        foreach (j, compo; row)
        {
            compo.write;
            if (j == row.length - 1) writeln;
            else " ".write;
        }
    }
}

import std.stdio;
import std.string;
import std.array;
import std.conv;
import std.algorithm;
import std.range;
import std.math;
import std.numeric;
import std.traits;
import std.container;
import std.functional;
import std.typecons;
import std.ascii;
import std.uni;