#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 min (int a, int b) {return a < b ? a : b;}
 
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)
{
    if (v[i].x != v[j].x)
        return v[i].x < v[j].x;
    return v[i].y < v[j].y;
}
 
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] = 2000000000;
 
            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[2]] + sub[o[2]][o[3]] - sub[o[1]][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 ++)
                if (sus[k] == 2000000000 || jos[m - k] == 2000000000)
                    continue;
                else
                    sol = min (sol, sus[k] + jos[m - k]);
        }
 
    printf ("%lf\n", sol * 0.5);
 
    return 0;
}