#include <vector>
#include <numeric>
#include <list>
#include <map>
#include <set>
#include <deque>
#include <queue>
#include <stack>
#include <bitset>
#include <algorithm>
#include <sstream>
#include <iostream>
#include <fstream>
#include <cstdio>
#include <cmath>
#include <cstdlib>
#include <cctype>
#include <string>
#include <cstring>
#include <ctime>
#include <limits>
#include <iomanip>

using namespace std;

#define FOR(i,a,b)		for(int i=(a),_b=(b);i<(_b);++i)
#define FORD(i,a,b)		for(int i=(a),_b=(b);i>(_b);--i)
#define pb			push_back
#define mp			make_pair
#define	all(c)			(c).begin(),(c).end()
#define	tr(c,i)	for(typeof((c).begin()) i = (c).begin(); i != (c).end(); i++)
#define	present(c,x)		((c).find(x) != (c).end())
#define	cpresent(c,x)		(find(all(c),x) != (c).end())

typedef long long			ll;
typedef unsigned long long	ull;
typedef unsigned char	 	byte;
typedef vector<int>			vi;
typedef pair<int, int>		pii;
typedef pair<ll, ll>		pll;
typedef vector<pii>			vpii;

const int MX = 25;

int crossproduct(pii &v1, pii &v2)
{
	return v1.first*v2.second - v2.first*v1.second;
}

int main(int argc, char *argv[])
{
#ifndef ONLINE_JUDGE
	freopen(argv[1],"r",stdin);
#endif
#ifndef ONLINE_JUDGE
	ifstream cin(argv[1]);
#endif
#if 0
	ofstream cout(argv[2]);
#endif
	int n;
	cin >> n;
	pii a[n];
	FOR(i,0,n) cin >> a[i].first >> a[i].second;
	int ans = 0;
	FOR(i,0,n) FOR(j,i+1,n) {
		pii v1(pii(a[i].first-a[j].first,a[i].second-a[j].second));
		int mx = -1e-19, mn = 1e+9;
		FOR(k,0,n) {
			if (k != i && k != j) {
				pii v2(pii(a[k].first-a[i].first,a[k].second-a[i].second));
				int area = crossproduct(v1,v2);
				if (area < 0) mn = min(area,mn);
				else mx = max(mx,area);
			}
		}
		ans = max(ans,mx-mn);
	}
	printf("%.9f\n",0.5*ans);
	return 0;
}


#include <vector>
#include <numeric>
#include <list>
#include <map>
#include <set>
#include <deque>
#include <queue>
#include <stack>
#include <bitset>
#include <algorithm>
#include <sstream>
#include <iostream>
#include <fstream>
#include <cstdio>
#include <cmath>
#include <cstdlib>
#include <cctype>
#include <string>
#include <cstring>
#include <ctime>
#include <limits>
#include <iomanip>

using namespace std;

#define FOR(i,a,b)		for(int i=(a),_b=(b);i<(_b);++i)
#define FORD(i,a,b)		for(int i=(a),_b=(b);i>(_b);--i)
#define pb			push_back
#define mp			make_pair
#define	all(c)			(c).begin(),(c).end()
#define	tr(c,i)	for(typeof((c).begin()) i = (c).begin(); i != (c).end(); i++)
#define	present(c,x)		((c).find(x) != (c).end())
#define	cpresent(c,x)		(find(all(c),x) != (c).end())

typedef long long			ll;
typedef unsigned long long	ull;
typedef unsigned char	 	byte;
typedef vector<int>			vi;
typedef pair<int, int>		pii;
typedef pair<ll, ll>		pll;
typedef vector<pii>			vpii;

const int MX = 25;

int crossproduct(pii &v1, pii &v2)
{
	return v1.first*v2.second - v2.first*v1.second;
}

int main(int argc, char *argv[])
{
#ifndef ONLINE_JUDGE
	freopen(argv[1],"r",stdin);
#endif
#ifndef ONLINE_JUDGE
	ifstream cin(argv[1]);
#endif
#if 0
	ofstream cout(argv[2]);
#endif
	int n;
	cin >> n;
	pii a[n];
	FOR(i,0,n) cin >> a[i].first >> a[i].second;
	int ans = 0;
	FOR(i,0,n) FOR(j,i+1,n) {
		pii v1(pii(a[i].first-a[j].first,a[i].second-a[j].second));
		int mx = -1e-19, mn = 1e+9;
		FOR(k,0,n) {
			if (k != i && k != j) {
				pii v2(pii(a[k].first-a[j].first,a[k].second-a[j].second));
				int area = crossproduct(v1,v2);
				if (area < 0) mn = min(area,mn);
				else mx = max(mx,area);
			}
		}
		ans = max(ans,mx-mn);
	}
	printf("%.9f\n",0.5*ans);
	return 0;
}


#include <vector>
#include <numeric>
#include <list>
#include <map>
#include <set>
#include <deque>
#include <queue>
#include <stack>
#include <bitset>
#include <algorithm>
#include <sstream>
#include <iostream>
#include <fstream>
#include <cstdio>
#include <cmath>
#include <cstdlib>
#include <cctype>
#include <string>
#include <cstring>
#include <ctime>
#include <limits>
#include <iomanip>

using namespace std;

#define FOR(i,a,b)		for(int i=(a),_b=(b);i<(_b);++i)
#define FORD(i,a,b)		for(int i=(a),_b=(b);i>(_b);--i)
#define pb			push_back
#define mp			make_pair
#define	all(c)			(c).begin(),(c).end()
#define	tr(c,i)	for(typeof((c).begin()) i = (c).begin(); i != (c).end(); i++)
#define	present(c,x)		((c).find(x) != (c).end())
#define	cpresent(c,x)		(find(all(c),x) != (c).end())

typedef long long			ll;
typedef unsigned long long	ull;
typedef unsigned char	 	byte;
typedef vector<int>			vi;
typedef pair<int, int>		pii;
typedef pair<ll, ll>		pll;
typedef vector<pii>			vpii;

const int MX = 25;

bool mysort(pii a, pii b)
{
	if (a.first != b.first) return a.first < b.first;
	return a.second > b.second;
}

int main(int argc, char *argv[])
{
#ifndef ONLINE_JUDGE
	freopen(argv[1],"r",stdin);
#endif
#ifndef ONLINE_JUDGE
	ifstream cin(argv[1]);
#endif
#if 0
	ofstream cout(argv[2]);
#endif
	int n;
	cin >> n;
	pair<ll,ll> a[n],b[n];
	FOR(i,0,n) cin >> a[i].first >> a[i].second;
	double ans = 0;
	FOR(i,0,n) FOR(j,i+1,n) FOR(k,j+1,n) FOR(l,k+1,n) {
		int x1 = a[i].first, y1 = a[i].second;
		int x2 = a[j].first, y2 = a[j].second;
		int x3 = a[k].first, y3 = a[k].second;
		int x4 = a[l].first, y4 = a[l].second;
		ll sa = (x1-x2)*(x1-x2)+(y1-y2)*(y1-y2);
		ll sb = (x3-x2)*(x3-x2)+(y3-y2)*(y3-y2);
		ll sc = (x4-x3)*(x4-x3)+(y4-y3)*(y4-y3);
		ll sd = (x1-x4)*(x1-x4)+(y1-y4)*(y1-y4);
		ll sD = (x1-x3)*(x1-x3)+(y1-y3)*(y1-y3);
		ll a1 = (sa+sb+sD)*(sa+sb+sD)-2*(sa*sa+sb*sb+sD*sD);
		ll a2 = (sc+sd+sD)*(sc+sd+sD)-2*(sc*sc+sd*sd+sD*sD);
		ans = max(ans,sqrt(a1)+sqrt(a2));
	}
	printf("%.9f\n",0.25*ans);
	return 0;
}


#include <vector>
#include <numeric>
#include <list>
#include <map>
#include <set>
#include <deque>
#include <queue>
#include <stack>
#include <bitset>
#include <algorithm>
#include <sstream>
#include <iostream>
#include <fstream>
#include <cstdio>
#include <cmath>
#include <cstdlib>
#include <cctype>
#include <string>
#include <cstring>
#include <ctime>
#include <limits>
#include <iomanip>

using namespace std;

#define FOR(i,a,b)		for(int i=(a),_b=(b);i<(_b);++i)
#define FORD(i,a,b)		for(int i=(a),_b=(b);i>(_b);--i)
#define pb			push_back
#define mp			make_pair
#define	all(c)			(c).begin(),(c).end()
#define	tr(c,i)	for(typeof((c).begin()) i = (c).begin(); i != (c).end(); i++)
#define	present(c,x)		((c).find(x) != (c).end())
#define	cpresent(c,x)		(find(all(c),x) != (c).end())

typedef long long			ll;
typedef unsigned long long	ull;
typedef unsigned char	 	byte;
typedef vector<int>			vi;
typedef pair<int, int>		pii;
typedef pair<ll, ll>		pll;
typedef vector<pii>			vpii;

const int MX = 25;

bool mysort(pii a, pii b)
{
	if (a.first != b.first) return a.first < b.first;
	return a.second > b.second;
}

int main(int argc, char *argv[])
{
#ifndef ONLINE_JUDGE
	freopen(argv[1],"r",stdin);
#endif
#ifndef ONLINE_JUDGE
	ifstream cin(argv[1]);
#endif
#if 0
	ofstream cout(argv[2]);
#endif
	int n;
	cin >> n;
	pair<ll,ll> a[n],b[n];
	FOR(i,0,n) cin >> a[i].first >> a[i].second;
	double ans = 0;
	ll best = 0;
	ll A1 = 0, A2 = 0;
	FOR(i,0,n) FOR(j,i+1,n) FOR(k,j+1,n) FOR(l,k+1,n) {
		int x1 = a[i].first, y1 = a[i].second;
		int x2 = a[j].first, y2 = a[j].second;
		int x3 = a[k].first, y3 = a[k].second;
		int x4 = a[l].first, y4 = a[l].second;
		ll sa = (x1-x2)*(x1-x2)+(y1-y2)*(y1-y2);
		ll sb = (x3-x2)*(x3-x2)+(y3-y2)*(y3-y2);
		ll sc = (x4-x3)*(x4-x3)+(y4-y3)*(y4-y3);
		ll sd = (x1-x4)*(x1-x4)+(y1-y4)*(y1-y4);
		ll sD = (x1-x3)*(x1-x3)+(y1-y3)*(y1-y3);
		ll a1 = (sa+sb+sD)*(sa+sb+sD)-2*(sa*sa+sb*sb+sD*sD);
		ll a2 = (sc+sd+sD)*(sc+sd+sD)-2*(sc*sc+sd*sd+sD*sD);
		ans = max(ans,(a1+a2+2*sqrt(a1*a2)));
	}
	printf("%.9f\n",0.25*sqrt(ans));
	return 0;
}


#include <vector>
#include <numeric>
#include <list>
#include <map>
#include <set>
#include <deque>
#include <queue>
#include <stack>
#include <bitset>
#include <algorithm>
#include <sstream>
#include <iostream>
#include <fstream>
#include <cstdio>
#include <cmath>
#include <cstdlib>
#include <cctype>
#include <string>
#include <cstring>
#include <ctime>
#include <limits>
#include <iomanip>

using namespace std;

#define FOR(i,a,b)		for(int i=(a),_b=(b);i<(_b);++i)
#define FORD(i,a,b)		for(int i=(a),_b=(b);i>(_b);--i)
#define pb			push_back
#define mp			make_pair
#define	all(c)			(c).begin(),(c).end()
#define	tr(c,i)	for(typeof((c).begin()) i = (c).begin(); i != (c).end(); i++)
#define	present(c,x)		((c).find(x) != (c).end())
#define	cpresent(c,x)		(find(all(c),x) != (c).end())

typedef long long			ll;
typedef unsigned long long	ull;
typedef unsigned char	 	byte;
typedef vector<int>			vi;
typedef pair<int, int>		pii;
typedef pair<ll, ll>		pll;
typedef vector<pii>			vpii;

const int MX = 25;

bool mysort(pii a, pii b)
{
	if (a.first != b.first) return a.first < b.first;
	return a.second > b.second;
}

int main(int argc, char *argv[])
{
#ifndef ONLINE_JUDGE
	freopen(argv[1],"r",stdin);
#endif
#ifndef ONLINE_JUDGE
	ifstream cin(argv[1]);
#endif
#if 0
	ofstream cout(argv[2]);
#endif
	int n;
	cin >> n;
	pii a[n],b[n];
	FOR(i,0,n) cin >> a[i].first >> a[i].second;
	FOR(i,0,n) b[i].first = a[i].second, b[i].second = a[i].first;
	sort(a,a+n,mysort);
	sort(b,b+n,mysort);
	double ans = 0;
	FOR(i,0,n) FOR(j,i+1,n-1) {
		int x1 = a[0].first, y1 = a[0].second;
		int x2 = a[i].first, y2 = a[i].second;
		int x3 = a[j].first, y3 = a[j].second;
		int x4 = a[n-1].first, y4 = a[n-1].second;
		double sa = (x1-x2)*(x1-x2)+(y1-y2)*(y1-y2);
		double sb = (x3-x2)*(x3-x2)+(y3-y2)*(y3-y2);
		double sc = (x4-x3)*(x4-x3)+(y4-y3)*(y4-y3);
		double sd = (x1-x4)*(x1-x4)+(y1-y4)*(y1-y4);
		double sD = (x1-x3)*(x1-x3)+(y1-y3)*(y1-y3);
		double a1 = 0.25*sqrt((sa+sb+sD)*(sa+sb+sD)-2*(sa*sa+sb*sb+sD*sD));
		double a2 = 0.25*sqrt((sc+sd+sD)*(sc+sd+sD)-2*(sc*sc+sd*sd+sD*sD));
		ans = max(ans,a1+a2);
	}
	FOR(i,1,n-2) FOR(j,i+1,n-1) {
		int y1 = b[0].first, x1 = b[0].second;
		int y2 = b[i].first, x2 = b[i].second;
		int y3 = b[j].first, x3 = b[j].second;
		int y4 = b[n-1].first, x4 = b[n-1].second;
		double sa = (x1-x2)*(x1-x2)+(y1-y2)*(y1-y2);
		double sb = (x3-x2)*(x3-x2)+(y3-y2)*(y3-y2);
		double sc = (x4-x3)*(x4-x3)+(y4-y3)*(y4-y3);
		double sd = (x1-x4)*(x1-x4)+(y1-y4)*(y1-y4);
		double sD = (x1-x3)*(x1-x3)+(y1-y3)*(y1-y3);
		double a1 = 0.25*sqrt((sa+sb+sD)*(sa+sb+sD)-2*(sa*sa+sb*sb+sD*sD));
		double a2 = 0.25*sqrt((sc+sd+sD)*(sc+sd+sD)-2*(sc*sc+sd*sd+sD*sD));
		ans = max(ans,a1+a2);
	}
	printf("%.9f\n",ans);
	return 0;
}


#include <vector>
#include <numeric>
#include <list>
#include <map>
#include <set>
#include <deque>
#include <queue>
#include <stack>
#include <bitset>
#include <algorithm>
#include <sstream>
#include <iostream>
#include <fstream>
#include <cstdio>
#include <cmath>
#include <cstdlib>
#include <cctype>
#include <string>
#include <cstring>
#include <ctime>
#include <limits>
#include <iomanip>

