#include <iostream>
#include <sstream>
#include <iomanip>
#include <vector>
#include <string>
#include <map>
#include <set>
#include <algorithm>
#include <numeric>
#include <iterator>
#include <functional>
#include <complex>
#include <queue>
#include <stack>
#include <cmath>
#include <cassert>
#include <cstring>
using namespace std;
typedef long long LL;
typedef complex<double> CMP;
double outer_prod(const CMP& a, const CMP& b) { return imag(conj(a)*b); }
double inner_prod(const CMP& a, const CMP& b) { return real(conj(a)*b); }
int ccw(const CMP& a, CMP b, CMP c) {
b -= a; c -= a;
if( outer_prod(b,c) > 0 ) return +1; // counter clockwise
if( outer_prod(b,c) < 0 ) return -1; // clockwise
if( inner_prod(b,c) < 0 ) return +2; // c--a--b on line
if( norm(b) < norm(c) ) return -2; // a--b--c on line
return 0;
}
bool byX( const CMP& a, const CMP& b ) {
if( a.real() != b.real() )
return a.real() < b.real();
return a.imag() < b.imag();
}
vector<CMP> convex_hull( vector<CMP> p )
{
#define IS_RIGHT <0 // skip on-line verts
//#define IS_RIGHT ==-1 // take all
sort(p.begin(), p.end(), &byX);
vector<CMP> ans;
for(int i=0; i<p.size(); ans.push_back(p[i++])) // left-to-right
while( ans.size()>=2 && ccw(ans[ans.size()-2], ans[ans.size()-1], p[i]) IS_RIGHT )
ans.pop_back();
if( ans.size() == p.size() )
return ans;
for(int i=p.size()-2; i>=0; ans.push_back(p[i--])) // right-to-left
while( ans.size()>=2 && ccw(ans[ans.size()-2], ans[ans.size()-1], p[i]) IS_RIGHT )
ans.pop_back();
ans.pop_back();
return ans;
}
double area( const vector<CMP>& q )
{
double a = 0.0;
CMP o = q[0];
for(int i=1; i+1<q.size(); ++i)
a += outer_prod(q[i]-o, q[i+1]-o);
return abs(a)/2;
}
class BatmanAndRobin { public:
double minArea(vector <int> x, vector <int> y)
{
int N = x.size();
vector<CMP> p;
for(int i=0; i<N; ++i)
p.push_back(CMP(x[i],y[i]));
const double eps = 1e-6;
CMP diff[] = {CMP(eps,0), CMP(0,eps), CMP(-eps,0), CMP(0,-eps)};
double answer = area(convex_hull(p));
for(int i=0; i<N; ++i)
for(int j=i+1; j<N; ++j) {
for(int di=0; di<4; ++di)
for(int dj=0; dj<4; ++dj) {
vector<CMP> a = left_of(p, p[i]+diff[di], p[j]+diff[dj]);
vector<CMP> b = right_of(p, p[i]+diff[di], p[j]+diff[dj]);
double aa = a.size()<=2 ? 0 : area(convex_hull(a));
double bb = b.size()<=2 ? 0 : area(convex_hull(b));
answer = min(answer, max(aa,bb));
}
}
return answer;
}
vector<CMP> left_of(const vector<CMP>& p, const CMP& o, CMP v)
{
v -= o;
vector<CMP> r;
for(int i=0; i<p.size(); ++i)
if( is_left(p[i]-o, v) )
r.push_back(p[i]);
return r;
}
vector<CMP> right_of(const vector<CMP>& p, const CMP& o, CMP v)
{
v -= o;
vector<CMP> r;
for(int i=0; i<p.size(); ++i)
if( !is_left(p[i]-o, v) )
r.push_back(p[i]);
return r;
}
bool is_left(const CMP& p, const CMP& v)
{
return arg(p/v)>0;
}
};
// BEGIN CUT HERE
#include <ctime>
double start_time; string timer()
{ ostringstream os; os << " (" << int((clock()-start_time)/CLOCKS_PER_SEC*1000) << " msec)"; return os.str(); }
template<typename T> ostream& operator<<(ostream& os, const vector<T>& v)
{ os << "{ ";
for(typename vector<T>::const_iterator it=v.begin(); it!=v.end(); ++it)
os << '\"' << *it << '\"' << (it+1==v.end() ? "" : ", "); os << " }"; return os; }
void verify_case(const double& Expected, const double& Received) {
bool ok = (abs(Expected - Received) < 1e-9);
if(ok) cerr << "PASSED" << timer() << endl; else { cerr << "FAILED" << timer() << endl;
cerr << "\to: \"" << Expected << '\"' << endl << "\tx: \"" << Received << '\"' << endl; } }
#define CASE(N) {cerr << "Test Case #" << N << "..." << flush; start_time=clock();
#define END verify_case(_, BatmanAndRobin().minArea(x, y));}
int main(){
CASE(0)
int x_[] = {100,100,90,90,-100,-100,-90,-90};
vector <int> x(x_, x_+sizeof(x_)/sizeof(*x_));
int y_[] = {100,90,100,90,-100,-90,-100,-90};
vector <int> y(y_, y_+sizeof(y_)/sizeof(*y_));
double _ = 100.0;
END
CASE(1)
int x_[] = {-1000,-1000,1000,1000,1000,-1000};
vector <int> x(x_, x_+sizeof(x_)/sizeof(*x_));
int y_[] = {-1000,1000,-1000,1000,0,0};
vector <int> y(y_, y_+sizeof(y_)/sizeof(*y_));
double _ = 0.0;
END
CASE(2)
int x_[] = {-1000,-1000,1000,1000,0};
vector <int> x(x_, x_+sizeof(x_)/sizeof(*x_));
int y_[] = {-1000,1000,-1000,1000,0};
vector <int> y(y_, y_+sizeof(y_)/sizeof(*y_));
double _ = 1000000.0;
END
CASE(3)
int x_[] = {-904,-812,-763,-735,-692,-614,-602,-563,-435,-243,-87,-52,-28,121,126,149,157,185,315,336,390,470,528,591,673,798,815,837,853,874};
vector <int> x(x_, x_+sizeof(x_)/sizeof(*x_));
int y_[] = {786,10,-144,949,37,-857,-446,-969,-861,-712,5,-972,-3,-202,-845,559,-244,-542,-421,422,526,-501,-791,-899,-315,281,-275,467,743,-321};
vector <int> y(y_, y_+sizeof(y_)/sizeof(*y_));
double _ = 1067472.0;
END
CASE(4)
int x_[] = {-904,-812,-763,-735,-692,-614,-602,-563,-435,-243,-87,-52,-28,121,126,149,157,185,315,336,390,470,528,591,673,798,815,837,853,874,1,2,3,4,5,6,7,8,9,10,11,12,13,14,15,16,17,18,19,20};
vector <int> x(x_, x_+sizeof(x_)/sizeof(*x_));
int y_[] = {786,10,-144,949,37,-857,-446,-969,-861,-712,5,-972,-3,-202,-845,559,-244,-542,-421,422,526,-501,-791,-899,-315,281,-275,467,743,-321,1,2,3,4,5,6,7,8,9,10,11,12,13,14,15,16,17,18,19,20};
vector <int> y(y_, y_+sizeof(y_)/sizeof(*y_));
double _ = -1;
END
/*
CASE(5)
int x_[] = ;
vector <int> x(x_, x_+sizeof(x_)/sizeof(*x_));
int y_[] = ;
vector <int> y(y_, y_+sizeof(y_)/sizeof(*y_));
double _ = ;
END
*/
}
// END CUT HERE