#include <stdlib.h>
#include <fstream>
#include <iostream>
#include <string>
#include <queue>
#include <stack>
#include <vector>
#include <string.h>
#include <iomanip>
#include <time.h>
#include <list>
#include <algorithm>
#include <math.h>
#include <assert.h>
using namespace std;


const string file = "rubarba";

const string infile = file + ".in";
const string outfile = file + ".out";

struct Point
{
	Point(int x, int y)
	{
		this->x = x;
		this->y = y;
	}
	int x;
	int y;
};


vector<Point> points;
vector<Point> convexHull;
int N;
long double minArea;

long long CrossProduct(const Point& s, const Point& p1, const Point& p2)
{
	long long result = 1LL * (p1.x - s.x)*(p2.y - s.y) - 1LL * (p1.y - s.y) * (p2.x - s.x);
	return result;
}


Point Substract(const Point&a, const Point &b)
{
	int px = b.x - a.x;
	int py = b.y - a.y;

	return Point(px, py);
}

long double Distance(const Point&a)
{
	return sqrt((long double)(a.x * a.x) + a.y * a.y);
}


bool SortPredicate(const Point& a, const Point& b)
{

	long double val1 = 1.0*(a.y - points[0].y )/(1.0*a.x - points[0].x);
	long double val2 = 1.0*(b.y - points[0].y )/(1.0*b.x - points[0].x);

	if(val1 < val2)
	{
		return true;
	}

	if(val1 > val2)
	{
		return false;
	}

	return Distance(Substract(a, points[0])) < Distance(Substract(b, points[0]));

	
}

void citire()
{
	ifstream fin(infile.c_str());

	fin >> N;
	points.reserve(N);
	int minI = 0;
	for(int i = 0 ; i < N; i++)
	{
		int x, y;
		fin >> x >> y;
		points.push_back(Point(x, y));

		if(points[minI].x > x)
		{
			minI = i;
		}
		else if(points[minI].x == x)
		{
			minI = points[minI].y > y ? i : minI;
		}

	}

	swap(points[0], points[minI]);

	fin.close();
}

void GrahamScan()
{
	sort(points.begin() + 1, points.end(), SortPredicate);

	for(int i = 0; i < N; i++)
	{
		while(convexHull.size() >= 2 && CrossProduct(convexHull[convexHull.size() - 2], convexHull[convexHull.size() - 1], points[i]) <= 0LL)
		{
			convexHull.pop_back();
		}

		convexHull.push_back(points[i]);
	}

}

struct PointD
{
	long double x;
	long double y;

	PointD()
	{

	}

	PointD(long double x, long double y)
	{
		this->x = x;
		this->y = y;
	}
};


struct LineD
{
	LineD()
	{

	}

	LineD(const Point& p1, const Point& p2)
	{
		this->slope = 1.0 *(p2.y - p1.y) / (p2.x - p1.x);
		this->c = p1.y - p1.x * slope;
	}

	LineD(const Point& p1, long double slope)
	{
		this->c = p1.y - p1.x * slope;
		this->slope = slope;
	}

	long double slope;
	long double c;
};


PointD GetIntersection(const LineD& l1, const LineD& l2)
{

	long double px = (l1.c - l2.c)/(l2.slope - l1.slope);
	long double py = l1.slope * px + l1.c;

	return PointD(px, py);
}

long double ProdusScalar(const PointD& p1, const PointD& p2)
{
	return p1.x * p2.x + p1.y * p2.y;
}

long double Norma(const PointD& p)
{
	return sqrt(p.x * p.x + p.y * p.y);
}


PointD Translate(const PointD& p1, const PointD& p2)
{
	return PointD(p2.x - p1.x, p2.y - p1.y);
}

void RotateClockwise(PointD& p, long double sine, long double cosine)
{
	long double x = p.x;
	long double y = p.y;
	p.x = x * cosine + y * sine;
	p.y =  - x * sine + y * cosine;
}

int Next(int i)
{
	return i == 0 ? convexHull.size() - 1 : i - 1;
}


struct Calliper
{
	int p;
	PointD v;