using namespace std;

#define FOR(i,a,b)		for(int i=(a),_b=(b);i<(_b);++i)
#define FORD(i,a,b)		for(int i=(a),_b=(b);i>(_b);--i)
#define pb			push_back
#define mp			make_pair
#define	all(c)			(c).begin(),(c).end()
#define	tr(c,i)	for(typeof((c).begin()) i = (c).begin(); i != (c).end(); i++)
#define	present(c,x)		((c).find(x) != (c).end())
#define	cpresent(c,x)		(find(all(c),x) != (c).end())

typedef long long			ll;
typedef unsigned long long	ull;
typedef unsigned char	 	byte;
typedef vector<int>			vi;
typedef pair<int, int>		pii;
typedef pair<ll, ll>		pll;
typedef vector<pii>			vpii;

const int MX = 25;

bool mysort(pii a, pii b)
{
	if (a.first != b.first) return a.first < b.first;
	return a.second > b.second;
}

int main(int argc, char *argv[])
{
#ifndef ONLINE_JUDGE
	freopen(argv[1],"r",stdin);
#endif
#ifndef ONLINE_JUDGE
	ifstream cin(argv[1]);
#endif
#if 0
	ofstream cout(argv[2]);
#endif
	int n;
	cin >> n;
	pii a[n],b[n];
	FOR(i,0,n) cin >> a[i].first >> a[i].second;
	FOR(i,0,n) b[i].first = a[i].second, b[i].second = a[i].first;
	sort(a,a+n,mysort);
	sort(b,b+n,mysort);
	double ans = 0;
	FOR(i,1,n-2) FOR(j,i+1,n-1) {
		int x1 = a[0].first, y1 = a[0].second;
		int x2 = a[i].first, y2 = a[i].second;
		int x3 = a[j].first, y3 = a[j].second;
		int x4 = a[n-1].first, y4 = a[n-1].second;
		double sa = sqrt((x1-x2)*(x1-x2)+(y1-y2)*(y1-y2));
		double sb = sqrt((x3-x2)*(x3-x2)+(y3-y2)*(y3-y2));
		double sc = sqrt((x4-x3)*(x4-x3)+(y4-y3)*(y4-y3));
		double sd = sqrt((x1-x4)*(x1-x4)+(y1-y4)*(y1-y4));
		double sD = sqrt((x1-x3)*(x1-x3)+(y1-y3)*(y1-y3));
		double s1 = 0.5*(sa+sb+sD);
		double s2 = 0.5*(sc+sd+sD);
		double a1 = sqrt(s1*(s1-sa)*(s1-sb)*(s1-sD));
		double a2 = sqrt(s2*(s2-sc)*(s2-sd)*(s2-sD));
		ans = max(ans,a1+a2);
	}
	FOR(i,1,n-2) FOR(j,i+1,n-1) {
		int y1 = b[0].first, x1 = b[0].second;
		int y2 = b[i].first, x2 = b[i].second;
		int y3 = b[j].first, x3 = b[j].second;
		int y4 = b[n-1].first, x4 = b[n-1].second;
		double sa = sqrt((x1-x2)*(x1-x2)+(y1-y2)*(y1-y2));
		double sb = sqrt((x3-x2)*(x3-x2)+(y3-y2)*(y3-y2));
		double sc = sqrt((x4-x3)*(x4-x3)+(y4-y3)*(y4-y3));
		double sd = sqrt((x1-x4)*(x1-x4)+(y1-y4)*(y1-y4));
		double sD = sqrt((x1-x3)*(x1-x3)+(y1-y3)*(y1-y3));
		double s1 = 0.5*(sa+sb+sD);
		double s2 = 0.5*(sc+sd+sD);
		double a1 = sqrt(s1*(s1-sa)*(s1-sb)*(s1-sD));
		double a2 = sqrt(s2*(s2-sc)*(s2-sd)*(s2-sD));
		ans = max(ans,a1+a2);
	}
	cout << ans << endl;
	return 0;
}


#include <vector>
#include <numeric>
#include <list>
#include <map>
#include <set>
#include <deque>
#include <queue>
#include <stack>
#include <bitset>
#include <algorithm>
#include <sstream>
#include <iostream>
#include <fstream>
#include <cstdio>
#include <cmath>
#include <cstdlib>
#include <cctype>
#include <string>
#include <cstring>
#include <ctime>
#include <limits>
#include <iomanip>

using namespace std;

#define FOR(i,a,b)		for(int i=(a),_b=(b);i<(_b);++i)
#define FORD(i,a,b)		for(int i=(a),_b=(b);i>(_b);--i)
#define pb			push_back
#define mp			make_pair
#define	all(c)			(c).begin(),(c).end()
#define	tr(c,i)	for(typeof((c).begin()) i = (c).begin(); i != (c).end(); i++)
#define	present(c,x)		((c).find(x) != (c).end())
#define	cpresent(c,x)		(find(all(c),x) != (c).end())

typedef long long			ll;
typedef unsigned long long	ull;
typedef unsigned char	 	byte;
typedef vector<int>			vi;
typedef pair<int, int>		pii;
typedef pair<ll, ll>		pll;
typedef vector<pii>			vpii;

const int MX = 25;

bool mysort(pii a, pii b)
{
	if (a.first != b.first) return a.first < b.first;
	return a.second > b.second;
}

int main(int argc, char *argv[])
{
#ifndef ONLINE_JUDGE
	freopen(argv[1],"r",stdin);
#endif
#ifndef ONLINE_JUDGE
	ifstream cin(argv[1]);
#endif
#if 0
	ofstream cout(argv[2]);
#endif
	int n;
	cin >> n;
	pii a[n],b[n];
	FOR(i,0,n) cin >> a[i].first >> a[i].second;
	FOR(i,0,n) b[i].first = a[i].second, b[i].second = a[i].first;
	sort(a,a+n,mysort);
	sort(b,b+n,mysort);
	double ans = 0;
	FOR(i,1,n-2) FOR(j,i+1,n-1) {
		int x1 = a[0].first, y1 = a[0].second;
		int x2 = a[i].first, y2 = a[i].second;
		int x3 = a[j].first, y3 = a[j].second;
		int x4 = a[n-1].first, y4 = a[n-1].second;
		double sa = (x1-x2)*(x1-x2)+(y1-y2)*(y1-y2);
		double sb = (x3-x2)*(x3-x2)+(y3-y2)*(y3-y2);
		double sc = (x4-x3)*(x4-x3)+(y4-y3)*(y4-y3);
		double sd = (x1-x4)*(x1-x4)+(y1-y4)*(y1-y4);
		double sD = (x1-x3)*(x1-x3)+(y1-y3)*(y1-y3);
		double a1 = 0.25*sqrt((sa+sb+sD)*(sa+sb+sD)-2*(sa*sa+sb*sb+sD*sD));
		double a2 = 0.25*sqrt((sc+sd+sD)*(sc+sd+sD)-2*(sc*sc+sd*sd+sD*sD));
		ans = max(ans,a1+a2);
	}
	FOR(i,1,n-2) FOR(j,i+1,n-1) {
		int y1 = b[0].first, x1 = b[0].second;
		int y2 = b[i].first, x2 = b[i].second;
		int y3 = b[j].first, x3 = b[j].second;
		int y4 = b[n-1].first, x4 = b[n-1].second;
		double sa = (x1-x2)*(x1-x2)+(y1-y2)*(y1-y2);
		double sb = (x3-x2)*(x3-x2)+(y3-y2)*(y3-y2);
		double sc = (x4-x3)*(x4-x3)+(y4-y3)*(y4-y3);
		double sd = (x1-x4)*(x1-x4)+(y1-y4)*(y1-y4);
		double sD = (x1-x3)*(x1-x3)+(y1-y3)*(y1-y3);
		double a1 = 0.25*sqrt((sa+sb+sD)*(sa+sb+sD)-2*(sa*sa+sb*sb+sD*sD));
		double a2 = 0.25*sqrt((sc+sd+sD)*(sc+sd+sD)-2*(sc*sc+sd*sd+sD*sD));
		ans = max(ans,a1+a2);
	}
	cout << ans << endl;
	return 0;
}


#include <vector>
#include <numeric>
#include <list>
#include <map>
#include <set>
#include <deque>
#include <queue>
#include <stack>
#include <bitset>
#include <algorithm>
#include <sstream>
#include <iostream>
#include <fstream>
#include <cstdio>
#include <cmath>
#include <cstdlib>
#include <cctype>
#include <string>
#include <cstring>
#include <ctime>
#include <limits>
#include <iomanip>

using namespace std;

#define FOR(i,a,b)		for(int i=(a),_b=(b);i<(_b);++i)
#define FORD(i,a,b)		for(int i=(a),_b=(b);i>(_b);--i)
#define pb			push_back
#define mp			make_pair
#define	all(c)			(c).begin(),(c).end()
#define	tr(c,i)	for(typeof((c).begin()) i = (c).begin(); i != (c).end(); i++)
#define	present(c,x)		((c).find(x) != (c).end())
#define	cpresent(c,x)		(find(all(c),x) != (c).end())

typedef long long			ll;
typedef unsigned long long	ull;
typedef unsigned char	 	byte;
typedef vector<int>			vi;
typedef pair<int, int>		pii;
typedef pair<ll, ll>		pll;
typedef vector<pii>			vpii;

const int MX = 25;

bool mysort(pii a, pii b)
{
	if (a.first != b.first) return a.first < b.first;
	return a.second > b.second;
}

int main(int argc, char *argv[])
{
#ifndef ONLINE_JUDGE
	freopen(argv[1],"r",stdin);
#endif
#ifndef ONLINE_JUDGE
	ifstream cin(argv[1]);
#endif
#if 0
	ofstream cout(argv[2]);
#endif
	int n;
	cin >> n;
	pii a[n],b[n];
	FOR(i,0,n) cin >> a[i].first >> a[i].second;
	double ans = 0;
	FOR(i,0,n) FOR(j,i+1,n) FOR(k,j+1,n) FOR(l,k+1,n) {
		int x1 = a[i].first, y1 = a[i].second;
		int x2 = a[j].first, y2 = a[j].second;
		int x3 = a[k].first, y3 = a[k].second;
		int x4 = a[l].first, y4 = a[l].second;
		double sa = sqrt((x1-x2)*(x1-x2)+(y1-y2)*(y1-y2));
		double sb = sqrt((x3-x2)*(x3-x2)+(y3-y2)*(y3-y2));
		double sc = sqrt((x4-x3)*(x4-x3)+(y4-y3)*(y4-y3));
		double sd = sqrt((x1-x4)*(x1-x4)+(y1-y4)*(y1-y4));
		double sD = sqrt((x1-x3)*(x1-x3)+(y1-y3)*(y1-y3));
		double s1 = 0.5*(sa+sb+sD);
		double s2 = 0.5*(sc+sd+sD);
		double a1 = sqrt(s1*(s1-sa)*(s1-sb)*(s1-sD));
		double a2 = sqrt(s2*(s2-sc)*(s2-sd)*(s2-sD));
		ans = max(ans,a1+a2);
	}
	cout << ans << endl;
	return 0;
}


#include <vector>
#include <numeric>
#include <list>
#include <map>
#include <set>
#include <deque>
#include <queue>
#include <stack>
#include <bitset>
#include <algorithm>
#include <sstream>
#include <iostream>
#include <fstream>
#include <cstdio>
#include <cmath>
#include <cstdlib>
#include <cctype>
#include <string>
#include <cstring>
#include <ctime>
#include <limits>
#include <iomanip>

using namespace std;

#define FOR(i,a,b)		for(int i=(a),_b=(b);i<(_b);++i)
#define FORD(i,a,b)		for(int i=(a),_b=(b);i>(_b);--i)
#define pb			push_back
#define mp			make_pair
#define	all(c)			(c).begin(),(c).end()
#define	tr(c,i)	for(typeof((c).begin()) i = (c).begin(); i != (c).end(); i++)
#define	present(c,x)		((c).find(x) != (c).end())
#define	cpresent(c,x)		(find(all(c),x) != (c).end())

typedef long long			ll;
typedef unsigned long long	ull;
typedef unsigned char	 	byte;
typedef vector<int>			vi;
typedef pair<int, int>		pii;
typedef pair<ll, ll>		pll;
typedef vector<pii>			vpii;

const int MX = 25;

bool mysort(pii a, pii b)
{
	if (a.first != b.first) return a.first < b.first;
	return a.second > b.second;
}

int main(int argc, char *argv[])
{
#ifndef ONLINE_JUDGE
	freopen(argv[1],"r",stdin);
#endif
#ifndef ONLINE_JUDGE
	ifstream cin(argv[1]);
#endif
#if 0
	ofstream cout(argv[2]);
#endif
	int n;
	cin >> n;
	pair<ll,ll> a[n],b[n];
	FOR(i,0,n) cin >> a[i].first >> a[i].second;
	double ans = 0;
	ll best = 0;
	FOR(i,0,n) FOR(j,i+1,n) FOR(k,j+1,n) FOR(l,k+1,n) {
		int x1 = a[i].first, y1 = a[i].second;
		int x2 = a[j].first, y2 = a[j].second;
		int x3 = a[k].first, y3 = a[k].second;
		int x4 = a[l].first, y4 = a[l].second;
		ll sa = (x1-x2)*(x1-x2)+(y1-y2)*(y1-y2);
		ll sb = (x3-x2)*(x3-x2)+(y3-y2)*(y3-y2);
		ll sc = (x4-x3)*(x4-x3)+(y4-y3)*(y4-y3);
		ll sd = (x1-x4)*(x1-x4)+(y1-y4)*(y1-y4);
		ll sD = (x1-x3)*(x1-x3)+(y1-y3)*(y1-y3);
		ll a1 = (sa+sb+sD)*(sa+sb+sD)-2*(sa*sa+sb*sb+sD*sD);
		ll a2 = (sc+sd+sD)*(sc+sd+sD)-2*(sc*sc+sd*sd+sD*sD);
		if (a1+a2 > best) {
			best = a1+a2;
			ans = 0.25*(sqrt(a1)+sqrt(a2));
		}
	}
	printf("%.9f\n",ans);
	return 0;
}


#include <vector>
#include <numeric>
#include <list>
#include <map>
#include <set>
#include <deque>
#include <queue>
#include <stack>
#include <bitset>
#include <algorithm>
#include <sstream>
#include <iostream>
#include <fstream>
#include <cstdio>
#include <cmath>
#include <cstdlib>
#include <cctype>
#include <string>
#include <cstring>
#include <ctime>
#include <limits>
#include <iomanip>

using namespace std;

#define FOR(i,a,b)		for(int i=(a),_b=(b);i<(_b);++i)
#define FORD(i,a,b)		for(int i=(a),_b=(b);i>(_b);--i)
#define pb			push_back
#define mp			make_pair
#define	all(c)			(c).begin(),(c).end()
#define	tr(c,i)	for(typeof((c).begin()) i = (c).begin(); i != (c).end(); i++)
#define	present(c,x)		((c).find(x) != (c).end())
#define	cpresent(c,x)		(find(all(c),x) != (c).end())

typedef long long			ll;
typedef unsigned long long	ull;
typedef unsigned char	 	byte;
typedef vector<int>			vi;
typedef pair<int, int>		pii;
typedef pair<ll, ll>		pll;
typedef vector<pii>			vpii;

const int MX = 25;

