#include<bits/stdc++.h>
#define maxN 100005
#define eps 0.00001
using namespace std;

pair<int,int> v[maxN];
int n,st[maxN],vf,leftmost,rightmost,upmost;
double ans=0.0;
pair<int,int> pr[maxN];
inline double Determ(pair<int,int> a,pair<int,int> b,pair<int,int> c)
{
    double det=(c.first-a.first)*(b.second-a.second)-(b.first-a.first)*(c.second-a.second);
    return det;
}

inline double Dist(pair<int,int> a,pair<int,int> b)
{
    double d=(a.second-b.second)*(a.second-b.second)+(a.first-b.first)*(a.first-b.first);
    d=sqrt((double)d);
    return d;
}

inline bool Egal(double a,double b)
{
    if(fabs(a-b)<eps) return 1;
    return 0;
}
inline bool cmp(pair<int,int> a,pair<int,int> b)
{
    double det=Determ(v[1],a,b);
    if(!det) return Dist(v[1],a)<Dist(v[1],b);
    return det>0;
}

inline double arie(pair<int,int> a,pair<int,int> b,pair<int,int> c)
{
    double det;
    det=Determ(a,b,c);
    det=fabs(det);
    return 0.5*det;
}

inline void BuildConvexHull()
{
    int best=1;
    for(int i=2;i<=n;i++)
    {
        if(v[i].first<v[best].first || (v[i].first==v[best].first && v[i].second<v[best].second)) best=i;
    }
    swap(v[1],v[best]);
    st[++vf]=1;
    sort(v+2,v+n+1,cmp);
    st[++vf]=2;
    for(int i=3;i<=n;i++)
    {
        while(vf>=2 && Determ(v[st[vf-1]],v[st[vf]],v[i])<=0) vf--;
        st[++vf]=i;
    }
}

inline double Inaltime(pair<int,int> a,pair<int,int> b,pair<int,int> c)
{
    double s,d;
    s=arie(a,b,c);
    d=Dist(a,b);
    return (2*s)/d;
}

inline double angle(pair<int,int> a,pair<int,int> b,pair<int,int> c)
{
    double d1,d2,d3;
    d1=Dist(a,c);
    d2=Dist(a,b);
    d3=Dist(b,c);
    double ang=(d2*d2+d3*d3-d1*d1);
    ang=(ang)/(2.0*d2*d3);
   // double ang=(d2*d2+d3*d3-d1*d1)/(2.0*d2*d3);
    return ang;
}
inline double DistLine(pair<int,int> a,pair<int,int> b,pair<int,int> d,pair<int,int> c)
{
    if(a.second==b.second)
    {
        return abs(c.first-d.first);
    }
        else
    {
        double m,m1,n1,xM,yM;
        m=(1.0*(a.second-b.second))/(1.0*(a.first-b.first));
        m1=-1.0/m;
        n1=c.second-m1*c.first;
        xM=d.first;
        yM=d.second;

        double dist=fabs(m1*xM-yM+n1)/sqrt((double)1.0+m1*m1);

        return dist;
    }
}
inline void BruteForce()
{
    rightmost=2;
    leftmost=1;
    int st=vf,dr=2;
    while(v[dr+1].first>v[dr].first) rightmost=++dr;
    double best=0.0;
    int pos=0;
    for(int i=3;i<=vf;i++)
    {
        double s=arie(v[1],v[2],v[i]);
        if(s>best)
        {
            best=s;
            pos=i;
        }
    }
    upmost=pos;
    leftmost=n;
    double x=angle(v[n],v[1],v[2]);
   // cerr<<x<<'\n';
    if(angle(v[n],v[1],v[2])<-eps) leftmost=n;
        else leftmost=1;
    if(angle(v[3],v[2],v[1])<-eps) rightmost=3;
        else rightmost=2;
    double h=Inaltime(v[1],v[2],v[upmost]);
    double L=DistLine(v[1],v[2],v[leftmost],v[rightmost]);
    ans=h*L;
}
int main()
{
    freopen("rubarba.in","r",stdin);
    freopen("rubarba.out","w",stdout);
    scanf("%d",&n);
    if(n<=2)
    {
        printf("0\n");
        return 0;
    }
    for(int i=1;i<=n;i++)
    {
        scanf("%d%d",&v[i].first,&v[i].second);
    }

    BuildConvexHull();
    for(int i=1;i<=vf;i++)
    {
        pr[i]=v[st[i]];
    }
    for(int i=1;i<=n;i++)
    {
        v[i]=pr[i];
    }
    n=vf;
    BruteForce();

    for(int i=2;i<=vf;i++)
    {
        int l,r;
        l=i;
        r=(i+1);
        if(r>vf) r=1;
        while(arie(v[l],v[r],v[(upmost+1)-n*(upmost==n)])>arie(v[l],v[r],v[upmost])) upmost=upmost+1-n*(upmost==n);
        leftmost=i-1;
        if(angle(v[leftmost],v[l],v[r])<-eps) leftmost=i-1;
            else leftmost=i;
        rightmost=r+1;
        if(rightmost>n) rightmost=1;
        if(angle(v[l],v[r],v[rightmost])<-eps) rightmost=rightmost;
            else rightmost=r;
        double h=Inaltime(v[l],v[r],v[upmost]);
        double L=DistLine(v[l],v[r],v[leftmost],v[rightmost]);
        ans=min(ans,h*L);
    }

    printf("%.2f\n",ans);

    return 0;
}