#include <fstream>
#include <cmath>
#include <algorithm>
#include <cstdio>
#define INF 1000000000.0
using namespace std;
int n, K, nr[2][310][310];
struct Punct{double x, y;};
Punct P[310];
double best[310], sol = INF;

inline void Citire()
{
	int i;
	ifstream fin("popandai.in");
	fin >> n >> K;
	for(i = 1; i <= n; ++i)
		fin >> P[i].x >> P[i].y;
	fin.close();
}

inline double Det(Punct A, Punct B, Punct C)
{
	return 0.5 * ( A.x * B.y + B.x * C.y + C.x * A.y - A.y * B.x - B.y * C.x - C.y * A.x);
}

inline void Preprocesare()
{
	int i, j, k;
	for(i = 1; i <= n; ++i)
	{
		for(j = 1; j <= n; ++j)
		{
			if(i == j)
				continue;
			for(k = 1; k <= n; ++k)
			{
				if(k == i || k == j)
					continue;
				if(P[k].x >= min(P[i].x, P[j].x) && P[k].x < max(P[i].x, P[j].x))
				{
					if(Det(P[i], P[j], P[k]) < 0.0)
						nr[0][i][j]++;
					else
						nr[1][i][j]++;
				}
			}
		}
	}
}

inline bool Sortare(int a, int b)
{
	if(P[a].x == P[b].x)
		return P[a].y > P[b].y;
	return P[a].x < P[b].x;
}

inline int Count(int i,int j,int k)
{
	int a, b, c;
	int ord[] = {i, j, k};
	sort(ord, ord + 3, Sortare);
	a = ord[0];
	b = ord[1];
	c = ord[2];
	if(Det(P[a], P[c], P[b]) > 0.0)
		return nr[0][a][b] + nr[0][b][c] - nr[0][a][c];
	return nr[0][a][c] - nr[0][a][b] - nr[0][b][c] - 1;
}

inline void Rezolvare()
{
	int i, j, k, vizuine;
	for(i = 1; i <= n; ++i)
	{
		for(j = i + 1; j <= n; ++j)
		{
			for(k = 0; k <= n; ++k)
				best[k] = INF;
			// best[nr] = aria minima a unui triunghi facut de 
			// P[i], P[j] si un punct din stanga dreptei (P[i], P[j])
			// care are in interior cel putin nr puncte
			for(k = 1; k <= n; ++k)
			{
				if(k == i || k == j)
					continue;
				if(Det(P[i], P[j], P[k]) < 0.0)
				{
					vizuine = Count(i, j, k);
					best[vizuine] = min(best[vizuine], fabs(Det(P[i], P[j], P[k])));
				}
			}
			for(k = n - 1; k >= 0; --k)
				best[k] = min(best[k], best[k + 1]);
			for(k = 1; k <= n; ++k)
			{
				if(k == i || k == j)
					continue;
				if(Det(P[i], P[j], P[k]) > 0.0)
				{
					vizuine = Count(i, j, k);
					if(vizuine <= K)
						sol = min(sol, Det(P[i], P[j], P[k]) + best[K - vizuine]);
					else
						sol = min(sol, Det(P[i], P[j], P[k]) + best[0]);
				}
			}
		}
	}
}

inline void Afisare()
{
	freopen("popandai.out", "w", stdout);
	printf("%.1lf\n", sol);
}

int main()
{
	Citire();
	Preprocesare();
	Rezolvare();
	Afisare();
	return 0;
}