import std.stdio, std.string, std.conv, std.algorithm;
import std.range, std.array, std.math, std.typecons, std.container, core.bitop;

immutable mod = 10^^9 + 7;

void main() {
    int n, k;
    scan(n, k);

    auto x = new int[](n), y = new int[](n);

    foreach (i ; 0 .. n) {
        scan(x[i], y[i]);
    }

    long ans = long.max;

    if (k == 2) {
        foreach (i ; 0 .. n) {
            foreach (j ; i + 1 .. n) {
                int xl = min(x[i], x[j]), xr = x[i] + x[j] - xl;
                int yb = min(y[i], y[j]), yt = y[i] + y[j] - yb;

                ans = min(ans, 1L * (xr - xl) * (yt - yb));
            }
        }
    }
    else if (k == 3) {
        foreach (i ; 0 .. n) {
            foreach (j ; i + 1 .. n) {
                foreach (l ; j + 1 .. n) {
                    int xl = [x[i], x[j], x[l]].reduce!min, xr = [x[i], x[j], x[l]].reduce!max;
                    int yb = [y[i], y[j], y[l]].reduce!min, yt = [y[i], y[j], y[l]].reduce!max;

                    ans = min(ans, 1L * (xr - xl) * (yt - yb));
                }
            }
        }
    }
    else {
        foreach (i ; 0 .. n) {
            foreach (j ; i + 1 .. n) {
                foreach (l ; j + 1 .. n) {
                    foreach (m ; l + 1 .. n) {
                        int xl = [x[i], x[j], x[l], x[m]].reduce!min;
                        int xr = [x[i], x[j], x[l], x[m]].reduce!max;
                        int yb = [y[i], y[j], y[l], y[m]].reduce!min;
                        int yt = [y[i], y[j], y[l], y[m]].reduce!max;

                        int cnt;

                        foreach (a ; 0 .. n) {
                            if (xl <= x[a] && x[a] <= xr && yb <= y[a] && y[a] <= yt) cnt++;
                        }

                        if (cnt >= k) {
                            ans = min(ans, 1L * (xr - xl) * (yt - yb));
                        }
                    }
                }
            }
        }
    }

    writeln(ans);
}



void scan(T...)(ref T args) {
    string[] line = readln.split;
    foreach (ref arg; args) {
        arg = line.front.to!(typeof(arg));
        line.popFront();
    }
    assert(line.empty);
}



void fillAll(R, T)(ref R arr, T value) {
    static if (is(typeof(arr[] = value))) {
        arr[] = value;
    }
    else {
        foreach (ref e; arr) {
            fillAll(e, value);
        }
    }
}