	long double nextAngle;
	void rotate(long double sine, long double cosine)
	{
		if(fabs(cosine - nextAngle) <= 0.000000001L)
		{
			p = Next(p);
		}
		RotateClockwise(v, sine, cosine);
	}

	long double getNextAngle()
	{
		Point &p1 = convexHull[p];
		Point &p2 = convexHull[Next(p)];

		Point translated = Substract(p1, p2);
		PointD t(translated.x, translated.y);

		long double ang = ProdusScalar(v, t) / Norma(t);
		nextAngle = ang;
		return ang;
	}

	PointD getIntersection(const Calliper & other)
	{
		long double slope = v.y / v.x;
		LineD l(convexHull[p], slope);
		long double slope2 = other.v.y / other.v.x;
		LineD l2(convexHull[other.p], slope2);

		return GetIntersection(l, l2);

	}

};


Calliper cal[4];


void initCallipers()
{
	int xMin = 0;
	int xMax = 0;
	int yMin = 0;
	int yMax = 0;
	
	for(unsigned int i = 0; i < convexHull.size(); i++)
	{
		int currentPoint = i;

		xMin = convexHull[currentPoint].x < convexHull[xMin].x ? currentPoint : xMin;
		xMax = convexHull[currentPoint].x > convexHull[xMax].x ? currentPoint : xMax; 

		yMin = convexHull[currentPoint].y < convexHull[yMin].y ? currentPoint : yMin;
		yMax = convexHull[currentPoint].y > convexHull[yMax].y ? currentPoint : yMax;

	}

	long double dXdif = (convexHull[xMax].x - convexHull[xMin].x);
	long double dYdif = (convexHull[yMax].y - convexHull[yMin].y);
	minArea = dXdif * dYdif;

	cal[0].v = PointD(0, 1); cal[0].p = xMin;
	cal[1].v = PointD(0, -1); cal[1].p = xMax;
	cal[2].v = PointD(-1, 0); cal[2].p = yMin;
	cal[3].v = PointD(1, 0); cal[3].p = yMax;

}

void RotatingCallipers()
{

	if(convexHull.size() <= 2)
	{
		minArea = 0;
		return;
	}

	initCallipers();
	PointD x(0, 1);


	while(ProdusScalar(x, cal[0].v) >= -0.1L)
	{
		long double minAngle = -1;

		for(int i = 0; i < 4; i++)
		{
			minAngle = max(minAngle, cal[i].getNextAngle());
		}

		long double sine = sqrt(1.0L - minAngle * minAngle);


		for(int i = 0; i < 4; i++)
		{
			cal[i].rotate(sine, minAngle);
		}

		//if(ProdusScalar(x, cal[0].v) < 0.0L)
			//break;

		PointD A = cal[0].getIntersection(cal[3]);
		PointD B = cal[3].getIntersection(cal[1]);
		PointD C = cal[2].getIntersection(cal[0]);
		PointD D = cal[2].getIntersection(cal[1]);


		PointD AB = Translate(B, A);
		PointD AC = Translate(C, A);

		long double area = Norma(AB) * Norma(AC);

		if(area != area)
			continue;

		minArea = min(area, minArea);

		cout << "NORMA(AB) =\t" << Norma(AB) << "\n";
		cout << "NORMA(AC) =\t" << Norma(AC) << "\n";

		cout << setprecision(8);
		cout << "A =\t" << A.x  << "\t" << A.y << "\n";
		cout << "B =\t" << B.x  << "\t" << B.y << "\n";
		cout << "C =\t" << C.x  << "\t" << C.y << "\n";
		cout << "D =\t" << D.x  << "\t" << D.y << "\n";
		
		cout << fixed << setprecision(2) << "AREA =\t" <<  area << "\n";  

		cout << "\n";

	}	

}


void solve()
{
	GrahamScan();
	RotatingCallipers();
}

void afisare()
{
	ofstream fout(outfile.c_str());

	fout << fixed << setprecision(2) << minArea << "\n";

	fout.close();
}


int main()
{
	citire();
	solve();
	afisare();
}