#include <stdio.h>
#include <iostream>
#include <algorithm>
#include <vector>
#include <string>
#include <map>
#include <set>
#include <queue>
#include <stack>
using namespace std;
#define maxn 2005


FILE *fin=fopen("farmeri.in", "r");
FILE *fout=fopen("farmeri.out", "w");

int n,m;
double x[maxn], y[maxn];
double sol=0.00;
double dp[maxn][maxn][2];

struct dot{
    double x, y;
    dot(){};
    dot(double _x, double _y){
        x=_x; y=_y;
    }
    void fread(){
        fscanf(fin, "%lf%lf", &x, &y);
    }
    void read(){
        scanf("%lf%lf", &x, &y);
    }
    void pisi(){
        printf("(%.2lf,%.2lf)\n", x,y);
    }
    bool operator<(const dot& A) const{
        if (x==A.x) return y<A.y;
        return x<A.x;
    }
    bool operator==(const dot& A) const{
        return (x==A.x && y==A.y);
    }
    bool operator!=(const dot &A) const{
        return (x!=A.x || y!=A.y);
    }
} d[maxn], e[maxn], s1[maxn], s2[maxn];

void finput(){
    fscanf(fin, "%d", &n);
    for (int i=0; i<n; ++i){
        d[i].fread();
        e[i]=d[i];
    }
}
void input(){
    scanf("%d", &n);
    for (int i=0; i<n; ++i){
        d[i].read();
        e[i]=d[i];
    }
}

double vp(dot &A, dot &B, dot &C){
    return (A.x-B.x)*(C.y-B.y)-(A.y-B.y)*(C.x-B.x);
}

int get_convex(){
    int k=2;
    s1[1]=d[0]; s1[2]=d[1];
    for (int i=2; i<n; i++){
        k++;
        s1[k]=d[i];
        while (k>2 && vp(s1[k-2],s1[k-1],s1[k])>0){
            k--;
            s1[k]=s1[k+1];
        }
    }
    int k2=2;
    s2[1]=d[0]; s2[2]=d[1];
    for (int i=2; i<n; i++){
        k2++;
        s2[k2]=d[i];
        while (k2>2 && vp(s2[k2-2],s2[k2-1],s2[k2])<0){
            k2--;
            s2[k2]=s2[k2+1];
        }
    }
    int ss=0;
    for (int i=1; i<=k; i++){
        d[ss]=s1[i];
        ss++;
    }
    for (int i=k2-1; i>1; i--){
        d[ss]=s2[i];
        ss++;
    }

    return ss;
}

void solve(){
    sort(d,d+n);
    sort(e,e+n);

    m=get_convex();
    int k=0;
    for (int i=0; i<n; i++){
        bool found=false;
        for (int j=0; j<m; j++)
            if (e[i]==d[j]) found=true;
        if (!found){
         s1[k++]=e[i];
        }
    }

    for (int i=0; i<maxn; i++)
        for (int j=0; j<maxn; j++)
            dp[i][j][0]=dp[i][j][1]=-200000000000.00;

    double V;

    for (int i=0; i<m; i++){
        int j=(i==m-1)?0:i+1;
        for (int k=0; k<m; k++)
            if (i!=k && j!=k){
                V=vp(d[i], d[j], d[k]);
                if (V<0){
                    if (-V>dp[i][j][0]) dp[i][j][0]=-V;
                    if (-V>dp[j][k][0]) dp[j][k][0]=-V;
                    if (-V>dp[k][i][0]) dp[k][i][0]=-V;

                    if (-V>dp[j][i][1]) dp[j][i][1]=-V;
                    if (-V>dp[k][j][1]) dp[k][j][1]=-V;
                    if (-V>dp[i][k][1]) dp[i][k][1]=-V;
                } else if (V>0){
                    if (V>dp[i][j][0]) dp[i][j][0]=V;
                    if (V>dp[j][k][0]) dp[j][k][0]=V;
                    if (V>dp[k][i][0]) dp[k][i][0]=V;

                    if (V>dp[j][i][1]) dp[j][i][1]=V;
                    if (V>dp[k][j][1]) dp[k][j][1]=V;
                    if (V>dp[i][k][1]) dp[i][k][1]=V;
                }
            }
    }

    for (int i=0; i<n; i++)
        for (int j=i+1; j<n; j++)
            if (dp[i][j][0]+dp[i][j][1]>sol) sol=dp[i][j][0]+dp[i][j][1];
}

void foutput(){
    fprintf(fout, "%.3lf\n", sol/2.0);
}
void output(){
    printf("%.3lf\n", sol/2.0);
}


int main(){
    finput();
    solve();
    foutput();
    return 0;
}
