#include <iostream>
#include <fstream>
#include <algorithm>
#include <cmath>
#define NMax 100010
#define limit 1000000
#define Next ++position == limit?f.read(buffer, limit), position = 0:0
#define ch buffer[position]
#define EPS 1e-9
#define INF 2000000000
#define fINF 1e15
using namespace std;
double ans = fINF;
int st[NMax];
ifstream f ("rubarba.in");
int position;
char buffer[limit];
int n;
struct punct
{
int x, y;
punct ()
{
x = y = 0;
}
punct (const int _x, const int _y)
{
x = _x;
y = _y;
}
};
punct a[2*NMax];
inline void Read(int &x)
{
for (; ch < '0' || ch > '9'; Next);
for (x = 0; '0' <= ch && ch <= '9'; x = x*10 + ch - '0', Next);
}
void Read()
{
f.read(buffer, limit);
Read(n);
int pos = 1;
for (int i=1; i<=n; ++i)
{
int x, y;
Read(x), Read(y);
a[i] = punct(x, y);
if (y < a[pos].y || (y == a[pos].y && x < a[pos].x))
pos = i;
}
f.close();
swap(a[1], a[pos]);
}
inline long long sqr(const int x)
{
return 1LL * x * x;
}
inline double fsqr(const double x)
{
return x * x;
}
inline double Dist(const punct &A, const punct &B)
{
return sqrt(1.0*(sqr(A.x-B.x)+sqr(A.y-B.y)));
}
inline bool cmp(const punct &A, const punct &B)
{
long long p1, p2;
p1 = 1LL*(A.y - a[1].y)*(B.x - a[1].x);
p2 = 1LL*(B.y - a[1].y)*(A.x - a[1].x);
if (p1 == p2)
return (Dist(A, a[1]) < Dist(B, a[1]));
return p1 < p2;
}
inline long long Det(const punct &A, const punct &B, const punct &C)
{
// A.x A.y 1
// B.x B.y 1
// C.x C.y 1
return 1LL*A.x*B.y + 1LL*A.y*C.x + 1LL*B.x*C.y - 1LL*B.y*C.x - 1LL*A.x*C.y - 1LL*B.x*A.y;
}
void ConvexHull()
{
sort(a+2, a+n+1, cmp);
int vf, i;
long long o;
vf = 0;
st[++vf] = 1;
st[++vf] = 2;
for (i = 3; i<=n; ++i)
{
o = Det(a[st[vf-1]], a[st[vf]], a[i]);
if (o == 0)
st[vf] = i;
else
if (o > 0)
st[++vf] = i;
else
{
while (vf >= 2 && o < 0)
{
--vf;
o = Det(a[st[vf-1]], a[st[vf]], a[i]);
}
st[++vf] = i;
}
}
for (i=1; i<=vf; ++i)
a[i] = a[st[i]];
n = vf + vf;
for (; i<=n; ++i)
a[i] = a[i-vf];
}
inline double DistP_dr(const punct &pct, const int &A, const int &B, const long long &C)
{
return fabs(1.0*(1LL*A*pct.x + 1LL*B*pct.y + C)) / sqrt(1.0*(sqr(A) + sqr(B)));
}
inline double Distanta_in_dreapta(const int ind1, const int ind2, const double dist12, const int ind, const int coefa, const int coefb, const long long coefc)
{
double _aux, _aux2, d, dd;
_aux = DistP_dr(a[ind], coefa, coefb, coefc);
_aux2 = Dist(a[ind], a[ind2]);
d = sqrt(fsqr(_aux2) - fsqr(_aux));
dd = sqrt(fsqr(Dist(a[ind], a[ind1])) - fsqr(_aux));
if (fabs(dd - d - dist12) <= EPS)
return d;
return -1.0;
}
inline double Distanta_in_stanga(const int ind1, const int ind2, const double dist12, const int ind, const int coefa, const int coefb, const long long coefc)
{
double _aux, _aux2, d, dd;
_aux = DistP_dr(a[ind], coefa, coefb, coefc);
_aux2 = Dist(a[ind], a[ind1]);
d = sqrt(fsqr(_aux2) - fsqr(_aux));
dd = sqrt(fsqr(Dist(a[ind], a[ind2])) - fsqr(_aux));
if (fabs(dd - d - dist12) <= EPS)
return d;
return -1.0;
}
inline double AreaDreptunghi(const int ind1, const int ind2, const double dist12, const int sus, const int stanga, const int dreapta, const int coefa, const int coefb, const long long coefc)
{
double x = DistP_dr(a[sus], coefa, coefb, coefc);
double y = dist12 + Distanta_in_dreapta(ind1, ind2, dist12, dreapta, coefa, coefb, coefc) + Distanta_in_stanga(ind1, ind2, dist12, stanga, coefa, coefb, coefc);
return x * y;
}
void Solve()
{
ConvexHull();
int i, sus = 1, stanga, dreapta;
stanga = 1;
dreapta = 2;
double distmaxsus, distmaxstanga, distmaxdreapta;
double dist12 = Dist(a[1], a[2]);
int coefa, coefb;
long long coefc;
distmaxdreapta = distmaxstanga = distmaxsus = -1.0;
coefa = a[1].y - a[2].y;
coefb = a[2].x - a[1].x;
coefc = 1LL*a[1].x*a[2].y - 1LL*a[1].y*a[2].x;
//cout<<coefa<<" "<<coefb<<" "<<coefc<<"\n";
int n2 = n/2;
for (i = 3; i<= n2; ++i)
{
double _aux = DistP_dr(a[i], coefa, coefb, coefc);
if (_aux > distmaxsus || fabs(distmaxsus - _aux) <= EPS)
{
distmaxsus = _aux;
sus = i;
}
}
for (i=3; i<=n2; ++i)
{
double d = Distanta_in_dreapta(1, 2, dist12, i, coefa, coefb, coefc);
if (d != -1.0 && (d > distmaxdreapta || fabs(d - distmaxdreapta) <= EPS))
{
distmaxdreapta = d;
dreapta = i;
}
}
for (i=3; i<=n2; ++i)
{
double d = Distanta_in_stanga(1, 2, dist12, i, coefa, coefb, coefc);
if (d != -1.0 && (d > distmaxstanga || fabs(d-distmaxstanga) <= EPS))
{
distmaxstanga = d;
stanga = i;
}
}
if (stanga == 1)
stanga = n / 2 + 1;
ans = min(ans, AreaDreptunghi(1, 2, dist12, sus, stanga, dreapta, coefa, coefb, coefc));
int lim = n / 2;
for (i=2; i<=lim; ++i)
{
/// fixez latura i, i+1
coefa = a[i].y - a[i+1].y;
coefb = a[i+1].x - a[i].x;
coefc = 1LL*a[i].x*a[i+1].y - 1LL*a[i].y*a[i+1].x;
dist12 = Dist(a[i], a[i+1]);
double d, dnow;
dnow = DistP_dr(a[sus], coefa, coefb, coefc);
d = DistP_dr(a[sus+1], coefa, coefb, coefc);
while (sus < n && d > dnow)
{
dnow = d;
++sus;
d = DistP_dr(a[sus+1], coefa, coefb, coefc);
}
///
if (dreapta == i)
++dreapta;
dnow = Distanta_in_dreapta(i, i+1, dist12, dreapta, coefa, coefb, coefc);
d = Distanta_in_dreapta(i, i+1, dist12, dreapta+1, coefa, coefb, coefc);
while (dreapta < n && d != -1.0 && d > dnow)
{
dnow = d;
++dreapta;
d = Distanta_in_dreapta(i, i+1, dist12, dreapta+1, coefa, coefb, coefc);
}
///
if (a[stanga].x == a[i+1].x && a[stanga].y == a[i+1].y )/// ciuriburi
++stanga;
dnow = Distanta_in_stanga(i, i+1, dist12, stanga, coefa, coefb, coefc);
while (stanga < n && dnow == -1.0)
{
++stanga;
dnow = Distanta_in_stanga(i, i+1, dist12, stanga, coefa, coefb, coefc);
}
d = Distanta_in_stanga(i, i+1, dist12, stanga+1, coefa, coefb, coefc);
while (stanga < n && d != -1.0 && d > dnow)
{
dnow = d;
++stanga;
d = Distanta_in_stanga(i, i+1, dist12, stanga+1, coefa, coefb, coefc);
}
ans = min(ans, AreaDreptunghi(i, i+1, dist12, sus, stanga, dreapta, coefa, coefb, coefc));
}
//cout<<ans;
}
void Write()
{
FILE *g = fopen ("rubarba.out", "w");
fprintf(g, "%.2lf\n", ans);
fclose(g);
}
int main()
{
Read();
Solve();
Write();
return 0;
}