int crossproduct(pii &v1, pii &v2)
{
	return v1.first*v2.second - v2.first*v1.second;
}

int main(int argc, char *argv[])
{
#ifndef ONLINE_JUDGE
	freopen(argv[1],"r",stdin);
#endif
#ifndef ONLINE_JUDGE
	ifstream cin(argv[1]);
#endif
#if 0
	ofstream cout(argv[2]);
#endif
	int n;
	cin >> n;
	pii a[n];
	FOR(i,0,n) cin >> a[i].first >> a[i].second;
	int ans = 0;
	FOR(i,0,n) FOR(j,i+1,n) {
		pii v1(a[j].first-a[i].first,a[j].second-a[i].second);
		int mx = -1e+9, mn = 1e+9;
		FOR(k,0,n) {
			if (k != i && k != j) {
				pii v2(pii(a[k].first-a[i].first,a[k].second-a[i].second));
				int area = crossproduct(v1,v2);
				if (area <= 0) mn = min(area,mn);
				if (area >= 0) mx = max(mx,area);
			}
		}
		ans = max(ans,mx-mn);
	}
	printf("%.9f\n",ans/2.0);
	return 0;
}


#include<iostream>
#include<cmath>
#include<vector>

using namespace std;
#define For(i,n) for(int i=0; i<n; i++)
#define MAX(a,b) ( (a < b) ? b : a)

struct Coord{
	int x,y;
	Coord(int a = 0, int b = 0){
		x=a;
		y=b;
	}
	bool operator == (const Coord c) const {
		return c.x==x && c.y==y;
	}
	double operator - (const Coord c) const {
		int x_ = x - c.x, y_ = y - c.y;
		return sqrt(x_*x_ + y_*y_);
	}
};
struct Quad{
	Coord A, B, C, D;
};
pair<long long, long long> area(Coord &A, Coord &B, Coord &C){
	pair<long long, long long> p;
	p.first = (long long) (A.x*(B.y-C.y) + B.x*(C.y-A.y) + C.x*(A.y-B.y));
	p.second = (long long) (abs(p.first)%2);
	p.first/=2;
	return p;
}

template<typename T1, typename T2>
pair<T1, T2> operator + (const pair<T1, T2> &p1, const pair<T1, T2> &p2){
	pair<T1, T2> ret;
	ret.second = p1.second+p2.second;
	ret.first = p1.first + p2.first + (ret.second/10);
	ret.second = ret.second%10;
	return ret;
}

int main(){
	int n;
	cin>>n;
	vector<Coord> points(n);
	for(int i=0; i<n; i++){
		int a, b;
		cin>>a>>b;
		points[i] = Coord(a,b);
	}
	pair<long long, long long> ret = make_pair(0,0);
	for(int i=0; i<points.size(); i++){
		for(int j=i+1; j<points.size(); j++){
			pair<long long, long long> right = make_pair(0,0), left = make_pair(0,0);
			for(int k=0; k<points.size(); k++){
				pair<long long, long long> dir = area(points[i], points[j], points[k]);
				if(dir.first>0)
					left = MAX(dir, left);
				else if(dir.first<0){
					dir.first*=-1;
					right = MAX(dir, right);
				}
			}
			right = right + left;
			ret = MAX(ret, right);
		}
	}
	cout<<(double)(ret.first) + 0.1 * (double)ret.second<<endl;
}


#include<iostream>
#include<cmath>
#include<vector>

using namespace std;
#define For(i,n) for(int i=0; i<n; i++)
#define MAX(a,b) ( (a < b) ? b : a)

struct Coord{
    int x,y;
    Coord(int a = 0, int b = 0){
        x=a;
        y=b;
    }
    bool operator == (const Coord c) const {
        return c.x==x && c.y==y;
    }
    double operator - (const Coord c) const {
        int x_ = x - c.x, y_ = y - c.y;
        return sqrt(x_*x_ + y_*y_);
    }
};
struct Quad{
    Coord A, B, C, D;
};
pair<long long, short> area(Coord &A, Coord &B, Coord &C){
    pair<long long, short> p;
    p.first = (long long) (A.x*(B.y-C.y) + B.x*(C.y-A.y) + C.x*(A.y-B.y));
    p.second = (short) (abs(p.first)%2);
    p.first/=2;
    return p;
}

template<typename T1, typename T2>
pair<T1, T2> operator + (const pair<T1, T2> &p1, const pair<T1, T2> &p2){
    pair<T1, T2> ret;
    ret.second = p1.second+p2.second;
    ret.first = p1.first + p2.first + (ret.second/10);
    ret.second = ret.second%10;
    return ret;
}

int main(){
    int n;
    cin>>n;
    vector<Coord> points(n);
    for(int i=0; i<n; i++){
        int a, b;
        cin>>a>>b;
        points[i] = Coord(a,b);
    }
    pair<long long, short> ret = make_pair(0,0);
    for(int i=0; i<points.size(); i++){
        for(int j=i+1; j<points.size(); j++){
            pair<long long, short> right = make_pair(0,0), left = make_pair(0,0);
            for(int k=0; k<points.size(); k++){
                pair<long long, short> dir = area(points[i], points[j], points[k]);
                if(dir.first>0)
                    left = MAX(dir, left);
                else if(dir.first<0){
                    dir.first*=-1;
                    right = MAX(dir, right);
                }
            }
            right = right + left;
            ret = MAX(ret, right);
        }
    }
    cout<<(double)(ret.first) + 0.1 * (double)ret.second<<endl;
}


#include<iostream>
#include<iomanip>
#include<cmath>
#include<vector>

using namespace std;
#define For(i,n) for(int i=0; i<n; i++)
#define MAX(a,b) ( (a < b) ? b : a)
#define ABS(a) ( (a < 0) ? -a : a)

struct Coord{
	int x,y;
	Coord(int a = 0, int b = 0){
		x=a;
		y=b;
	}
	bool operator == (const Coord c) const {
		return c.x==x && c.y==y;
	}
};
struct Quad{
	Coord A, B, C, D;
};
pair<long long, int> area(Coord &A, Coord &B, Coord &C, bool &check){
	pair<long long, int> p;
	p.first = (long long) (A.x*(B.y-C.y) + B.x*(C.y-A.y) + C.x*(A.y-B.y));
	if(p.first==-1) check = true;
	p.second = ( (ABS(p.first)%2) ? 5 : 0);
	p.first/=2;
	return p;
}

template<typename T1, typename T2>
pair<T1, T2> operator + (const pair<T1, T2> &p1, const pair<T1, T2> &p2){
	pair<T1, T2> ret;
	ret.second = p1.second+p2.second;
	ret.first = p1.first + p2.first + (ret.second/10);
	ret.second = ret.second%10;
	return ret;
}

int main(){
	int n;
	cin>>n;
	vector<Coord> points(n);
	for(int i=0; i<n; i++){
		int a, b;
		cin>>a>>b;
		points[i] = Coord(a,b);
	}
	pair<long long, int> ret = make_pair(0,0);
	for(int i=0; i<points.size(); i++){
		for(int j=i+1; j<points.size(); j++){
			pair<long long, int> right = make_pair(0,0), left = make_pair(0,0);
			for(int k=0; k<points.size(); k++){
				bool check;
				pair<long long, int> dir = area(points[i], points[j], points[k], check);
				if(dir.first>0)
					left = MAX(dir, left);
				else if(dir.first<0 || check){
					dir.first*=-1;
					right = MAX(dir, right);
				}
			}
			if((right.first >0 || right.second >0) && (left.first >0 || left.second >0)){
				right = right + left;
				ret = MAX(ret, right);
			}
		}
	}
	cout << fixed<<std::setprecision(9)<<(double)(ret.first) + 0.1 * (double)ret.second<<endl;
}


#include<iostream>
#include<iomanip>
#include<cmath>
#include<vector>

using namespace std;
#define For(i,n) for(int i=0; i<n; i++)
#define MAX(a,b) ( (a < b) ? b : a)
#define ABS(a) ( (a < 0) ? -a : a)
#define EPS 0.0000000001

struct Coord{
	int x,y;
	Coord(int a = 0, int b = 0){
		x=a;
		y=b;
	}
	bool operator == (const Coord c) const {
		return c.x==x && c.y==y;
	}
};

double area(Coord &A, Coord &B, Coord &C){
	return (double)(A.x*(B.y-C.y) + B.x*(C.y-A.y) + C.x*(A.y-B.y)) * 0.5;
}

int main(){
	do{
	int n;
	cin>>n;
	vector<Coord> points(n);
	for(int i=0; i<n; i++){
		int a, b;
		cin>>a>>b;
		points[i] = Coord(a,b);
	}
	double ret = 0;
	for(int i=0; i<points.size(); i++){
		for(int j=i+1; j<points.size(); j++){
			double right = 0, left = 0;
			for(int k=0; k<points.size(); k++){
				double dir = area(points[i], points[j], points[k]);
				if(dir > EPS)
					left = MAX(dir, left);
				else if(dir < 0){
					dir*=-1;
					right = MAX(dir, right);
				}
			}
			if(right > 0 && left > 0){
				right = right + left;
				ret = MAX(ret, right);
			}
		}
	}
	cout<<fixed<<std::setprecision(9)<<ret<<endl;
	}while(1);
}


#include<iostream>
#include<iomanip>
#include<cmath>
#include<vector>

using namespace std;
#define For(i,n) for(int i=0; i<n; i++)
#define MAX(a,b) ( (a < b) ? b : a)
#define ABS(a) ( (a < 0) ? -a : a)
#define EPS 0.0000000001

struct Coord{
	int x,y;
	Coord(int a = 0, int b = 0){
		x=a;
		y=b;
	}
	bool operator == (const Coord c) const {
		return c.x==x && c.y==y;
	}
};

double area(Coord &A, Coord &B, Coord &C){
	return (double)(A.x*(B.y-C.y) + B.x*(C.y-A.y) + C.x*(A.y-B.y)) * 0.5;
}

int main(){
	int n;
	cin>>n;
	vector<Coord> points(n);
	for(int i=0; i<n; i++){
		int a, b;
		cin>>a>>b;
		points[i] = Coord(a,b);
	}
	double ret = 0;
	for(int i=0; i<points.size(); i++){
		for(int j=i+1; j<points.size(); j++){
			double right = 0, left = 0;
			for(int k=0; k<points.size(); k++){
				double dir = area(points[i], points[j], points[k]);
				if(dir > EPS)
					left = MAX(dir, left);
				else if(dir < 0){
					dir*=-1;
					right = MAX(dir, right);
				}
			}
			if(right > 0 && left > 0){
				right = right + left;
				ret = MAX(ret, right);
			}
		}
	}
	cout<<fixed<<std::setprecision(9)<<ret<<endl;
}


#include<iostream>
#include<iomanip>
#include<cmath>
#include<vector>

using namespace std;
#define For(i,n) for(int i=0; i<n; i++)
#define MAX(a,b) ( (a < b) ? b : a)

struct Coord{
	int x,y;
	Coord(int a = 0, int b = 0){
		x=a;
		y=b;
	}
	bool operator == (const Coord c) const {
		return c.x==x && c.y==y;
	}
};
struct Quad{
	Coord A, B, C, D;
};
pair<long long, int> area(Coord &A, Coord &B, Coord &C, bool &check){
	pair<long long, int> p;
	p.first = (long long) (A.x*(B.y-C.y) + B.x*(C.y-A.y) + C.x*(A.y-B.y));
	if(p.first==-1) check = true;
	p.second =  (int) (((long long )(abs(p.first)))%2);
	p.second *= 5;
	p.first/=2;
	return p;
}

template<typename T1, typename T2>
pair<T1, T2> operator + (const pair<T1, T2> &p1, const pair<T1, T2> &p2){
	pair<T1, T2> ret;
	ret.second = p1.second+p2.second;
	ret.first = p1.first + p2.first + (ret.second/10);
	ret.second = ret.second%10;
	return ret;
}

int main(){
	int n;
	cin>>n;
	vector<Coord> points(n);
	for(int i=0; i<n; i++){
		int a, b;
		cin>>a>>b;
		points[i] = Coord(a,b);
	}
	pair<long long, int> ret = make_pair(0,0);
	for(int i=0; i<points.size(); i++){
		for(int j=i+1; j<points.size(); j++){
			pair<long long, int> right = make_pair(0,0), left = make_pair(0,0);
			for(int k=0; k<points.size(); k++){
				bool check;
				pair<long long, int> dir = area(points[i], points[j], points[k], check);
				if(dir.first>0)
					left = MAX(dir, left);
				else if(dir.first<0 || check){
					dir.first*=-1;
					right = MAX(dir, right);
				}
			}
			if((right.first >0 || right.second >0) && (left.first >0 || left.second >0)){
				right = right + left;
				ret = MAX(ret, right);
			}
		}
	}
	cout << fixed<<std::setprecision(9)<<(double)(ret.first) + 0.1 * (double)ret.second<<endl;
}


#include<iostream>
#include<string>
#include<vector>

using namespace std;

int gcd(int a, int b){
    for (;;){
        if (a == 0) return b;
        b %= a;
        if (b == 0) return a;
        a %= b;
    }
}

int lcm(int a, int b){
    int temp = gcd(a, b);
    return temp ? (a / temp * b) : 0;
}

int main(){
	int x, y;
	long long a,b;
	cin>>x>>y>>a>>b;
	x = lcm(x,y);
	a = a/x + ( (a%x == 0) ? 0 : 1);
	b = b/x;
	cout<<max(b-a+1,(long long)0)<<endl;
	return 0;
}


#include<iostream>
#include<iomanip>
#include<cmath>
#include<vector>

using namespace std;
#define For(i,n) for(int i=0; i<n; i++)
#define MAX(a,b) ( (a < b) ? b : a)

struct Coord{
	int x,y;
	Coord(int a = 0, int b = 0){
		x=a;
		y=b;
	}
	bool operator == (const Coord c) const {
		return c.x==x && c.y==y;
	}
};
struct Quad{
	Coord A, B, C, D;
};
pair<long long, int> area(Coord &A, Coord &B, Coord &C, bool &check){
	pair<long long, int> p;
	p.first = (long long) (A.x*(B.y-C.y) + B.x*(C.y-A.y) + C.x*(A.y-B.y));
	if(p.first==-1) check = true;
	p.second = (int) (abs(p.first)%2);
	p.second *= 5;
	p.first/=2;
	return p;
}

template<typename T1, typename T2>
pair<T1, T2> operator + (const pair<T1, T2> &p1, const pair<T1, T2> &p2){
	pair<T1, T2> ret;
	ret.second = p1.second+p2.second;
	ret.first = p1.first + p2.first + (ret.second/10);
	ret.second = ret.second%10;
	return ret;
}

int main(){
	int n;
	cin>>n;
	vector<Coord> points(n);
	for(int i=0; i<n; i++){
		int a, b;
		cin>>a>>b;
		points[i] = Coord(a,b);
	}
	pair<long long, int> ret = make_pair(0,0);
	for(int i=0; i<points.size(); i++){
		for(int j=i+1; j<points.size(); j++){
			pair<long long, int> right = make_pair(0,0), left = make_pair(0,0);
			for(int k=0; k<points.size(); k++){
				bool check;
				pair<long long, int> dir = area(points[i], points[j], points[k], check);
				if(dir.first>0)
					left = MAX(dir, left);
				else if(dir.first<0 || check){
					dir.first*=-1;
					right = MAX(dir, right);
				}
			}
			if((right.first >0 || right.second >0) && (left.first >0 || left.second >0)){
				right = right + left;
				ret = MAX(ret, right);
			}
		}
	}
	cout << fixed<<std::setprecision(9)<<(double)(ret.first) + 0.1 * (double)ret.second<<endl;
}


