import std.stdio, std.string, std.conv;
import std.algorithm, std.array;
auto solve(string s_) {
    auto NK = s_.split.map!(to!long)();
    immutable N=NK[0], K=NK[1];
    auto xys = new long[2][N];
    long[] xs; xs.reserve(N);
    long[] ys; ys.reserve(N);
    foreach(ref xy;xys) {
        xy=readln.split.map!(to!long).array();
        xs~=xy[0];
        ys~=xy[1];
    }
    xs=xs.sort.uniq.array();
    ys=ys.sort.uniq.array();
    immutable xn=xs.length;
    immutable yn=ys.length;
    auto dp=new int[][](xn,yn);
    foreach(ref xy;xys) {
        long idx(long[] as, long v) {
            long l=0,r=as.length-1;
            while(l!=r) {
                immutable m=(l+r)/2;
                if(as[m]==v) return m;
                if(as[m]<v) l=m+1;
                else        r=m-1;
            }
            return l;
        }
        immutable xi=idx(xs,xy[0]);
        immutable yi=idx(ys,xy[1]);
        dp[idx(xs,xy[0])][idx(ys,xy[1])]++;
    }
    foreach(xi;0..xn) foreach(yi;0..yn) {
        if(xi!=0) dp[xi][yi]+=dp[xi-1][yi];
        if(yi!=0) dp[xi][yi]+=dp[xi][yi-1];
        if(xi!=0 && yi!=0) dp[xi][yi]-=dp[xi-1][yi-1];
    }
    long m=long.max;
    foreach(xi;0..xn-1) foreach(yi;0..yn-1) {
        foreach(xj;xi..xn) foreach(yj;yi..yn) {
            auto c=dp[xj][yj];
            if(xi!=0) c-=dp[xi-1][yj];
            if(yi!=0) c-=dp[xj][yi-1];
            if(xi!=0 && yi!=0) c+=dp[xi-1][yi-1];
            if(c<K) continue;
            m=min(m,(xs[xj]-xs[xi])*(ys[yj]-ys[yi]));
        }
    }
    return m;
}
void main(){ for(string s; (s=readln.chomp()).length;) writeln(solve(s)); }