Problem: Iahub has drawn a set of n points in the cartesian plane which he calls "special points". A quadrilateral is a simple polygon without self-intersections with four sides (also called edges) and four vertices (also called corners). Please note that a quadrilateral doesn't have to be convex. A special quadrilateral is one which has all four vertices in the set of special points. Given the set of special points, please calculate the maximal area of a special quadrilateral. 

Input

The first line contains integer n (4 ≤ n ≤ 300). Each of the next n lines contains two integers: xi, yi ( - 1000 ≤ xi, yi ≤ 1000) — the cartesian coordinates of ith special point. It is guaranteed that no three points are on the same line. It is guaranteed that no two points coincide. 

Output

Output a single real number — the maximal area of a special quadrilateral. The answer will be considered correct if its absolute or relative error does't exceed 10 - 9.

Examples

Input

5
0 0
0 4
4 0
4 4
2 3


Output

16.000000

Note

In the test example we can choose first 4 points to be the vertices of the quadrilateral. They form a square by side 4, so the area is 4·4 = 16.

Solution (in CPP):

Solution:
#include <bits/stdc++.h>
using namespace std;
struct Point {
  double x, y;
  int type;
  Point(double x = 0, double y = 0) : x(x), y(y) {}
  void read() { scanf("%lf%lf", &x, &y); }
};
inline Point operator+(const Point& A, const Point& B) {
  return Point(A.x + B.x, A.y + B.y);
}
inline Point operator-(const Point& A, const Point& B) {
  return Point(A.x - B.x, A.y - B.y);
}
inline Point operator*(const Point& A, const double& p) {
  return Point(A.x * p, A.y * p);
}
inline Point operator/(const Point& A, const double& p) {
  return Point(A.x / p, A.y / p);
}
inline bool operator<(const Point& a, const Point& b) {
  return a.x < b.x || (a.x == b.x && a.y < b.y);
}
const double eps = 1e-8;
inline int dcmp(const double x) {
  if (fabs(x) < eps)
    return 0;
  else
    return x < 0 ? -1 : 1;
}
inline bool operator==(const Point& a, const Point& b) {
  return dcmp(a.x - b.x) == 0 && dcmp(a.y - b.y) == 0;
}
inline double sqr(const double& x) { return x * x; }
inline double Dot(const Point& A, const Point& B) {
  return A.x * B.x + A.y * B.y;
}
inline double Length(const Point& A) { return sqrt(Dot(A, A)); }
inline double Angle(const Point& A, const Point& B) {
  return acos(Dot(A, B) / Length(A) / Length(B));
}
inline double Cross(const Point& A, const Point& B) {
  return A.x * B.y - A.y * B.x;
}
inline Point Rotate(const Point& A, const double rad) {
  return Point(A.x * cos(rad) - A.y * sin(rad),
               A.x * sin(rad) + A.y * cos(rad));
}
inline Point Normal(const Point& A) {
  double L = Length(A);
  if (dcmp(L) > 0)
    return Point(-A.y / L, A.x / L);
  else
    return Point(0, 0);
}
inline double dist(const Point& a, const Point& b) {
  return (a.x - b.x) * (a.x - b.x) + (a.x - b.x) * (a.y - b.y);
}
double Dis(const Point& a, const Point& b) {
  return sqrt((a.x - b.x) * (a.x - b.x) + (a.y - b.y) * (a.y - b.y));
}
inline bool GetLineIntersection(const Point& P, const Point& v, const Point& Q,
                                const Point& w, Point& I) {
  if (!Cross(v, w)) return false;
  Point u = P - Q;
  double t = Cross(w, u) / Cross(v, w);
  I = P + v * t;
  return true;
}
inline bool OnSegment(const Point& p, const Point& a1, const Point& a2) {
  return dcmp(Cross(a1 - p, a2 - p)) == 0 && dcmp(Dot(a1 - p, a2 - p)) < 0 ||
         (p == a1 || p == a2);
}
inline bool GetSegmentIntersection(const Point& a1, const Point& a2,
                                   const Point& b1, const Point& b2, Point& I) {
  if (!GetLineIntersection(a1, a2 - a1, b1, b2 - b1, I)) return false;
  if (OnSegment(I, a1, a2) && OnSegment(I, b1, b2)) return true;
  return false;
}
inline double DistanceToline(Point& P, Point& A, Point& B) {
  Point v1 = B - A, v2 = P - A;
  return fabs(Cross(v1, v2)) / Length(v1);
}
inline double DistanceToSegment(Point& P, Point& A, Point& B) {
  if (A == B) return Length(P - A);
  Point v1 = B - A, v2 = P - A, v3 = P - B;
  if (dcmp(Dot(v1, v2)) > 0)
    return Length(v2);
  else if (dcmp(Dot(v1, v3)) > 0)
    return Length(v3);
  else
    return fabs(Cross(v1, v2)) / Length(v1);
}
inline Point GetLineProjection(Point& P, Point& A, Point& B) {
  Point v = B - A;
  return A + v * (Dot(v, P - A) / Dot(v, v));
}
inline double PolygonArea(Point* p, int n) {
  double area = 0;
  for (int i = 1; i < n - 1; ++i) {
    area += (Cross(p[i] - p[0], p[i + 1] - p[0]));
  }
  return (area / 2);
}
int ConvexHull(Point* p, int& n, Point* ch) {
  sort(p, p + n);
  n = unique(p, p + n) - p;
  int m = 0;
  for (int i = 0; i < n; ++i) {
    while (m > 1 && Cross(ch[m - 1] - ch[m - 2], p[i] - ch[m - 2]) <= 0) m--;
    ch[m++] = p[i];
  }
  int k = m;
  for (int i = n - 2; i >= 0; --i) {
    while (m > k && Cross(ch[m - 1] - ch[m - 2], p[i] - ch[m - 2]) <= 0) m--;
    ch[m++] = p[i];
  }
  if (n > 1) m--;
  return m;
}
Point p[400], ch[400];
Point tri[5], par[6];
int nump = 0;
int n, m;
int main() {
  scanf("%d", &n);
  for (int i = 1; i <= n; i++) {
    scanf("%lf%lf", &p[i].x, &p[i].y);
  }
  double ans = -1;
  for (int i = 1; i <= n; i++)
    for (int j = i + 1; j <= n; j++) {
      int p1 = 0, p2 = 0;
      double maxx = -1, minn = 1;
      double s;
      tri[0] = p[i];
      tri[1] = p[j];
      for (int k = 1; k <= n; k++)
        if (i != k && j != k) {
          tri[2] = p[k];
          s = PolygonArea(tri, 3);
          if (s < 0) {
            if (s < minn) {
              minn = s;
              p2 = k;
            }
          } else {
            if (s > maxx) {
              maxx = s;
              p1 = k;
            }
          }
        }
      if (minn < 0 && maxx > 0) {
        s = maxx - minn;
        if (s - ans > 0.00000000001) ans = s;
      } else
        continue;
    }
  printf("%.9lf\n", ans);
  return 0;
}