#include <cstdio>
#include <iostream>
#include <sstream>
#include <fstream>
#include <iomanip>
#include <algorithm>
#include <cmath>
#include <string>
#include <vector>
#include <list>
#include <queue>
#include <stack>
#include <set>
#include <map>
#include <bitset>
#include <numeric>
#include <climits>
#include <cfloat>
using namespace std;

class Point
{
public:
    int y, x;
    Point(){
        y = x = 0;
    }
    Point(int y0, int x0){
        y = y0;
        x = x0;
    }
    Point operator+(const Point& p) const{
        return Point(y + p.y, x + p.x);
    }
    Point operator-(const Point& p) const{
        return Point(y - p.y, x - p.x);
    }
    Point operator*(int a) const{
        return Point(y * a, x * a);
    }
    long long cross(const Point& p) const{
        return (long long)x * p.y - (long long)y * p.x; // |a|*|b|*sin慮
    }
    bool operator==(const Point& p) const{
        return x == p.x && y == p.y;
    }
    bool operator<(const Point& p) const{
        return x < p.x || (x == p.x && y < p.y);
    }
};

long long polygonArea(const vector<Point>& p)
{
    int n = p.size();
    long long ret = 0;
    for(int i=0; i<n; ++i)
        ret += p[i].cross(p[(i+1)%n]);
    return abs(ret);
}

void convexHull(const vector<Point>& p0, vector<Point>& cv)
{
    vector<Point> p = p0;
    sort(p.begin(), p.end());
    int n = p.size();

    int j = 0;
    cv.clear();
    for(int i=0; i<2*n-1; ++i){
        Point tmp = (i<n? p[i]:p[2*(n-1)-i]);
        while(j >= 2 && (tmp-cv[j-2]).cross(cv[j-1]-cv[j-2]) < 0){
            cv.pop_back();
            -- j;
        }
        cv.push_back(tmp);
        ++ j;
    }
    cv.pop_back();
}

long long solve(vector<Point>& p, int left, int right)
{
    int n = p.size();

    int l = 1;
    int r = (right - left + n) % n - 1;

    vector<Point> p2(3);
    p2[0] = p[left];
    p2[1] = p[right];

    while(l < r){
        int m1 = (l*2 + r) / 3;
        int m2 = (l + r*2 + 1) / 3;

        p2[2] = p[(left + m1) % n];
        long long s1 = polygonArea(p2);
        p2[2] = p[(left + m2) % n];
        long long s2 = polygonArea(p2);

        if(s1 < s2)
            l = m1 + 1;
        else
            r = m2 - 1;
    }

    p2[2] = p[(left + l) % n];
    return polygonArea(p2);
}

int main()
{
    int n;
    cin >> n;
    vector<Point> p(n);
    for(int i=0; i<n; ++i)
        cin >> p[i].x >> p[i].y;

    vector<Point> cv;
    convexHull(p, cv);
    int m = cv.size();

    long long ret = 0;

    if(m == 3){
        for(int i=0; i<n; ++i){
            if(find(cv.begin(), cv.end(), p[i]) != cv.end())
                continue;
            for(int j=0; j<3; ++j){
                vector<Point> p2 = cv;
                p2.insert(p2.begin()+j, p[i]);
                ret = max(ret, polygonArea(p2));
            }
        }
    }else{
        for(int i=0; i<m; ++i){
            for(int j=i+2; j<m; ++j){
                if(i == 0 && j == m-1)
                    continue;
                ret = max(ret, solve(cv, i, j) + solve(cv, j, i));
            }
        }
    }

    cout << (ret / 2) << '.';
    if(ret % 2 == 0)
        cout << '0' << endl;
    else
        cout << '5' << endl;

    return 0;
}

Measured memory_bytes: 1248