#include <cstdio>
#include <cmath>
#include <algorithm>
using namespace std;
const double pi=5;
const int maxn=2005;
double dabs(double d ) { if ( d< 0 ) return -d; return d;}
struct T        /// PAZI NA MOGUCNOST DA TI VISE TACAKA BUDE NA JEDNOJ PRAVOJ
{
    double x, y;
};
T tacke[maxn];
int rasp[maxn];
double P( int i1, int i2 , int i3)
{
    double x1=tacke[i2].x-tacke[i1].x;
    double y1=tacke[i2].y-tacke[i1].y;
    double x2=tacke[i3].x-tacke[i1].x;
    double y2=tacke[i3].y-tacke[i1].y;
    return dabs(x1*y2-x2*y1)/2;
}
bool inconv[maxn];
int n;


inline int f( int br)
{
    if ( br==n ) return 0;
    else return br;

}
void init();
double solve();
int main()
{
  ///  freopen("input.txt","r",stdin);
    init();
    printf("%lf\n",solve());
    return 0;
}



int graham()
{
    inconv[0]=true;
    inconv[1]=true;
    int sz=2;
    int t;
    for ( int i=2;i<n;i++)
    {
        inconv[i]=true;
        sz++;
        t=i-1;

        while ( t!= 0 )
        {
            if ( !inconv[t] )
            {
                t--;
                continue;
            }
            int g=t-1;
            while ( !inconv[g] ) g--;
            double a,b,c;
            a=tacke[i].y-tacke[g].y;
            b=-tacke[i].x+tacke[g].x;
            c=-(a*tacke[i].x+b*tacke[i].y);
            if ( a*tacke[t].x+b*tacke[t].y+c < 0 )
            {
                inconv[t--]=false;
                sz--;
            }
            else break;
        }
    }
    return sz;
}

bool cmp( T t1, T t2)
{
    if ( dabs(t1.x)<1e-5 && dabs(t1.y)<1e-5 ) return true;
    if ( dabs(t2.x)<1e-5 && dabs(t2.y)<1e-5 ) return false;
    double ug1=atan(t1.y/t1.x);if ( t1.x < 0 ) ug1+=pi;
    double ug2=atan(t2.y/t2.x);if ( t2.x < 0 ) ug2+=pi;
    if ( dabs(ug1-ug2)<1e-5 ) return t1.x*t1.x+t1.y*t1.y < t2.x*t2.x+t2.y*t2.y;
    return ug1<ug2;
}

double resi_nekonv()
{
    int niz[3];
    int sz=0;
    for ( int i=0;i<n;i++)
    if ( inconv[i]) niz[sz++]=i;
    double povrsina_veca=P(niz[0],niz[1],niz[2]);
    double min=999999999999.0;

    for ( int i=0;i<n;i++)
        if ( !inconv[i] )
        {
            double t=P(i,niz[0],niz[1]);
            if ( t<min ) min=t;
            t=P(i,niz[0],niz[2]);
            if ( t<min ) min=t;
            t=P(i,niz[2],niz[1]);
            if ( t<min ) min=t;
        }

    return povrsina_veca-min;
}

void init()
{
    scanf("%d",&n);
    int u=0;
    for ( int i=0;i<n;i++)
    {
        scanf("%lf %lf",&tacke[i].x,&tacke[i].y);
        if ( tacke[i].y < tacke[u].y )
         u=i;
         else if ( dabs(tacke[i].y-tacke[u].y) < 1e-5  && tacke[i].x < tacke[u].x ) u=i;
    }
    for ( int i=0;i<n;i++)
    {
        tacke[i].x-=tacke[u].x; tacke[i].y-=tacke[u].y;
    }
    std::sort(tacke,tacke+n,cmp);
    tacke[n]=tacke[0];
}




double p1,p2;

double solve()
{
    int sz=graham();
    if (sz==3)
    {
        return resi_nekonv();
    }

    double min=9999999999999.0;
    int t=0;
    for ( int i=0;i<sz;i++)
    {
        while ( !inconv[t]) t++;
        tacke[i]=tacke[t++];
    }
    int i1,i2,i3,i4;
    n=sz;
    i1=0;
    while ( i1<n )
    {
        i2=i1+1;
        i3=i1+1;
        i4=i2+2;
        if ( i2==n ) i2=0;
        if ( i3==n ) i3=0;
        if ( i4==n ) i4=0;
        while ( f(i4)!=i1 )
        {
            i3++;
            if (i3==n ) i3=0;
            if ( i4==i3 ) i4++;
            if ( i4>=n ) i4-=n;
            if ( i4== i1 ) break;
            p1=P(i1,i2,i3);
            while ( f(i2+1)!=i3 )
            {
                if ( P(i1,f(i2+1),i3) > p1 )
                {
                    i2++;
                    if ( i2==n ) i2=0;
                    p1=P(i1,i2,i3);
                }
                else break;
            }
            p2=P(i1,i3,i4);
            while ( f(i4+1)!=i1 )
            {
                if ( P(i1,f(i4+1),i3) > p2 )
                {
                    i4++;
                    if ( i4==n ) i4=0;
                    p2=P(i1,i4,i3);
                }
                else break;
            }
            if ( p1+p2 < min ) min=p1+p2;

        }
        i1++;

    }


    return min;
}

