#include <fstream>
#include <algorithm>
#include <iomanip>

using namespace std;

const char InFile[]="popandai.in";
const char OutFile[]="popandai.out";
const int MaxN=305;
const double DINF=1e32;

ifstream fin(InFile);
ofstream fout(OutFile);

struct Point
{
	Point(int x=0, int y=0):x(x),y(y){}
	int x,y;
};

struct Point_CMP
{
	inline bool operator() (const Point &A, const Point &B)
	{
		return A.x<B.x;
	}
};

int N,K,D[MaxN][MaxN];
double Best[MaxN],sol=DINF;
Point P[MaxN];

inline int Det(const Point &A, const Point &B, const Point &C)
{
	long long sol=1LL*(B.x-A.x)*(C.y-A.y)-1LL*(B.y-A.y)*(C.x-A.x);
	if(sol<0)
	{
		return -1;
	}
	return 1;
}

inline double Arie(const Point &A, const Point &B, const Point &C)
{
	double sol=1.0*(B.x-A.x)*(C.y-A.y)-1.0*(B.y-A.y)*(C.x-A.x);
	if(sol<0)
	{
		sol*=-1.0;
	}
	return sol*0.5;
}

inline int Query(const int &p1, const int &p2, const int &p3)
{
	int p[3];
	p[0]=p1;
	p[1]=p2;
	p[2]=p3;
	sort(p,p+3);
	int sol;
	if(Det(P[p[0]],P[p[2]],P[p[1]])<0)
	{
		sol=D[p[0]][p[2]]-D[p[0]][p[1]]-D[p[1]][p[2]]-1;
	}
	else
	{
		sol=D[p[0]][p[1]]+D[p[1]][p[2]]-D[p[0]][p[2]];
	}
	return sol;
}

int main()
{
	fin>>N>>K;
	for(register int i=1;i<=N;++i)
	{
		fin>>P[i].x>>P[i].y;
	}
	fin.close();
	
	sort(P+1,P+1+N,Point_CMP());
	
	for(register int i=1;i<=N;++i)
	{
		for(register int j=i+1;j<=N;++j)
		{
			for(register int k=i+1;k<j;++k)
			{
				if(Det(P[i],P[j],P[k])<0)
				{
					++D[i][j];
				}
			}
		}
	}
	
	for(register int i=1;i<=N;++i)
	{
		for(register int j=i+1;j<=N;++j)
		{
			for(register int k=0;k<=N;++k)
			{
				Best[k]=DINF;
			}
			for(register int k=1;k<=N;++k)
			{
				if(Det(P[i],P[j],P[k])<0 && k!=i && k!=j)
				{
					int pct=Query(i,j,k);
					Best[pct]=min(Best[pct],Arie(P[i],P[j],P[k]));
				}
			}
			for(register int k=N-1;k>=0;--k)
			{
				Best[k]=min(Best[k],Best[k+1]);
			}
			for(register int k=1;k<=N;++k)
			{
				if(Det(P[i],P[j],P[k])>0 && k!=i && k!=j)
				{
					int pct=Query(i,j,k);
					if(K-pct<0)
					{
						pct=0;
					}
					sol=min(sol,Arie(P[i],P[j],P[k])+Best[K-pct]);
				}
			}
		}
	}
	
	fout<<fixed<<setprecision(1)<<sol;
	fout.close();
	return 0;
}