#include<iostream>
#include<iomanip>
#include<cmath>
#include<vector>

using namespace std;
#define For(i,n) for(int i=0; i<n; i++)
#define MAX(a,b) ( (a < b) ? b : a)

struct Coord{
	int x,y;
	Coord(int a = 0, int b = 0){
		x=a;
		y=b;
	}
	bool operator == (const Coord c) const {
		return c.x==x && c.y==y;
	}
};
struct Quad{
	Coord A, B, C, D;
};
pair<long long, int> area(Coord &A, Coord &B, Coord &C, bool &check){
	pair<long long, int> p;
	p.first = (long long) (A.x*(B.y-C.y) + B.x*(C.y-A.y) + C.x*(A.y-B.y));
	if(p.first==-1) check = true;
	p.second =  (int) ((abs(p.first))%2);
	p.second *= 5;
	p.first/=2;
	return p;
}

template<typename T1, typename T2>
pair<T1, T2> operator + (const pair<T1, T2> &p1, const pair<T1, T2> &p2){
	pair<T1, T2> ret;
	ret.second = p1.second+p2.second;
	ret.first = p1.first + p2.first + (ret.second/10);
	ret.second = ret.second%10;
	return ret;
}

int main(){
	int n;
	cin>>n;
	vector<Coord> points(n);
	for(int i=0; i<n; i++){
		int a, b;
		cin>>a>>b;
		points[i] = Coord(a,b);
	}
	pair<long long, int> ret = make_pair(0,0);
	for(int i=0; i<points.size(); i++){
		for(int j=i+1; j<points.size(); j++){
			pair<long long, int> right = make_pair(0,0), left = make_pair(0,0);
			for(int k=0; k<points.size(); k++){
				bool check;
				pair<long long, int> dir = area(points[i], points[j], points[k], check);
				if(dir.first>0)
					left = MAX(dir, left);
				else if(dir.first<0 || check){
					dir.first*=-1;
					right = MAX(dir, right);
				}
			}
			if((right.first >0 || right.second >0) && (left.first >0 || left.second >0)){
				right = right + left;
				ret = MAX(ret, right);
			}
		}
	}
	cout << fixed<<std::setprecision(9)<<(double)(ret.first) + 0.1 * (double)ret.second<<endl;
}


#include <cstdio>
#include <cstring>
#include <cstdlib>
#include <cmath>
#include <bitset>
#include <deque>
#include <list>
#include <map>
#include <queue>
#include <set>
#include <stack>
#include <vector>
#include <iostream>
#include <fstream>
#include <algorithm>
#include <complex>
#include <limits>
#include <numeric>
#include <string>
#include <utility>
using namespace std;
typedef long long LL;typedef long double LD;typedef vector<int> vi;typedef pair<int,int> pii;
const LD PI = 3.1415926535897932384626433832795L;const LD E = 2.7182818284590452353602874713527L;const LD PHI = 1.2*sin(0.3*PI);
template<class T>T sqr(const T x){return x*x;}
LL binpow(const LL a, const LL n, const LL mod){return n == 0 ? 1 : sqr( binpow ( a, n/2, mod ) ) % mod * ( n % 2 ? a : 1 ) % mod;}
LL gcd(const LL a, const LL b){return b ? gcd( b, a%b ) : a;}LL lcm(const LL a, const LL b){return a/gcd(a,b)*b;}

const int MAXN = 342;

pii points[MAXN];
pair<LL, int> sorting[MAXN];
int farest[MAXN][MAXN];

istream& operator >> ( istream &in, pii &p ){
    in >> p.first >> p.second;
    return in;
}

inline pii operator - ( const pii &a, const pii &b ){
    return make_pair(a.first-b.first, a.second-b.second);
}

inline LL length2(pii a){
    return sqr((LL)a.first)+sqr((LL)a.second);
}
inline LD length(pii a){
    return sqrt(length2(a)+.0);
}
inline LD angle(const pii &a){
    return atan2(a.second+.0, a.first+.0);
}

int main(){

    int n;
    cin >> n;

    for ( int i = 0; i < n; ++i ){
        cin >> points[i];
    }

    for ( int i = 0; i < n; ++i ){
        for ( int j = 0; j < n; ++j ){
            sorting[j] = make_pair(length2(points[i]-points[j]),j);
        }
        sort(sorting, sorting+n);
        reverse(sorting, sorting+n);
        for ( int j = 0; j < n; ++j ){
            farest[i][j] = sorting[j].second;
        }
    }

    LD result = 0.0;
    for ( int i = 0; i < n; ++i ){
        for ( int j = 0; j < n; ++j ){
            if ( i == j ){
                continue;
            }
            for ( int fi = 0; fi < min(30,n); ++fi ){
                if ( farest[i][fi] == i || farest[i][fi] == j){
                    continue;
                }
                for ( int fj = 0; fj < min(30,n); ++fj ){
                    if ( farest[j][fj] == i || farest[j][fj] == j || farest[j][fj] == farest[i][fi] ){
                        continue;
                    }
                    pii d1 = points[i]-points[farest[i][fi]];
                    pii d2 = points[j]-points[farest[j][fj]];
                    LD current =
                        sqrt ( length2(d1) *
                        length2(d2) / 4.0 ) * sin ( angle ( d1 ) - angle(d2) );
                    result = max ( result, current );
                }
            }
        }
    }

    cout << result << endl;

    return 0;
}


#include <cstdio>
#include <cstring>
#include <cstdlib>
#include <cmath>
#include <bitset>
#include <deque>
#include <list>
#include <map>
#include <queue>
#include <set>
#include <stack>
#include <vector>
#include <iostream>
#include <fstream>
#include <algorithm>
#include <complex>
#include <limits>
#include <numeric>
#include <string>
#include <utility>
using namespace std;
typedef long long LL;typedef long double LD;typedef vector<int> vi;typedef pair<int,int> pii;
const LD PI = 3.1415926535897932384626433832795L;const LD E = 2.7182818284590452353602874713527L;const LD PHI = 1.2*sin(0.3*PI);
template<class T>T sqr(const T x){return x*x;}
LL binpow(const LL a, const LL n, const LL mod){return n == 0 ? 1 : sqr( binpow ( a, n/2, mod ) ) % mod * ( n % 2 ? a : 1 ) % mod;}
LL gcd(const LL a, const LL b){return b ? gcd( b, a%b ) : a;}LL lcm(const LL a, const LL b){return a/gcd(a,b)*b;}

const int MAXN = 342;

pii points[MAXN];
int farest[2][MAXN];

istream& operator >> ( istream &in, pii &p ){
    in >> p.first >> p.second;
    return in;
}

inline pii operator - ( pii &a, pii &b ){
    return make_pair(a.first-b.first, a.second-b.second);
}

inline LL length2(pii a){
    return sqr((LL)a.first)+sqr((LL)a.second);
}
inline LD length(pii a){
    return sqrt(sqr((LL)a.first)+sqr((LL)a.second)+.0);
}
inline LD angle(pii a){
    return atan2(a.second+.0, a.first+.0);
}

int main(){

    int n;
    cin >> n;

    for ( int i = 0; i < n; ++i ){
        cin >> points[i];
    }

    for ( int i = 0; i < n; ++i ){
        farest[0][i] = farest[1][i] = i;
        LL max1, max2;
        max1 = max2 = 0;
        for ( int j = 0; j < n; ++j ){
            LL current = length2(points[i]-points[j]);
            if ( current > max1 ){
                max2 = max1;
                max1 = current;
                farest[1][i] = farest[0][i];
                farest[0][i] = j;
            } else if ( current == max1 || current > max2 ){
                max2 = current;
                farest[1][i] = j;
            }
        }
    }

    LD result = 0.0;
    for ( int i = 0; i < n; ++i ){
        for ( int j = 0; j < n; ++j ){
            if ( i == j ) continue;
            for ( int fi = 0; fi < 2; ++fi){
                if ( j == farest[fi][i] ){
                    continue;
                }
                for ( int fj = 0; fj < 2; ++fj){
                    if ( i == farest[fj][j] || farest[fi][i] == farest[fj][j] ){
                        continue;
                    }
                    pii d1 = points[i] - points[farest[fi][i]];
                    pii d2 = points[j] - points[farest[fj][j]];
                    LD current = length(d1) * length(d2) * sin ( angle(d1) - angle(d2) ) / 2.0;
                    result = max ( result, current );
                }
            }
        }
    }

    cout << result << endl;

    return 0;
}


#include <iostream>

using namespace std;

const int MAXN = 300;

struct point{
	int x, y;
	point(){}
	point(const int _x, const int _y):x(_x),y(_y){}
} points[MAXN];

istream& operator >> ( istream &in, point &p ) {
	in >> p.x >> p.y;
	return in;
}

int operator ^ ( const point a, const point b ) {
	return a.x*b.y-a.y*b.x;
}
point operator -  ( const point a, const point b ) {
	return point(a.x-b.x,a.y-b.y);
}

int main(){

	int n;
	cin >> n;
	for (int i = 0; i < n; i++){
		cin >> points[i];
	}

	int max_result_area_sum = 0;
	for (int i = 0; i < n; i++){
		for (int j = i+1; j < n; j++){
			point diagonal = points[j]-points[i];
			int max_positive_area = 0, min_negative_area = 0;
			for (int k = 0; k < n; k++){
				if ( k == i || k == j ){
					continue;
				}
				point side = points[k] - points[i];
				int current_area = side ^ diagonal;
				max_positive_area = max ( max_positive_area, current_area );
				min_negative_area = min ( min_negative_area, current_area );
			}
			if ( max_positive_area > 0 && min_negative_area < 0 ) {
				max_result_area_sum = max ( max_result_area_sum, max_positive_area-min_negative_area );
			}
		}
	}

	cout << max_result_area_sum / 2.0L << endl;

	return 0;
}


#include <iostream>

using namespace std;

const int MAXN = 300;

struct point{
	int x, y;
	point(){}
	point(const int _x, const int _y):x(_x),y(_y){}
} points[MAXN];

istream& operator >> ( istream &in, point &p ) {
	in >> p.x >> p.y;
	return in;
}

int operator ^ ( const point a, const point b ) {
	return a.x*b.y-a.y*b.x;
}
point operator -  ( const point a, const point b ) {
	return point(a.x-b.x,a.y-b.y);
}

int main(){

	int n;
	cin >> n;
	for (int i = 0; i < n; i++){
		cin >> points[i];
	}

	int max_result_area_sum = 0;
	for (int i = 0; i < n; i++){
		for (int j = i+1; j < n; j++){
			point diagonal = points[j]-points[i];
			int max_positive_area = 0, min_negative_area = 0;
			for (int k = 0; k < n; k++){
				if ( k == i || k == j ){
					continue;
				}
				point side = points[k] - points[i];
				int current_area = side ^ diagonal;
				max_positive_area = max ( max_positive_area, current_area );
				min_negative_area = min ( min_negative_area, current_area );
			}
			if ( max_positive_area > 0 && min_negative_area < 0 ) {
				max_result_area_sum = max ( max_result_area_sum, max_positive_area-min_negative_area );
			}
		}
	}

	cout.precision(9);
	cout.setf(ios::fixed);
	cout << max_result_area_sum / 2.0L << endl;

	return 0;
}


#include <cstdio>
#include <cstring>
#include <cstdlib>
#include <cmath>
#include <bitset>
#include <deque>
#include <list>
#include <map>
#include <queue>
#include <set>
#include <stack>
#include <vector>
#include <iostream>
#include <fstream>
#include <algorithm>
#include <complex>
#include <limits>
#include <numeric>
#include <string>
#include <utility>
using namespace std;
typedef long long LL;typedef long double LD;typedef vector<int> vi;typedef pair<int,int> pii;
const LD PI = 3.1415926535897932384626433832795L;const LD E = 2.7182818284590452353602874713527L;const LD PHI = 1.2*sin(0.3*PI);
template<class T>T sqr(const T x){return x*x;}
LL binpow(const LL a, const LL n, const LL mod){return n == 0 ? 1 : sqr( binpow ( a, n/2, mod ) ) % mod * ( n % 2 ? a : 1 ) % mod;}
LL gcd(const LL a, const LL b){return b ? gcd( b, a%b ) : a;}LL lcm(const LL a, const LL b){return a/gcd(a,b)*b;}

const int MAXN = 342;

pii points[MAXN];
pair<LL, int> sorting[MAXN];
int farest[MAXN][MAXN];

istream& operator >> ( istream &in, pii &p ){
    in >> p.first >> p.second;
    return in;
}

inline pii operator - ( const pii &a, const pii &b ){
    return make_pair(a.first-b.first, a.second-b.second);
}

inline LL length2(pii a){
    return sqr((LL)a.first)+sqr((LL)a.second);
}
inline LD length(pii a){
    return sqrt(length2(a)+.0);
}
inline LD angle(const pii &a){
    return atan2(a.second+.0, a.first+.0);
}

inline int area (pii a, pii b, pii c) {
    return (b.first - a.first) * (c.second - a.second) - (b.second - a.second) * (c.first - a.first);
}

inline bool intersect_1 (int a, int b, int c, int d) {
    if (a > b)  swap (a, b);
    if (c > d)  swap (c, d);
    return max(a,c) <= min(b,d);
}

bool intersect (pii a, pii b, pii c, pii d) {
    return intersect_1 (a.first, b.first, c.first, d.first)
        && intersect_1 (a.second, b.second, c.second, d.second)
        && area(a,b,c) * area(a,b,d) <= 0
        && area(c,d,a) * area(c,d,b) <= 0;
}

int main(){

    int n;
    cin >> n;

    for ( int i = 0; i < n; ++i ){
        cin >> points[i];
    }

    for ( int i = 0; i < n; ++i ){
        for ( int j = 0; j < n; ++j ){
            sorting[j] = make_pair(length2(points[i]-points[j]),j);
        }
        sort(sorting, sorting+n);
        reverse(sorting, sorting+n);
        for ( int j = 0; j < n; ++j ){
            farest[i][j] = sorting[j].second;
        }
    }

    LD result = 0.0;
    for ( int i = 0; i < n; ++i ){
        for ( int j = 0; j < n; ++j ){
            if ( i == j ){
                continue;
            }
            for ( int fi = 0; fi < min(5,n); ++fi ){
                if ( farest[i][fi] == i || farest[i][fi] == j){
                    continue;
                }
                for ( int fj = 0; fj < min(5,n); ++fj ){
                    if ( farest[j][fj] == i || farest[j][fj] == j || farest[j][fj] == farest[i][fi] ){
                        continue;
                    }
                    if ( !intersect ( points[i], points[farest[i][fi]], points[j], points[farest[j][fj]] ) ) {
                        continue;
                    }
                    pii d1 = points[i]-points[farest[i][fi]];
                    pii d2 = points[j]-points[farest[j][fj]];
                    LD current =
                        sqrt ( length2(d1) *
                        length2(d2) / 4.0L ) * sin ( angle ( d1 ) - angle(d2) );
                    result = max ( result, current );
                }
            }
        }
    }

    cout.precision(9);
    cout.setf(ios::fixed);
    cout << result << endl;

    return 0;
}


