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;
const int N = 100010;
long long mod = 1e9 + 7;
long long fmod(long long b, long long exp) {
  long long res = 1;
  while (exp) {
    if (exp & 1ll) res = (res * b) % mod;
    b = (b * b) % mod;
    exp /= 2ll;
  }
  return res;
}
struct Point {
  long long x, y;
  Point() {}
  Point(const long long& x, const long long& y) : x(x), y(y) {}
  void swap(Point& other) {
    using std::swap;
    swap(x, other.x);
    swap(y, other.y);
  }
  Point& operator=(const Point& other) {
    x = other.x;
    y = other.y;
    return *this;
  }
  Point& operator+=(const Point& other) {
    x += other.x;
    y += other.y;
    return *this;
  }
  Point& operator-=(const Point& other) {
    x -= other.x;
    y -= other.y;
    return *this;
  }
  Point& operator*=(const long long& factor) {
    x *= factor;
    y *= factor;
    return *this;
  }
  Point& operator/=(const long long& factor) {
    x /= factor;
    y /= factor;
    return *this;
  }
  long long dist(const Point& b) { return hypot(x - b.x, y - b.y); }
  bool operator==(const Point& b) const { return (x == b.x) && (y == b.y); }
  bool operator<(const Point& b) const {
    return (x == b.x) ? (y < b.y) : (x < b.x);
  }
};
inline Point makePoint(const long long& x, const long long& y) {
  return Point(x, y);
}
inline Point operator+(const Point& a, const Point& b) {
  return makePoint(a.x + b.x, a.y + b.y);
}
inline Point operator-(const Point& a, const Point& b) {
  return makePoint(a.x - b.x, a.y - b.y);
}
inline long long operator^(const Point& a, const Point& b) {
  return (a.x * b.y) - (a.y * b.x);
}
inline long long operator*(const Point& a, const Point& b) {
  return (a.x * b.x) + (a.y * b.y);
}
istream& operator>>(istream& is, Point& point) {
  return is >> point.x >> point.y;
}
ostream& operator<<(ostream& os, const Point& point) {
  return os << point.x << ' ' << point.y;
}
void swap(Point& lhs, Point& rhs) { lhs.swap(rhs); }
inline int pre(int i, int n) { return i == 0 ? n - 1 : i - 1; }
inline int nex(int i, int n) { return i == n - 1 ? 0 : i + 1; }
struct Line {
  Point x, d;
  Line(){};
  Line(const Point& _x, const Point& _y) : x(_x), d(_y - _x) {}
  bool onLine(const Point& p) {
    if (p == x) return true;
    return (((p - x) ^ d) == 0);
  }
  long long area(const Point& p) { return ((p - x) ^ d); }
};
Point pts[N];
int main() {
  ios_base::sync_with_stdio(false);
  cin.tie(NULL);
  int t = 1, n, i, j, k = 0;
  cin >> n;
  for (i = 0; i < n; i++) cin >> pts[i];
  long long mx = 0;
  Line a;
  for (i = 0; i < n; i++) {
    for (int j = i + 1; j < n; j++) {
      a = Line(pts[i], pts[j]);
      long long lft1 = 0, rt1 = 0;
      for (k = 0; k < n; k++)
        if (k != j && k != i) {
          long long cur = a.area(pts[k]);
          if (cur < 0)
            lft1 = max(lft1, -cur);
          else
            rt1 = max(rt1, cur);
        }
      if (lft1 && rt1) mx = max(mx, lft1 + rt1);
    }
  }
  cout << fixed << setprecision(7) << ((long double)mx) / 2 << "\n";
  return 0;
}