#include <stdio.h>
#include <vector>
#include <algorithm>
#include <math.h>
using namespace std;

#define pb push_back
#define EPS 1E-10
#define MAXN 2000
#define INF 40000000100.0

struct Point {
   double x, y;
};

bool _less(double a, double b) {
   if(a < b - EPS) return true; return false;
}

bool _gre(double a, double b) {
   if(a > b + EPS) return true; return false;
}

bool _eq(double a, double b) {
   if(a + EPS > b && a - EPS < b) return true; return false;
}

bool _conv(Point p1, Point p2, Point p3) {
   if(_gre((p3.y - p2.y)*(p2.x - p1.x), (p2.y - p1.y) * (p3.x - p2.x))) return true; return false;
}

bool _col(Point p1, Point p2, Point p3) {
   if(_eq((p3.y - p2.y)*(p2.x - p1.x), (p2.y - p1.y) * (p3.x - p2.x))) return true; return false;
}

Point compP;

double _abs(double x) {
   if(x < 0) return -x; return x;
}

double _intensity(Point p1, Point p2) {
   return sqrt((p1.x - p2.x)* (p1.x - p2.x) + (p1.y - p2.y) * (p1.y - p2.y));
}

bool cmpPoint (Point p1, Point p2) {
   if(_col(compP, p1, p2)) return _intensity(p1, compP) < _intensity(p2, compP);
   return _gre((p2.y - compP.y)*(p1.x - compP.x), (p1.y - compP.y) * (p2.x - compP.x));
}

vector<Point> ConvexHull(Point * p, int n) {
   vector<Point> conv;

   for(int i = 1; i < n; i ++) {
      if(_gre(p[0].x, p[i].x) || (_eq(p[0].x, p[i].x) && _gre(p[0].y, p[i].y))) {
         Point tmp = p[i];
         p[i] = p[0];
         p[0] = tmp;
      }
   }

   compP = p[0];

   sort(p + 1, p + n, cmpPoint);

   conv.pb(p[0]);
   conv.pb(p[1]);

   int i = n - 2;

   while(i > 0 && _col(p[0], p[i+1], p[i])) i--;

   if(i == 0) return conv;

   for(int k = 2; k < n; k++) {
      while(conv.size() >= 2 && !_conv(conv[conv.size() - 2], conv[conv.size() - 1], p[k])) conv.pop_back();
      conv.pb(p[k]);
   }

   return conv;
}

int n;
Point * p;

void Input() {
   FILE *fin = fopen("farmeri.in", "r");
   fscanf(fin, "%d", &n);
   p = new Point[n];
   for(int i = 0; i < n; i++) fscanf(fin, "%lf%lf", &p[i].x, &p[i].y);
}

int index[MAXN + 50][MAXN + 50];
double maxA[MAXN + 50][MAXN + 50];

double _area(Point p1, Point p2, Point p3) {
   return _abs((p1.x - p2.x) * (p3.y - p2.y) - (p1.y - p2.y) * (p3.x - p2.x)) / 2;
}

bool _eqP(Point p1, Point p2) {
   if(_eq(p1.x, p2.x) && _eq(p1.y, p2.y)) return true;
   return false;
}

double Solve() {
   vector<Point> conv = ConvexHull(p, n);
   //for(int i = 0; i < conv.size(); i++) printf("%.2lf %.2lf\n", conv[i].x, conv[i].y);

   if(conv.size() == 2) return 0;

   if(conv.size() == 3) {
      double A = _area(conv[0], conv[1], conv[2]);
      double sol = INF;

      for(int i = 0; i < n; i++) if(!_eqP(conv[0], p[i]) && !_eqP(conv[1], p[i]) && !_eqP(conv[2], p[i])) {
         double S = _area(conv[0], p[i], conv[2]);
         if(S < sol) sol = S;

         S = _area(conv[0], p[i], conv[1]);
         if(S < sol) sol = S;

         S = _area(conv[1], p[i], conv[2]);
         if(S < sol) sol = S;
      }

      return A - sol;
   }

   n = conv.size();

   for(int d = 2; d <= n - 2; d++) {
      for(int i = 0; i < n; i++) {
         if(d == 2) {
            index[i][(i + 2) % n] = (i+1)%n;
            maxA[i][(i + 2) % n] = _area(conv[i], conv[(i+1)%n], conv[(i+2)%n]);
         } else {
            index[i][(i + d) % n] = index[i][(i+d - 1)%n];
            maxA[i][(i + d) % n] = _area(conv[i], conv[index[i][(i+d - 1)%n]], conv[(i+d)%n]);
            double A2 = _area(conv[i], conv[index[i+1][(i+d)%n]], conv[(i+d)%n]);

            if(_less(maxA[i][(i + d) % n], A2)) {
               maxA[i][(i + d) % n] = A2;
               index[i][(i + d) % n] = index[i+1][(i+d)%n];
            }

            for(int k = index[i][(i+d - 1)%n]; k != index[i+1][(i+d)%n]; k = (k + 1) % n) {
               double currA = _area(conv[i], conv[k], conv[(i+d)%n]);
               if(_gre(currA, maxA[i][(i + d) % n])) {
                  maxA[i][(i + d) % n] = currA;
                  index[i][(i+d)%n] = k;
               }
            }
         }
      }
   }

   double sol = -INF;

   for(int i = 0; i < n; i++) {
      for(int j = 0; j < n; j++) if(i != j && (i+ 1) % n != j && i != (j + 1) % n) {
         if(_less(sol, maxA[i][j] + maxA[j][i])) sol = maxA[i][j] + maxA[j][i];

         //printf("%d [%.0lf %.0lf] %d [%.0lf %.0lf]: %d %.3lf\n", i, conv[i].x, conv[i].y, j, conv[j].x, conv[j].y, index[i][j], maxA[i][j]);
         //printf("%d [%.0lf %.0lf] %d [%.0lf %.0lf]: %d %.3lf\n", i, conv[i].x, conv[i].y, j, conv[j].x, conv[j].y, index[i][j], maxA[i][j]);
      }
   }

   return sol;
}

void Output() {
   FILE * fout = fopen("farmeri.out", "w");
   fprintf(fout, "%.3lf\n", Solve());
}

int main() {
   Input();
   Output();
}