#include <cstdio>
#include <cstring>
#include <cstdlib>
#include <cmath>
#include <bitset>
#include <deque>
#include <list>
#include <map>
#include <queue>
#include <set>
#include <stack>
#include <vector>
#include <iostream>
#include <fstream>
#include <algorithm>
#include <complex>
#include <limits>
#include <numeric>
#include <string>
#include <utility>
using namespace std;
typedef long long LL;typedef long double LD;typedef vector<int> vi;typedef pair<int,int> pii;
const LD PI = 3.1415926535897932384626433832795L;const LD E = 2.7182818284590452353602874713527L;const LD PHI = 1.2*sin(0.3*PI);
template<class T>T sqr(const T x){return x*x;}
LL binpow(const LL a, const LL n, const LL mod){return n == 0 ? 1 : sqr( binpow ( a, n/2, mod ) ) % mod * ( n % 2 ? a : 1 ) % mod;}
LL gcd(const LL a, const LL b){return b ? gcd( b, a%b ) : a;}LL lcm(const LL a, const LL b){return a/gcd(a,b)*b;}

const int MAXN = 342;

pii points[MAXN];
int farest[2][MAXN];

istream& operator >> ( istream &in, pii &p ){
    in >> p.first >> p.second;
    return in;
}

inline pii operator - ( const pii &a, const pii &b ){
    return make_pair(a.first-b.first, a.second-b.second);
}

inline LL length2(pii a){
    return sqr((LL)a.first)+sqr((LL)a.second);
}
inline LD length(pii a){
    return sqrt(length2(a)+.0);
}
inline LD angle(const pii &a){
    return atan2(a.second+.0, a.first+.0);
}

inline LD sin ( const pii &a ){
    return a.second / sqrt(.0+sqr(a.first)+sqr(a.second));
}

int main(){

    int n;
    cin >> n;

    for ( int i = 0; i < n; ++i ){
        cin >> points[i];
    }

    for ( int i = 0; i < n; ++i ){
        farest[0][i] = farest[1][i] = i;
        LL max1, max2;
        max1 = max2 = 0;
        for ( int j = 0; j < n; ++j ){
            LL current = length2(points[i]-points[j]);
            if ( current > max1 ){
                max2 = max1;
                max1 = current;
                farest[1][i] = farest[0][i];
                farest[0][i] = j;
            } else if ( current == max1 || current > max2 ){
                max2 = current;
                farest[1][i] = j;
            }
        }
    }

    LD result = 0.0;
    for ( int i = 0; i < n; ++i ){
        for ( int j = 0; j < n; ++j ){
            if ( i == j ) continue;
            for ( int fi = 0; fi < 2; ++fi){
                if ( j == farest[fi][i] ){
                    continue;
                }
                for ( int fj = 0; fj < 2; ++fj){
                    if ( i == farest[fj][j] || farest[fi][i] == farest[fj][j] ){
                        continue;
                    }
                    pii d1 = points[i] - points[farest[fi][i]];
                    pii d2 = points[j] - points[farest[fj][j]];
                    LD current = length(d1) * length(d2) * sin ( d1-d2 ) / 2.0;
                    result = max ( result, current );
                }
            }
        }
    }

    cout << result << endl;

    return 0;
}


#include <cstdio>
#include <cstring>
#include <cstdlib>
#include <cmath>
#include <bitset>
#include <deque>
#include <list>
#include <map>
#include <queue>
#include <set>
#include <stack>
#include <vector>
#include <iostream>
#include <fstream>
#include <algorithm>
#include <complex>
#include <limits>
#include <numeric>
#include <string>
#include <utility>
using namespace std;
typedef long long LL;typedef long double LD;typedef vector<int> vi;typedef pair<int,int> pii;
const LD PI = 3.1415926535897932384626433832795L;const LD E = 2.7182818284590452353602874713527L;const LD PHI = 1.2*sin(0.3*PI);
template<class T>T sqr(const T x){return x*x;}
LL binpow(const LL a, const LL n, const LL mod){return n == 0 ? 1 : sqr( binpow ( a, n/2, mod ) ) % mod * ( n % 2 ? a : 1 ) % mod;}
LL gcd(const LL a, const LL b){return b ? gcd( b, a%b ) : a;}LL lcm(const LL a, const LL b){return a/gcd(a,b)*b;}

const int MAXN = 342;

pii points[MAXN];
pair<LL, int> sorting[MAXN];
int farest[MAXN][MAXN];

istream& operator >> ( istream &in, pii &p ){
    in >> p.first >> p.second;
    return in;
}

inline pii operator - ( const pii &a, const pii &b ){
    return make_pair(a.first-b.first, a.second-b.second);
}

inline LL length2(pii a){
    return sqr((LL)a.first)+sqr((LL)a.second);
}
inline LD length(pii a){
    return sqrt(length2(a)+.0);
}
inline LD angle(const pii &a){
    return atan2(a.second+.0, a.first+.0);
}

inline int area (pii a, pii b, pii c) {
	return (b.first - a.first) * (c.second - a.second) - (b.second - a.second) * (c.first - a.first);
}

inline bool intersect_1 (int a, int b, int c, int d) {
	if (a > b)  swap (a, b);
	if (c > d)  swap (c, d);
	return max(a,c) <= min(b,d);
}

bool intersect (pii a, pii b, pii c, pii d) {
	return intersect_1 (a.first, b.first, c.first, d.first)
		&& intersect_1 (a.second, b.second, c.second, d.second)
		&& area(a,b,c) * area(a,b,d) <= 0
		&& area(c,d,a) * area(c,d,b) <= 0;
}

int main(){

    int n;
    cin >> n;

    for ( int i = 0; i < n; ++i ){
        cin >> points[i];
    }

    for ( int i = 0; i < n; ++i ){
        for ( int j = 0; j < n; ++j ){
            sorting[j] = make_pair(length2(points[i]-points[j]),j);
        }
        sort(sorting, sorting+n);
        reverse(sorting, sorting+n);
        for ( int j = 0; j < n; ++j ){
            farest[i][j] = sorting[j].second;
        }
    }

    LD result = 0.0;
    for ( int i = 0; i < n; ++i ){
        for ( int j = 0; j < n; ++j ){
            if ( i == j ){
                continue;
            }
            for ( int fi = 0; fi < min(5,n); ++fi ){
                if ( farest[i][fi] == i || farest[i][fi] == j){
                    continue;
                }
                for ( int fj = 0; fj < min(5,n); ++fj ){
                    if ( farest[j][fj] == i || farest[j][fj] == j || farest[j][fj] == farest[i][fi] ){
                        continue;
                    }
					if ( !intersect ( points[i], points[farest[i][fi]], points[j], points[farest[j][fj]] ) ) {
						continue;
					}
                    pii d1 = points[i]-points[farest[i][fi]];
                    pii d2 = points[j]-points[farest[j][fj]];
                    LD current =
                        sqrt ( length2(d1) *
                        length2(d2) / 4.0 ) * sin ( angle ( d1 ) - angle(d2) );
                    result = max ( result, current );
                }
            }
        }
    }

    cout << result << endl;

    return 0;
}


#include <cstdio>
#include <cstring>
#include <cstdlib>
#include <cmath>
#include <bitset>
#include <deque>
#include <list>
#include <map>
#include <queue>
#include <set>
#include <stack>
#include <vector>
#include <iostream>
#include <fstream>
#include <algorithm>
#include <complex>
#include <limits>
#include <numeric>
#include <string>
#include <utility>
using namespace std;
typedef long long LL;typedef long double LD;typedef vector<int> vi;typedef pair<int,int> pii;
const LD PI = 3.1415926535897932384626433832795L;const LD E = 2.7182818284590452353602874713527L;const LD PHI = 1.2*sin(0.3*PI);
template<class T>T sqr(const T x){return x*x;}
LL binpow(const LL a, const LL n, const LL mod){return n == 0 ? 1 : sqr( binpow ( a, n/2, mod ) ) % mod * ( n % 2 ? a : 1 ) % mod;}
LL gcd(const LL a, const LL b){return b ? gcd( b, a%b ) : a;}LL lcm(const LL a, const LL b){return a/gcd(a,b)*b;}

const int MAXN = 342;

pii points[MAXN];
pair<LL, int> sorting[MAXN];
int farest[MAXN][MAXN];

istream& operator >> ( istream &in, pii &p ){
    in >> p.first >> p.second;
    return in;
}

inline pii operator - ( const pii &a, const pii &b ){
    return make_pair(a.first-b.first, a.second-b.second);
}

inline LL length2(pii a){
    return sqr((LL)a.first)+sqr((LL)a.second);
}
inline LD length(pii a){
    return sqrt(length2(a)+.0);
}
inline LD angle(const pii &a){
    return atan2(a.second+.0, a.first+.0);
}

inline int area (pii a, pii b, pii c) {
    return (b.first - a.first) * (c.second - a.second) - (b.second - a.second) * (c.first - a.first);
}

inline bool intersect_1 (int a, int b, int c, int d) {
    if (a > b)  swap (a, b);
    if (c > d)  swap (c, d);
    return max(a,c) <= min(b,d);
}

bool intersect (pii a, pii b, pii c, pii d) {
    return intersect_1 (a.first, b.first, c.first, d.first)
        && intersect_1 (a.second, b.second, c.second, d.second)
        && area(a,b,c) * area(a,b,d) <= 0
        && area(c,d,a) * area(c,d,b) <= 0;
}

int main(){

    int n;
    cin >> n;

    for ( int i = 0; i < n; ++i ){
        cin >> points[i];
    }

    for ( int i = 0; i < n; ++i ){
        for ( int j = 0; j < n; ++j ){
            sorting[j] = make_pair(length2(points[i]-points[j]),j);
        }
        sort(sorting, sorting+n);
        reverse(sorting, sorting+n);
        for ( int j = 0; j < n; ++j ){
            farest[i][j] = sorting[j].second;
        }
    }

    LD result = 0.0;
    for ( int i = 0; i < n; ++i ){
        for ( int j = 0; j < n; ++j ){
            if ( i == j ){
                continue;
            }
            for ( int fi = 0; fi < min(5,n); ++fi ){
                if ( farest[i][fi] == i || farest[i][fi] == j){
                    continue;
                }
                for ( int fj = 0; fj < min(5,n); ++fj ){
                    if ( farest[j][fj] == i || farest[j][fj] == j || farest[j][fj] == farest[i][fi] ){
                        continue;
                    }
                    if ( !intersect ( points[i], points[farest[i][fi]], points[j], points[farest[j][fj]] ) ) {
                        continue;
                    }
                    pii d1 = points[i]-points[farest[i][fi]];
                    pii d2 = points[j]-points[farest[j][fj]];
                    LD current =
                        sqrt ( length2(d1) *
                        length2(d2) / 4.0L ) * sinl ( angle ( d1 ) - angle(d2) );
                    result = max ( result, current );
                }
            }
        }
    }

    cout.precision(9);
    cout.setf(ios::fixed);
    cout << result << endl;

    return 0;
}


#include <cstdio>
#include <cstring>
#include <cstdlib>
#include <cmath>
#include <bitset>
#include <deque>
#include <list>
#include <map>
#include <queue>
#include <set>
#include <stack>
#include <vector>
#include <iostream>
#include <fstream>
#include <algorithm>
#include <complex>
#include <limits>
#include <numeric>
#include <string>
#include <utility>
using namespace std;
typedef long long LL;typedef long double LD;typedef vector<int> vi;typedef pair<int,int> pii;
const LD PI = 3.1415926535897932384626433832795L;const LD E = 2.7182818284590452353602874713527L;const LD PHI = 1.2*sin(0.3*PI);
template<class T>T sqr(const T x){return x*x;}
LL binpow(const LL a, const LL n, const LL mod){return n == 0 ? 1 : sqr( binpow ( a, n/2, mod ) ) % mod * ( n % 2 ? a : 1 ) % mod;}
LL gcd(const LL a, const LL b){return b ? gcd( b, a%b ) : a;}LL lcm(const LL a, const LL b){return a/gcd(a,b)*b;}

const int MAXN = 342;

pii points[MAXN];
pair<LL, int> sorting[MAXN];
int farest[MAXN][MAXN];

istream& operator >> ( istream &in, pii &p ){
    in >> p.first >> p.second;
    return in;
}

inline pii operator - ( const pii &a, const pii &b ){
    return make_pair(a.first-b.first, a.second-b.second);
}

inline LL length2(pii a){
    return sqr((LL)a.first)+sqr((LL)a.second);
}
inline LD length(pii a){
    return sqrt(length2(a)+.0);
}
inline LD angle(const pii &a){
    return atan2(a.second+.0, a.first+.0);
}

int main(){

    int n;
    cin >> n;

    for ( int i = 0; i < n; ++i ){
        cin >> points[i];
    }

    for ( int i = 0; i < n; ++i ){
        for ( int j = 0; j < n; ++j ){
            sorting[j] = make_pair(length2(points[i]-points[j]),j);
        }
        sort(sorting, sorting+n);
        reverse(sorting, sorting+n);
        for ( int j = 0; j < n; ++j ){
            farest[i][j] = sorting[j].second;
        }
    }

    LD result = 0.0;
    for ( int i = 0; i < n; ++i ){
        for ( int j = 0; j < n; ++j ){
            if ( i == j ){
                continue;
            }
            for ( int fi = 0; fi < min(15,n); ++fi ){
                if ( farest[i][fi] == i || farest[i][fi] == j){
                    continue;
                }
                for ( int fj = 0; fj < min(15,n); ++fj ){
                    if ( farest[j][fj] == i || farest[j][fj] == j || farest[j][fj] == farest[i][fi] ){
                        continue;
                    }
                    pii d1 = points[i]-points[farest[i][fi]];
                    pii d2 = points[j]-points[farest[j][fj]];
                    LD current =
                        sqrt ( length2(d1) *
                        length2(d2) / 4.0 ) * sin ( angle ( d1 ) - angle(d2) );
                    result = max ( result, current );
                }
            }
        }
    }

    cout << result << endl;

    return 0;
}


#include <cstdio>
#include <cstring>
#include <cstdlib>
#include <cmath>
#include <bitset>
#include <deque>
#include <list>
#include <map>
#include <queue>
#include <set>
#include <stack>
#include <vector>
#include <iostream>
#include <fstream>
#include <algorithm>
#include <complex>
#include <limits>
#include <numeric>
#include <string>
#include <utility>
using namespace std;
typedef long long LL;typedef long double LD;typedef vector<int> vi;typedef pair<int,int> pii;
const LD PI = 3.1415926535897932384626433832795L;const LD E = 2.7182818284590452353602874713527L;const LD PHI = 1.2*sin(0.3*PI);
template<class T>T sqr(const T x){return x*x;}
LL binpow(const LL a, const LL n, const LL mod){return n == 0 ? 1 : sqr( binpow ( a, n/2, mod ) ) % mod * ( n % 2 ? a : 1 ) % mod;}
LL gcd(const LL a, const LL b){return b ? gcd( b, a%b ) : a;}LL lcm(const LL a, const LL b){return a/gcd(a,b)*b;}

const int MAXN = 342;

pii points[MAXN];
pair<LL, int> sorting[MAXN];
int farest[MAXN][MAXN];

istream& operator >> ( istream &in, pii &p ){
    in >> p.first >> p.second;
    return in;
}

