#include <stdio.h>

#include <algorithm>

using namespace std;

struct point
{
    int x, y;
};

int n, m, sol = 2000000000;
point v[305];
int sub[305][305];

inline int cmp (point a, point b)
{
    if (a.x != b.x)
        return a.x < b.x;
    return a.y < b.y;
}

inline int cmp2 (int i, int j)
{
    return cmp (v[i], v[j]);
}

inline int semn (point a, point b, point c)
{
    return a.x * (b.y - c.y) + a.y * (c.x - b.x) + (b.x * c.y) - (b.y * c.x);
}

void prec ()
{
    int i, j, k;

    for (i = 1; i <= n; i ++)
        for (j = i + 1; j <= n; j ++)
        {
            for (k = i + 1; k < j; k ++)
                if (semn (v[i], v[j], v[k]) < 0)
                    sub[i][j] ++;
            sub[j][i] = sub[i][j];
        }
}

int main ()
{
    freopen ("popandai.in", "r", stdin);
    freopen ("popandai.out", "w", stdout);

    scanf ("%d %d", &n, &m);

    int i, j, k;

    for (i = 1; i <= n; i ++)
        scanf ("%d %d", &v[i].x, &v[i].y);

    sort (v + 1, v + n + 1, cmp);

    prec ();

    int sus[305], jos[305], o[5], nr;

    for (i = 1; i <= n; i ++)
        for (j = i + 1; j <= n; j ++)
        {
            for (k = 0; k <= n; k ++)
                sus[k] = jos[k] = 1000000000;

            for (k = 1; k <= n; k ++)
                if (i != k && j != k)
                {
                    o[1] = i;
                    o[2] = j;
                    o[3] = k;
                    sort (o + 1, o + 4, cmp2);

                    if (semn (v[o[1]], v[o[2]], v[o[3]]) < 0)
                        nr = sub[o[1]][o[3]] + sub[o[1]][o[2]] - sub[o[2]][o[3]];
                    else
                        nr = sub[o[1]][o[3]] - sub[o[1]][o[2]] - sub[o[2]][o[3]] - 1;

                    if (semn (v[i], v[j], v[k]) < 0)
                        jos [nr] = min (jos[nr], abs (semn (v[i], v[j], v[k])));
                    else
                        sus [nr] = min (sus[nr], abs (semn (v[i], v[j], v[k])));
                }

            for (k = n - 1; k >= 0; k --)
            {
                sus[k] = min (sus[k], sus[k + 1]);
                jos[k] = min (jos[k], jos[k + 1]);
            }
            for (k = 0; k <= m; k ++)
                sol = min (sol, sus[k] + jos[m - k]);
        }

    printf ("%lf\n", sol * 0.5);

    return 0;
}