inline pii operator - ( const pii &a, const pii &b ){
    return make_pair(a.first-b.first, a.second-b.second);
}

inline LL length2(pii a){
    return sqr((LL)a.first)+sqr((LL)a.second);
}
inline LD length(pii a){
    return sqrt(length2(a)+.0);
}
inline LD angle(const pii &a){
    return atan2(a.second+.0, a.first+.0);
}

int main(){

    int n;
    cin >> n;

    for ( int i = 0; i < n; ++i ){
        cin >> points[i];
    }

    for ( int i = 0; i < n; ++i ){
        for ( int j = 0; j < n; ++j ){
            sorting[j] = make_pair(length2(points[i]-points[j]),j);
        }
        sort(sorting, sorting+n);
        reverse(sorting, sorting+n);
        for ( int j = 0; j < n; ++j ){
            farest[i][j] = sorting[j].second;
        }
    }

    LD result = 0.0;
    for ( int i = 0; i < n; ++i ){
        for ( int j = 0; j < n; ++j ){
            if ( i == j ){
                continue;
            }
            for ( int fi = 0; fi < min(5,n); ++fi ){
                if ( farest[i][fi] == i || farest[i][fi] == j){
                    continue;
                }
                for ( int fj = 0; fj < min(5,n); ++fj ){
                    if ( farest[j][fj] == i || farest[j][fj] == j || farest[j][fj] == farest[i][fi] ){
                        continue;
                    }
                    pii d1 = points[i]-points[farest[i][fi]];
                    pii d2 = points[j]-points[farest[j][fj]];
                    LD current =
                        sqrt ( length2(d1) *
                        length2(d2) / 4.0 ) * sin ( angle ( d1 ) - angle(d2) );
                    result = max ( result, current );
                }
            }
        }
    }

    cout << result << endl;

    return 0;
}


#include <iostream>
#include <stdio.h>
#include <utility>
#include <algorithm>
#include <cstring>
#include <vector>
#include <map>
#include <set>
#include <queue>
#include <math.h>
#include <cstdio>
#include <iomanip>

#define FOR(i,x,y) for(int i=(x);i<(y);i++)
#define RFOR(i,x,y) for(int i=(x);i>=(y);i--)
#define MIN(x,y) ((x)<(y)?(x):(y))
#define MAX(x,y) ((x)>(y)?(x):(y))
#define ABS(x) ((x)>0?(x):-(x))
#define SQ(x) ((x)*(x))
#define mset(x,y) memset(x,y,sizeof(x))

typedef long long int lli;
typedef long double ld;

using namespace std;

struct point
{
    int x,y;
};

point arr[400];

ld dist(int i, int j, int k)
{
    return 0.5*(ld)(arr[i].x*(arr[j].y-arr[k].y)+arr[j].x*(arr[k].y-arr[i].y)+arr[k].x*(arr[i].y-arr[j].y));
}

int main()
{
   // freopen("inp.txt","r",stdin);
    int n;
    scanf("%d",&n);
    for(int i=0;i<n;i++) scanf("%d%d",&arr[i].x,&arr[i].y);
    ld maxa=0,maxu,maxd;
    for(int i=0;i<n;i++)
        for(int j=0;j<n;j++)
            if(i!=j)
        {
            maxu=0;
            for(int k=0;k<n;k++)if(k!=i&&k!=j)if(dist(i,j,k)>maxu) maxu=dist(i,j,k);
            maxd=0;
            for(int k=0;k<n;k++)if(k!=i&&k!=j)if(dist(i,j,k)<maxd) maxd=dist(i,j,k);
            if(maxu-maxd>maxa) maxa=maxu-maxd;
        }
    std::cout<<std::setprecision(10)<<maxa;
    return 0;

}


#include <iostream>
#include <stdio.h>
#include <utility>
#include <algorithm>
#include <cstring>
#include <vector>
#include <map>
#include <set>
#include <queue>
#include <math.h>
#include <cstdio>

#define FOR(i,x,y) for(int i=(x);i<(y);i++)
#define RFOR(i,x,y) for(int i=(x);i>=(y);i--)
#define MIN(x,y) ((x)<(y)?(x):(y))
#define MAX(x,y) ((x)>(y)?(x):(y))
#define ABS(x) ((x)>0?(x):-(x))
#define SQ(x) ((x)*(x))
#define mset(x,y) memset(x,y,sizeof(x))

typedef long long int lli;
typedef long double ld;

using namespace std;

struct point
{
    int x,y;
};

point arr[400];

ld dist(int i, int j, int k)
{
    return 0.5*(ld)(arr[i].x*(arr[j].y-arr[k].y)+arr[j].x*(arr[k].y-arr[i].y)+arr[k].x*(arr[i].y-arr[j].y));
}

int main()
{
   // freopen("inp.txt","r",stdin);
    int n;
    scanf("%d",&n);
    for(int i=0;i<n;i++) scanf("%d%d",&arr[i].x,&arr[i].y);
    ld maxa=0,maxu,maxd;
    for(int i=0;i<n;i++)
        for(int j=0;j<n;j++)
            if(i!=j)
        {
            maxu=0;
            for(int k=0;k<n;k++)if(k!=i&&k!=j)if(dist(i,j,k)>maxu) maxu=dist(i,j,k);
            maxd=0;
            for(int k=0;k<n;k++)if(k!=i&&k!=j)if(dist(i,j,k)<maxd) maxd=dist(i,j,k);
            if(maxu-maxd>maxa) maxa=maxu-maxd;
        }
    cout<<maxa;
    return 0;

}


#include <iostream>
#include <stdio.h>
#include <utility>
#include <algorithm>
#include <cstring>
#include <vector>
#include <map>
#include <set>
#include <queue>
#include <math.h>
#include <cstdio>

#define FOR(i,x,y) for(int i=(x);i<(y);i++)
#define RFOR(i,x,y) for(int i=(x);i>=(y);i--)
#define MIN(x,y) ((x)<(y)?(x):(y))
#define MAX(x,y) ((x)>(y)?(x):(y))
#define ABS(x) ((x)>0?(x):-(x))
#define SQ(x) ((x)*(x))
#define mset(x,y) memset(x,y,sizeof(x))

typedef long long int lli;
typedef long double ld;

using namespace std;

struct point
{
    int x,y;
};

point arr[400];

ld dist(int i, int j, int k)
{
    return 0.5*(ld)(arr[i].x*(arr[j].y-arr[k].y)+arr[j].x*(arr[k].y-arr[i].y)+arr[k].x*(arr[i].y-arr[j].y));
}

int main()
{
   // freopen("inp.txt","r",stdin);
    int n;
    scanf("%d",&n);
    for(int i=0;i<n;i++) scanf("%d%d",&arr[i].x,&arr[i].y);
    ld maxa=0,maxu,maxd;
    for(int i=0;i<n;i++)
        for(int j=i+1;j<n;j++)
        {
            maxu=0;
            for(int k=0;k<n;k++)if(k!=i&&k!=j)if(dist(i,j,k)>maxu) maxu=dist(i,j,k);
            maxd=0;
            for(int k=0;k<n;k++)if(k!=i&&k!=j)if(dist(i,j,k)<maxd) maxd=dist(i,j,k);
            if(maxu-maxd>maxa) maxa=maxu-maxd;
        }
    printf("%0.10Lf",maxa);;
    return 0;

}


#include <iostream>
#include <stdio.h>
#include <utility>
#include <algorithm>
#include <cstring>
#include <vector>
#include <map>
#include <set>
#include <queue>
#include <math.h>
#include <cstdio>

#define FOR(i,x,y) for(int i=(x);i<(y);i++)
#define RFOR(i,x,y) for(int i=(x);i>=(y);i--)
#define MIN(x,y) ((x)<(y)?(x):(y))
#define MAX(x,y) ((x)>(y)?(x):(y))
#define ABS(x) ((x)>0?(x):-(x))
#define SQ(x) ((x)*(x))
#define mset(x,y) memset(x,y,sizeof(x))

typedef long long int lli;
typedef long double ld;

using namespace std;

struct point
{
    int x,y;
};

point arr[400];

ld dist(int i, int j, int k)
{
    return 0.5*(ld)(arr[i].x*(arr[j].y-arr[k].y)+arr[j].x*(arr[k].y-arr[i].y)+arr[k].x*(arr[i].y-arr[j].y));
}

int main()
{
   // freopen("inp.txt","r",stdin);
    int n;
    scanf("%d",&n);
    for(int i=0;i<n;i++) scanf("%d%d",&arr[i].x,&arr[i].y);
    ld maxa=0,maxu,maxd;
    for(int i=0;i<n;i++)
        for(int j=0;j<n;j++)
            if(i!=j)
        {
            maxu=0;
            for(int k=0;k<n;k++)if(k!=i&&k!=j)if(dist(i,j,k)>maxu) maxu=dist(i,j,k);
            maxd=0;
            for(int k=0;k<n;k++)if(k!=i&&k!=j)if(dist(i,j,k)<maxd) maxd=dist(i,j,k);
            if(maxu-maxd>maxa) maxa=maxu-maxd;
        }
    printf("%0.10Lf",maxa);
    return 0;

}


#include <iostream>
#include <stdio.h>
#include <utility>
#include <algorithm>
#include <cstring>
#include <vector>
#include <map>
#include <set>
#include <queue>
#include <math.h>
#include <cstdio>
#include <iomanip>

#define FOR(i,x,y) for(int i=(x);i<(y);i++)
#define RFOR(i,x,y) for(int i=(x);i>=(y);i--)
#define MIN(x,y) ((x)<(y)?(x):(y))
#define MAX(x,y) ((x)>(y)?(x):(y))
#define ABS(x) ((x)>0?(x):-(x))
#define SQ(x) ((x)*(x))
#define mset(x,y) memset(x,y,sizeof(x))

typedef long long int lli;
typedef long double ld;

using namespace std;

struct point
{
    int x,y;
};

point arr[400];

ld dist(int i, int j, int k)
{
    return 0.5*(ld)(arr[i].x*(arr[j].y-arr[k].y)+arr[j].x*(arr[k].y-arr[i].y)+arr[k].x*(arr[i].y-arr[j].y));
}

int main()
{
   // freopen("inp.txt","r",stdin);
    int n;
    scanf("%d",&n);
    for(int i=0;i<n;i++) scanf("%d%d",&arr[i].x,&arr[i].y);
    ld maxa=0,maxu,maxd;
    for(int i=0;i<n;i++)
        for(int j=0;j<n;j++)
            if(i!=j)
        {
            maxu=0;
            for(int k=0;k<n;k++)if(k!=i&&k!=j)if(dist(i,j,k)>maxu) maxu=dist(i,j,k);
            maxd=0;
            for(int k=0;k<n;k++)if(k!=i&&k!=j)if(dist(i,j,k)<maxd) maxd=dist(i,j,k);
            if(maxu==0.0||maxd==0.0) continue;
            if(maxu-maxd>maxa) {maxa=maxu-maxd;}//cout<<maxu<<" "<<maxd<<endl;}
        }
    std::cout<<std::setprecision(10)<<maxa;
    return 0;

}


#include <iostream>
#include <stdio.h>
#include <utility>
#include <algorithm>
#include <cstring>
#include <vector>
#include <map>
#include <set>
#include <queue>
#include <math.h>
#include <cstdio>

#define FOR(i,x,y) for(int i=(x);i<(y);i++)
#define RFOR(i,x,y) for(int i=(x);i>=(y);i--)
#define MIN(x,y) ((x)<(y)?(x):(y))
#define MAX(x,y) ((x)>(y)?(x):(y))
#define ABS(x) ((x)>0?(x):-(x))
#define SQ(x) ((x)*(x))
#define mset(x,y) memset(x,y,sizeof(x))

typedef long long int lli;
typedef long double ld;

using namespace std;

struct point
{
    int x,y;
};

point arr[400];

ld dist(int i, int j, int k)
{
    return 0.5*(ld)(arr[i].x*(arr[j].y-arr[k].y)+arr[j].x*(arr[k].y-arr[i].y)+arr[k].x*(arr[i].y-arr[j].y));
}

int main()
{
   // freopen("inp.txt","r",stdin);
    int n;
    scanf("%d",&n);
    for(int i=0;i<n;i++) scanf("%d%d",&arr[i].x,&arr[i].y);
    ld maxa=0,maxu,maxd;
    for(int i=0;i<n;i++)
        for(int j=i+1;j<n;j++)
        {
            maxu=0;
            for(int k=0;k<n;k++)if(k!=i&&k!=j)if(dist(i,j,k)>maxu) maxu=dist(i,j,k);
            maxd=0;
            for(int k=0;k<n;k++)if(k!=i&&k!=j)if(dist(i,j,k)<maxd) maxd=dist(i,j,k);
            if(maxu-maxd>maxa) maxa=maxu-maxd;
        }
    printf("%Lf",maxa);
    return 0;

}


#include <iostream>
#include <stdio.h>
#include <utility>
#include <algorithm>
#include <cstring>
#include <vector>
#include <map>
#include <set>
#include <queue>
#include <math.h>
#include <cstdio>
#include <iomanip>

#define FOR(i,x,y) for(int i=(x);i<(y);i++)
#define RFOR(i,x,y) for(int i=(x);i>=(y);i--)
#define MIN(x,y) ((x)<(y)?(x):(y))
#define MAX(x,y) ((x)>(y)?(x):(y))
#define ABS(x) ((x)>0?(x):-(x))
#define SQ(x) ((x)*(x))
#define mset(x,y) memset(x,y,sizeof(x))

typedef long long int lli;
typedef long double ld;

using namespace std;

struct point
{
    int x,y;
};

point arr[400];

ld dist(int i, int j, int k)
{
    return 0.5*(ld)(arr[i].x*(arr[j].y-arr[k].y)+arr[j].x*(arr[k].y-arr[i].y)+arr[k].x*(arr[i].y-arr[j].y));
}

int main()
{
    //freopen("inp.txt","r",stdin);
    int n;
    scanf("%d",&n);
    for(int i=0;i<n;i++) scanf("%d%d",&arr[i].x,&arr[i].y);
    ld maxa=0,maxu,maxd;
    for(int i=0;i<n;i++)
        for(int j=0;j<n;j++)
            if(i!=j)
        {
            maxu=0;
            for(int k=0;k<n;k++)if(k!=i&&k!=j)if(dist(i,j,k)>maxu) maxu=dist(i,j,k);
            maxd=0;
            for(int k=0;k<n;k++)if(k!=i&&k!=j)if(dist(i,j,k)<maxd) maxd=dist(i,j,k);
            if(maxu-maxd>maxa) maxa=maxu-maxd;
        }
    std::cout<<std::setprecision(10)<<maxa;
    return 0;

}


#include <iostream>
#include <stdio.h>
#include <utility>
#include <algorithm>
#include <cstring>
#include <vector>
#include <map>
#include <set>
#include <queue>
#include <math.h>
#include <cstdio>

#define FOR(i,x,y) for(int i=(x);i<(y);i++)
#define RFOR(i,x,y) for(int i=(x);i>=(y);i--)
#define MIN(x,y) ((x)<(y)?(x):(y))
#define MAX(x,y) ((x)>(y)?(x):(y))
#define ABS(x) ((x)>0?(x):-(x))
#define SQ(x) ((x)*(x))
#define mset(x,y) memset(x,y,sizeof(x))

typedef long long int lli;
typedef long double ld;

using namespace std;

struct point
{
    int x,y;
};

point arr[400];

ld dist(int i, int j, int k)
{
    return 0.5*(ld)(arr[i].x*(arr[j].y-arr[k].y)+arr[j].x*(arr[k].y-arr[i].y)+arr[k].x*(arr[i].y-arr[j].y));
}

int main()
{
    freopen("inp.txt","r",stdin);
    int n;
    scanf("%d",&n);
    for(int i=0;i<n;i++) scanf("%d%d",&arr[i].x,&arr[i].y);
    ld maxa=0,maxu,maxd;
    for(int i=0;i<n;i++)
        for(int j=i+1;j<n;j++)
        {
            maxu=0;
            for(int k=0;k<n;k++)if(k!=i&&k!=j)if(dist(i,j,k)>maxu) maxu=dist(i,j,k);
            maxd=0;
            for(int k=0;k<n;k++)if(k!=i&&k!=j)if(dist(i,j,k)<maxd) maxd=dist(i,j,k);
            if(maxu-maxd>maxa) maxa=maxu-maxd;
        }
    printf("%Lf",maxa);
    return 0;

}


#include <iostream>
#include <iomanip>
#include <cmath>

#define forn(i,x,y) for(int i=x;i<y;i++)
#define PII pair<int,int>
#define x first
#define y second

using namespace std;

double dist(pair<int,int> a, pair<int,int> b) {
    double res = (a.first - b.first) * (a.first - b.first);
    res += (a.second - b.second) * (a.second - b.second);
    return res;
}

long double get_area(PII a, PII b, PII c) {
    long double res = 0;
    res = a.x*(b.y-c.y) + b.x*(c.y-a.y) + c.x*(a.y-b.y);
    res /= 2.0;
    return (res < 0 ? -res : res);
}

int main(void) {
    int n; cin >> n;
    pair<int,int> pts[300];
    forn(i,0,n) {
        int a,b; cin >> a >> b; a+=1000;b +=1000;
        pts[i] = make_pair(a,b);
    }
    pair<int,int> maxia, maxda, maxid, maxdd;
    double minia = 1000000000, minda = 1000000000, minid = 1000000000, mindd = 1000000000;
    forn(i,0,n) {
        double dst = dist(pts[i], make_pair(0,0));
        if(dst < minia) {
            minia = dst;
            maxia = pts[i];
        }
    }
    forn(i,0,n) {
        if(pts[i] == maxia) continue;
        double dst = dist(pts[i], make_pair(2000,0));
        if(dst < minda) {
            minda = dst;
            maxda = pts[i];
        }
    }
    forn(i,0,n) {
        if(pts[i] == maxia or pts[i] == maxda) continue;
        double dst = dist(pts[i], make_pair(0,2000));
        if(dst < minid) {
            minid = dst;
            maxid = pts[i];
        }
    }
    forn(i,0,n) {
        if(pts[i] == maxia or pts[i] == maxda or pts[i] == maxid) continue;
        double dst = dist(pts[i], make_pair(2000,2000));
        if(dst < mindd) {
            mindd = dst;
            maxdd = pts[i];
        }
    }
    long double area = 0;
    area += get_area(maxia, maxda, maxid);
    area += get_area(maxda, maxid, maxdd);
    cout << setprecision(10) << area << endl;
}


#include <iostream>
#include <iomanip>
#include <cmath>

#define forn(i,x,y) for(int i=x;i<y;i++)
#define PII pair<int,int>
#define x first
#define y second

using namespace std;

double dist(pair<int,int> a, pair<int,int> b) {
    double res = (a.first - b.first) * (a.first - b.first);
    res += (a.second - b.second) * (a.second - b.second);
    return res;
}

long double get_area(PII a, PII b, PII c) {
    long double res = 0;
    res = a.x*(b.y-c.y) + b.x*(c.y-a.y) + c.x*(a.y-b.y);
    res /= 2.0;
    return (res < 0 ? -res : res);
}

int main(void) {
    int n; cin >> n;
    pair<int,int> pts[300];
    forn(i,0,n) {
        int a,b; cin >> a >> b;
        pts[i] = make_pair(a,b);
    }
    pair<int,int> maxia, maxda, maxid, maxdd;
    double minia = 1000000000, minda = 1000000000, minid = 1000000000, mindd = 1000000000;
    forn(i,0,n) {
        double dst = dist(pts[i], make_pair(-1000,-1000));
        if(dst < minia) {
            minia = dst;
            maxia = pts[i];
        }
    }
    forn(i,0,n) {
        if(pts[i] == maxia) continue;
        double dst = dist(pts[i], make_pair(1000,-1000));
        if(dst < minda) {
            minda = dst;
            maxda = pts[i];
        }
    }
    forn(i,0,n) {
        if(pts[i] == maxia or pts[i] == maxda) continue;
        double dst = dist(pts[i], make_pair(-1000,1000));
        if(dst < minid) {
            minid = dst;
            maxid = pts[i];
        }
    }
    forn(i,0,n) {
        if(pts[i] == maxia or pts[i] == maxda or pts[i] == maxid) continue;
        double dst = dist(pts[i], make_pair(1000,1000));
        if(dst < mindd) {
            mindd = dst;
            maxdd = pts[i];
        }
    }
    long double area = 0;
    area += get_area(maxia, maxda, maxid);
    area += get_area(maxda, maxid, maxdd);
    cout << setprecision(9) << fixed << area << endl;
}


#include <iostream>
#include <iomanip>
#include <cmath>

#define forn(i,x,y) for(int i=x;i<y;i++)
#define PII pair<int,int>
#define x first
#define y second

using namespace std;

double dist(pair<int,int> a, pair<int,int> b) {
    double res = (a.first - b.first) * (a.first - b.first);
    res += (a.second - b.second) * (a.second - b.second);
    return res;
}

long double get_area(PII a, PII b, PII c) {
    long double res = 0;
    res = a.x*(b.y-c.y) + b.x*(c.y-a.y) + c.x*(a.y-b.y);
    res /= 2.0;
    return (res < 0 ? -res : res);
}

int main(void) {
    int n; cin >> n;
    pair<int,int> pts[300];
    forn(i,0,n) {
        int a,b; cin >> a >> b;
        pts[i] = make_pair(a,b);
    }
    pair<int,int> maxia, maxda, maxid, maxdd;
    double minia = 1000000000, minda = 1000000000, minid = 1000000000, mindd = 1000000000;
    forn(i,0,n) {
        double dst = dist(pts[i], make_pair(-1000,-1000));
        if(dst < minia) {
            minia = dst;
            maxia = pts[i];
        }
    }
    forn(i,0,n) {
        if(pts[i] == maxia) continue;
        double dst = dist(pts[i], make_pair(1000,-1000));
        if(dst < minda) {
            minda = dst;
            maxda = pts[i];
        }
    }
    forn(i,0,n) {
        if(pts[i] == maxia or pts[i] == maxda) continue;
        double dst = dist(pts[i], make_pair(-1000,1000));
        if(dst < minid) {
            minid = dst;
            maxid = pts[i];
        }
    }
    forn(i,0,n) {
        if(pts[i] == maxia or pts[i] == maxda or pts[i] == maxid) continue;
        double dst = dist(pts[i], make_pair(1000,1000));
        if(dst < mindd) {
            mindd = dst;
            maxdd = pts[i];
        }
    }
    long double area = 0;
    area += get_area(maxia, maxda, maxid);
    area += get_area(maxda, maxid, maxdd);
    cout << setprecision(10) << area << endl;
}


#include <iostream>
#include <iomanip>

#define forn(i,x,y) for(int i=x;i<y;i++)
#define PII pair<int,int>
#define x first
#define y second

using namespace std;

long double get_area(PII a, PII b, PII c) {
    long double res = 0;
    res = a.x*(b.y-c.y) + b.x*(c.y-a.y) + c.x*(a.y-b.y);
    res /= 2.0;
    return (res < 0 ? -res : res);
}

int main(void) {
    int n; cin >> n;
    pair<int,int> pnt[300];
    forn(i,0,n) {
        int a,b; cin >> a >> b; a+=1000;b +=1000;
        pnt[i] = make_pair(a,b);
    }
    long double res = 0;
    forn(i,0,n) forn(j,i+1,n) {
        if(pnt[j].x-pnt[i].x == 0) continue;
        long double a = (pnt[j].y-pnt[i].y)/(pnt[j].x-pnt[i].x);
        long double b = pnt[i].y-a*pnt[i].x;
        long double maxad = 0, maxau = 0;
        forn(k,0,n) {
            if(k == i || k == j) continue;
            if(pnt[k].y < pnt[k].x*a+b)
                maxad = max(maxad, get_area(pnt[i],pnt[j],pnt[k]));
            else
                maxau = max(maxau, get_area(pnt[i],pnt[j],pnt[k]));
        }
        res = max(res, maxau+maxad);
    }
    cout << setprecision(10) << fixed << res << endl;
}


#include <iostream>
#include <iomanip>

#define forn(i,x,y) for(int i=x;i<y;i++)
#define PII pair<int,int>
#define x first
#define y second

using namespace std;

long double get_area(PII a, PII b, PII c) {
    long double res = 0;
    res = a.x*(b.y-c.y) + b.x*(c.y-a.y) + c.x*(a.y-b.y);
    res /= 2.0;
    return (res < 0 ? -res : res);
}

int main(void) {
    int n; cin >> n;
    pair<int,int> pnt[300];
    forn(i,0,n) {
        int a,b; cin >> a >> b; a+=1000;b +=1000;
        pnt[i] = make_pair(a,b);
    }
    long double res = 0;
    forn(i,0,n) forn(j,i+1,n) {
        if(pnt[j].x-pnt[i].x == 0) continue;
        double a = (pnt[j].y-pnt[i].y)/(pnt[j].x-pnt[i].x);
        double b = pnt[i].y-a*pnt[i].x;
        long double maxad = 0, maxau = 0;
        forn(k,0,n) {
            if(k == i || k == j) continue;
            if(pnt[k].y < pnt[k].x*a+b)
                maxad = max(maxad, get_area(pnt[i],pnt[j],pnt[k]));
            else
                maxau = max(maxau, get_area(pnt[i],pnt[j],pnt[k]));
        }
        res = max(res, maxau+maxad);
    }
    cout << setprecision(10) << res << endl;
}


#include <iostream>
#include <iomanip>

#define forn(i,x,y) for(int i=x;i<y;i++)
#define PII pair<int,int>
#define x first
#define y second

using namespace std;

long double get_area(PII a, PII b, PII c) {
    long double res = 0;
    res = a.x*(b.y-c.y) + b.x*(c.y-a.y) + c.x*(a.y-b.y);
    res /= 2.0;
    return (res < 0 ? -res : res);
}

int main(void) {
    int n; cin >> n;
    pair<int,int> pnt[300];
    forn(i,0,n) {
        int a,b; cin >> a >> b;
        pnt[i] = make_pair(a,b);
    }
    long double res = 0;
    forn(i,0,n) forn(j,i+1,n) {
        if(pnt[j].x-pnt[i].x == 0) continue;
        long double a = (pnt[j].y-pnt[i].y)/(long double)(pnt[j].x-pnt[i].x);
        long double b = pnt[i].y-a*pnt[i].x;
        long double maxad = 0, maxau = 0;
        forn(k,0,n) {
            if(k == i || k == j) continue;
            if(pnt[k].y < pnt[k].x*a+b)
                maxad = max(maxad, get_area(pnt[i],pnt[j],pnt[k]));
            else
                maxau = max(maxau, get_area(pnt[i],pnt[j],pnt[k]));
        }
        if(maxau > 0 && maxad > 0) res = max(res, maxau+maxad);
    }
    cout << setprecision(10) << fixed << res << endl;
}


#include <iostream>
#include <iomanip>

#define forn(i,x,y) for(int i=x;i<y;i++)
#define PII pair<int,int>
#define x first
#define y second

using namespace std;

long double get_area(PII a, PII b, PII c) {
    long double res = 0;
    res = a.x*(b.y-c.y) + b.x*(c.y-a.y) + c.x*(a.y-b.y);
    res /= 2.0;
    return (res < 0 ? -res : res);
}

int main(void) {
    int n; cin >> n;
    pair<int,int> pnt[300];
    forn(i,0,n) {
        int a,b; cin >> a >> b;
        pnt[i] = make_pair(a,b);
    }
    long double res = 0;
    forn(i,0,n) forn(j,i+1,n) {
        if(pnt[j].x-pnt[i].x == 0) continue;
        long double a = (pnt[j].y-pnt[i].y)/(pnt[j].x-pnt[i].x);
        long double b = pnt[i].y-a*pnt[i].x;
        long double maxad = 0, maxau = 0;
        forn(k,0,n) {
            if(k == i || k == j) continue;
            if(pnt[k].y < pnt[k].x*a+b)
                maxad = max(maxad, get_area(pnt[i],pnt[j],pnt[k]));
            else
                maxau = max(maxau, get_area(pnt[i],pnt[j],pnt[k]));
        }
        res = max(res, maxau+maxad);
    }
    cout << setprecision(10) << fixed << res << endl;
}


#include <iostream>
#include <iomanip>

#define forn(i,x,y) for(int i=x;i<y;i++)
#define PII pair<int,int>
#define x first
#define y second

using namespace std;

long double get_area(PII a, PII b, PII c) {
    long double res = 0;
    res = a.x*(b.y-c.y) + b.x*(c.y-a.y) + c.x*(a.y-b.y);
    res /= 2.0;
    return (res < 0 ? -res : res);
}

int main(void) {
    int n; cin >> n;
    pair<int,int> pnt[300];
    forn(i,0,n) {
        int a,b; cin >> a >> b;
        pnt[i] = make_pair(a,b);
    }
    long double res = 0;
    forn(i,0,n) forn(j,i+1,n) {
        if(pnt[j].x-pnt[i].x == 0) continue;
        long double a = (pnt[j].y-pnt[i].y)/(long double)(pnt[j].x-pnt[i].x);
        long double b = pnt[i].y-a*pnt[i].x;
        long double maxad = 0, maxau = 0;
        forn(k,0,n) {
            if(k == i || k == j) continue;
            if(pnt[k].y < pnt[k].x*a+b)
                maxad = max(maxad, get_area(pnt[i],pnt[j],pnt[k]));
            else
                maxau = max(maxau, get_area(pnt[i],pnt[j],pnt[k]));
        }
        res = max(res, maxau+maxad);
    }
    cout << setprecision(10) << fixed << res << endl;
}


#include <iostream>
#include <iomanip>
#include <cmath>

#define forn(i,x,y) for(int i=x;i<y;i++)
#define PII pair<int,int>
#define x first
#define y second

using namespace std;

double dist(pair<int,int> a, pair<int,int> b) {
    double res = (a.first - b.first) * (a.first - b.first);
    res += (a.second - b.second) * (a.second - b.second);
    return res;
}

long double get_area(PII a, PII b, PII c) {
    long double res = 0;
    res = a.x*(b.y-c.y) + b.x*(c.y-a.y) + c.x*(a.y-b.y);
    res /= 2.0;
    return (res < 0 ? -res : res);
    }

int main(void) {
    int n; cin >> n;
    pair<int,int> pts[300];
    forn(i,0,n) {
        int a,b; cin >> a >> b;
        pts[i] = make_pair(a,b);
    }
    pair<int,int> maxia, maxda, maxid, maxdd;
    double minia = 1000000000, minda = 1000000000, minid = 1000000000, mindd = 1000000000;
    forn(i,0,n) {
        double dst = dist(pts[i], make_pair(-1000,-1000));
        if(dst < minia) {
            minia = dst;
            maxia = pts[i];
        }
        dst = dist(pts[i], make_pair(1000,-1000));
        if(dst < minda) {
            minda = dst;
            maxda = pts[i];
        }
        dst = dist(pts[i], make_pair(-1000,1000));
        if(dst < minid) {
            minid = dst;
            maxid = pts[i];
        }
        dst = dist(pts[i], make_pair(1000,1000));
        if(dst < mindd) {
            mindd = dst;
            maxdd = pts[i];
        }
    }
    long double area = 0;
    area += get_area(maxia, maxda, maxid);
    area += get_area(maxda, maxid, maxdd);
    cout << setprecision(9) << fixed << area << endl;
}


/****************************************
**     Solution by Bekzhan Kassenov    **
****************************************/

#include <bits/stdc++.h>

using namespace std;

#define F first
#define S second
#define MP make_pair
#define INF (int)(2e9)
#define EPS 1e-9
#define MOD (1000 * 1000 * 1000 + 7)
#define all(x) (x).begin(), (x).end()

typedef pair <int, int> PII;
typedef vector <int> VI;
typedef vector <VI> VVI;
typedef long long ll;
typedef unsigned long long ull;
typedef long double ld;

template <typename T>
inline T sqr(T n) {
    return (n * n);
}

int n;
PII a[1000], b[1000], aa, bb;
bool used[1000];

int operator * (const PII& a, const PII& b) {
    return (a.F * b.S - b.F * a.S);
}

PII operator - (const PII& a, const PII& b) {
    return MP(a.F - b.F, a.S - b.S);
}

inline bool lo(const PII &t, const PII &a1, const PII &b) {
    return ((a1 - t) * (b - t) < 0);
}

inline int fastAbs(int n) {
    return ((n ^ (n >> 31)) - (n >> 31));
}

inline int fastMax(int x, int y) {
    return (((y - x) >> 31) & (x ^ y)) ^ y;
}

inline int S(int a1, int b1, int c1) {
    return fastAbs((a[b1] - a[a1]) * (a[c1] - a[a1]));
}

int read_int() {
    char c;

    bool flag = false;

    do {
        c = getchar();
        if (c == '-')
            flag = true;
    } while (c < '0' || c > '9');

    int res = 0;

    do {
        res = res * 10 + c - '0';
        c = getchar();
    } while (c >= '0' && c <= '9');

    if (flag)
        res *= -1;

    return res;
}

inline void build() {
    int mx = 0;

    for (int i = 1; i < n; i++) {
        if (b[i].S < b[mx].S || (b[i].S == b[mx].S && b[i].F < b[mx].F))
            mx = i;
    }

    a[0] = b[mx];
    int g = mx;
    used[mx] = true;

    int cnt = 1;

    for (int i = 1; i < n; i++) {
        int tmp = -1;

        for (int j = 0; j < n; j++) {
            if (!used[j] || j == g) {
                if (tmp == -1 || (b[tmp] - b[mx]) * (b[j] - b[mx]) < 0)
                    tmp = j;
            }
        }
        if (tmp == g)
            break;
        used[tmp] = true;
        a[i] = b[tmp];
        cnt++;
        mx = tmp;
    }

    n = cnt;
}

int main() {
    #ifndef ONLINE_JUDGE
        freopen("in", "r", stdin);
    #endif

    n = read_int();

    for (int i = 0; i < n; i++) {
        b[i].F = read_int();
        b[i].S = read_int();
    }

    if (n > 50)
        build();
    else
        for (int i = 0; i < n; i++)
            a[i] = b[i];

    int res = 0;

    for (int i = 0; i < n; i++) {
        for (int j = i + 1; j < n; j++) {
            int mx = -1, mx1 = -1;

            for (int k = 0; k < n; k++) {
                if ((i ^ k) && (j ^ k)) {
                    if (lo(a[i], a[j], a[k]))
                        mx = fastMax(mx, (S(i, j, k)));
                    else
                        mx1 = fastMax(mx1, (S(i, j, k)));
                }

            }

            if ((mx ^ -1) && (mx1 ^ -1))
                res = fastMax(res, mx + mx1);
        }
    }

    printf("%.14lf", (res + .0) / 2);

    return 0;
}


/****************************************
**     Solution by Bekzhan Kassenov    **
****************************************/

#include <bits/stdc++.h>

using namespace std;

#define F first
#define S second
#define MP make_pair

typedef pair <int, int> PII;

int n;
PII a[1000], b[1000], aa, bb;
bool used[1000];

inline int operator * (const PII& a, const PII& b) {
    return (a.F * b.S - b.F * a.S);
}

inline PII operator - (const PII& a, const PII& b) {
    return MP(a.F - b.F, a.S - b.S);
}

inline bool lo(const PII &t, const PII &a1, const PII &b) {
    return ((a1 - t) * (b - t) < 0);
}

inline int fastAbs(int n) {
    return ((n ^ (n >> 31)) - (n >> 31));
}

inline int fastMax(int x, int y) {
    return (((y - x) >> 31) & (x ^ y)) ^ y;
}

inline int S(int a1, int b1, int c1) {
    return fastAbs((a[b1] - a[a1]) * (a[c1] - a[a1]));
}

inline int read_int() {
    char c;

    bool flag = false;

    do {
        c = getchar();
        if (c == '-')
            flag = true;
    } while (c < '0' || c > '9');

    int res = 0;

    do {
        res = res * 10 + c - '0';
        c = getchar();
    } while (c >= '0' && c <= '9');

    if (flag)
        res *= -1;

    return res;
}

inline void build() {
    int mx = 0;

    for (int i = 1; i < n; i++) {
        if (b[i].S < b[mx].S || (b[i].S == b[mx].S && b[i].F < b[mx].F))
            mx = i;
    }

    a[0] = b[mx];
    int g = mx;
    used[mx] = true;

    int cnt = 1;

    for (int i = 1; i < n; i++) {
        int tmp = -1;

        for (int j = 0; j < n; j++) {
            if (!used[j] || j == g) {
                if (tmp == -1 || (b[tmp] - b[mx]) * (b[j] - b[mx]) < 0)
                    tmp = j;
            }
        }
        if (tmp == g)
            break;
        used[tmp] = true;
        a[i] = b[tmp];
        cnt++;
        mx = tmp;
    }

    n = cnt;
}

int main() {
    #ifndef ONLINE_JUDGE
        freopen("in", "r", stdin);
    #endif

    n = read_int();

    for (int i = 0; i < n; i++) {
        b[i].F = read_int();
        b[i].S = read_int();
    }

    if (n > 20)
        build();
    else
        for (int i = 0; i < n; i++)
            a[i] = b[i];

    int res = 0;

    for (int i = 0; i < n; i++) {
        for (int j = i + 1; j < n; j++) {
            int mx = -1, mx1 = -1;

            for (int k = 0; k < n; k++) {
                if ((i ^ k) && (j ^ k)) {
                    if (lo(a[i], a[j], a[k]))
                        mx = fastMax(mx, (S(i, j, k)));
                    else
                        mx1 = fastMax(mx1, (S(i, j, k)));
                }

            }

            if ((mx ^ -1) && (mx1 ^ -1))
                res = fastMax(res, mx + mx1);
        }
    }

    printf("%.14lf", (res + .0) / 2);

    return 0;
}


/****************************************
**     Solution by Bekzhan Kassenov    **
****************************************/

#include <bits/stdc++.h>

using namespace std;

#define F first
#define S second
#define MP make_pair
#define INF (int)(2e9)
#define EPS 1e-9
#define MOD (1000 * 1000 * 1000 + 7)
#define all(x) (x).begin(), (x).end()

typedef pair <int, int> PII;
typedef vector <int> VI;
typedef vector <VI> VVI;
typedef long long ll;
typedef unsigned long long ull;
typedef long double ld;

template <typename T>
inline T sqr(T n) {
    return (n * n);
}

int n;
PII a[1000], b[1000], aa, bb;
bool used[1000];

int operator * (const PII& a, const PII& b) {
    return (a.F * b.S - b.F * a.S);
}

PII operator - (const PII& a, const PII& b) {
    return MP(a.F - b.F, a.S - b.S);
}

inline bool lo(const PII &t, const PII &a1, const PII &b) {
    return ((a1 - t) * (b - t) < 0);
}

inline int fastAbs(int n) {
    return ((n ^ (n >> 31)) - (n >> 31));
}

inline int fastMax(int x, int y) {
    return (((y - x) >> 31) & (x ^ y)) ^ y;
}

inline int S(int a1, int b1, int c1) {
    return fastAbs((a[b1] - a[a1]) * (a[c1] - a[a1]));
}

int read_int() {
    char c;

    bool flag = false;

    do {
        c = getchar();
        if (c == '-')
            flag = true;
    } while (c < '0' || c > '9');

    int res = 0;

    do {
        res = res * 10 + c - '0';
        c = getchar();
    } while (c >= '0' && c <= '9');

    if (flag)
        res *= -1;

    return res;
}

inline void build() {
    int mx = 0;

    for (int i = 1; i < n; i++) {
        if (b[i].S < b[mx].S || (b[i].S == b[mx].S && b[i].F < b[mx].F))
            mx = i;
    }

    a[0] = b[mx];
    int g = mx;
    used[mx] = true;

    int cnt = 1;

    for (int i = 1; i < n; i++) {
        int tmp = -1;

        for (int j = 0; j < n; j++) {
            if (!used[j] || j == g) {
                if (tmp == -1 || (b[tmp] - b[mx]) * (b[j] - b[mx]) < 0)
                    tmp = j;
            }
        }
        if (tmp == g)
            break;
        used[tmp] = true;
        a[i] = b[tmp];
        cnt++;
        mx = tmp;
    }

    n = cnt;
}

int main() {
    #ifndef ONLINE_JUDGE
        freopen("in", "r", stdin);
    #endif

    n = read_int();

    for (int i = 0; i < n; i++) {
        b[i].F = read_int();
        b[i].S = read_int();
    }

    if (n > 10)
        build();
    else
        for (int i = 0; i < n; i++)
            a[i] = b[i];

    int res = 0;

    for (int i = 0; i < n; i++) {
        for (int j = i + 1; j < n; j++) {
            int mx = -1, mx1 = -1;

            for (int k = 0; k < n; k++) {
                if ((i ^ k) && (j ^ k)) {
                    if (lo(a[i], a[j], a[k]))
                        mx = fastMax(mx, (S(i, j, k)));
                    else
                        mx1 = fastMax(mx1, (S(i, j, k)));
                }

            }

            if ((mx ^ -1) && (mx1 ^ -1))
                res = fastMax(res, mx + mx1);
        }
    }

    printf("%.14lf", (res + .0) / 2);

    return 0;
}


/****************************************
**     Solution by Bekzhan Kassenov    **
****************************************/

#include <bits/stdc++.h>

using namespace std;

#define F first
#define S second
#define MP make_pair
#define INF (int)(2e9)
#define EPS 1e-9
#define MOD (1000 * 1000 * 1000 + 7)
#define all(x) (x).begin(), (x).end()

typedef pair <int, int> PII;
typedef vector <int> VI;
typedef vector <VI> VVI;
typedef long long ll;
typedef unsigned long long ull;
typedef long double ld;

template <typename T>
inline T sqr(T n) {
    return (n * n);
}

int n;
PII a[1000];

bool hi(PII t, PII a, PII b) {
    PII aa(MP(a.F - t.F, a.S - t.S));
    PII bb(MP(b.F - t.F, b.S - t.S));

    if (aa.F * bb.S - aa.S * bb.F > 0)
        return true;

    return false;
}

bool lo(PII t, PII a1, PII b) {
    PII aa(MP(a1.F - t.F, a1.S - t.S));
    PII bb(MP(b.F - t.F, b.S - t.S));

    if (aa.F * bb.S - aa.S * bb.F < 0)
        return true;

    return false;
}

double S(int a1, int b1, int c1) {
    PII aa = MP(a[b1].F - a[a1].F, a[b1].S - a[a1].S);
    PII bb = MP(a[c1].F - a[a1].F, a[c1].S - a[a1].S);

    double res = abs(aa.F * bb.S - aa.S * bb.F);

    return res / 2;
}

int main() {
    #ifndef ONLINE_JUDGE
        freopen("in", "r", stdin);
    #endif

    scanf("%d", &n);

    for (int i = 0; i < n; i++)
        scanf("%d%d", &a[i].F, &a[i].S);

    double res = 0;

    for (int i = 0; i < n; i++) {
        for (int j = 0; j < n; j++) {
            vector <double> s1, s2;

            for (int k = 0; k < n; k++) {
                if (lo(a[i], a[j], a[k]))
                    s1.push_back(S(i, j, k));
                else
                    s2.push_back(S(i, j, k));
            }

            double mx = 0;

            for (int k = 0; k < (int)s1.size(); k++)
                mx = max(mx, s1[k]);

            double mx1 = 0;

            for (int k = 0; k < (int)s2.size(); k++)
                mx1 = max(mx1, s2[k]);

            res = max(res, mx + mx1);
        }
    }

    printf("%.14lf", res);

    return 0;
}


/****************************************
**     Solution by Bekzhan Kassenov    **
****************************************/

#include <bits/stdc++.h>

using namespace std;

#define F first
#define S second
#define MP make_pair
#define INF (int)(2e9)
#define EPS 1e-9
#define MOD (1000 * 1000 * 1000 + 7)
#define all(x) (x).begin(), (x).end()

typedef pair <int, int> PII;
typedef vector <int> VI;
typedef vector <VI> VVI;
typedef long long ll;
typedef unsigned long long ull;
typedef long double ld;

template <typename T>
inline T sqr(T n) {
    return (n * n);
}

int n;
PII a[1000];

bool lo(PII t, PII a1, PII b) {
    PII aa(MP(a1.F - t.F, a1.S - t.S));
    PII bb(MP(b.F - t.F, b.S - t.S));

    return (aa.F * bb.S - aa.S * bb.F < 0);
}

double S(int a1, int b1, int c1) {
    PII aa = MP(a[b1].F - a[a1].F, a[b1].S - a[a1].S);
    PII bb = MP(a[c1].F - a[a1].F, a[c1].S - a[a1].S);

    return abs(aa.F * bb.S - aa.S * bb.F);

}

int main() {
    #ifndef ONLINE_JUDGE
        freopen("in", "r", stdin);
    #endif

    scanf("%d", &n);

    for (int i = 0; i < n; i++)
        scanf("%d%d", &a[i].F, &a[i].S);

    double res = 0;

    for (int i = 0; i < n; i++) {
        for (int j = i + 1; j < n; j++) {
            double mx = -1, mx1 = -1;

            for (int k = 0; k < n; k++) {
                if (i != j && i != k && j != k) {
                    if (lo(a[i], a[j], a[k]))
                        mx = max(mx, (S(i, j, k)));
                    else
                        mx1 = max(mx1, (S(i, j, k)));
                }

            }

            if (mx != -1 && mx1 != -1)
                res = max(res, mx + mx1);
        }
    }

    printf("%.14lf", res / 2);

    return 0;
}