You are given a set of n points in a 2D plane. No three points are collinear.

A pentagram is a set of 5 points A,B,C,D,E that can be arranged as follows. <image> Note the length of the line segments don't matter, only that those particular intersections exist.

Count the number of ways to choose 5 points from the given set that form a pentagram.

Input

The first line contains an integer n (5 ≤ n ≤ 300) — the number of points.

Each of the next n lines contains two integers x_i, y_i (-10^6 ≤ x_i,y_i ≤ 10^6) — the coordinates of the i-th point. It is guaranteed that no three points are collinear.

Output

Print a single integer, the number of sets of 5 points that form a pentagram.

Examples

Input


5
0 0
0 2
2 0
2 2
1 3


Output


1


Input


5
0 0
4 0
0 4
4 4
2 3


Output


0


Input


10
841746 527518
595261 331297
-946901 129987
670374 -140388
-684770 309555
-302589 415564
-387435 613331
-624940 -95922
945847 -199224
24636 -565799


Output


85

Note

A picture of the first sample: <image> A picture of the second sample: <image> A picture of the third sample: <image>
#include <bits/stdc++.h>
using namespace std;
template <typename T>
void maxtt(T& t1, T t2) {
  t1 = max(t1, t2);
}
template <typename T>
void mintt(T& t1, T t2) {
  t1 = min(t1, t2);
}
bool debug = 0;
int n, m, k;
int dx[4] = {0, 1, 0, -1}, dy[4] = {1, 0, -1, 0};
string direc = "URDL";
long long ln, lk, lm;
void etp(bool f = 0) {
  puts(f ? "YES" : "NO");
  exit(0);
}
void addmod(int& x, int y, int mod = 998244353) {
  assert(y >= 0);
  x += y;
  if (x >= mod) x -= mod;
  assert(x >= 0 && x < mod);
}
void et(int x = -1) {
  printf("%d\n", x);
  exit(0);
}
long long fastPow(long long x, long long y, int mod = 998244353) {
  long long ans = 1;
  while (y > 0) {
    if (y & 1) ans = (x * ans) % mod;
    x = x * x % mod;
    y >>= 1;
  }
  return ans;
}
long long gcd1(long long x, long long y) { return y ? gcd1(y, x % y) : x; }
struct Point {
  long long x, y;
  Point() {}
  Point(long long x, long long y) : x(x), y(y) {}
  long double abs() const { return hypot(x, y); }
  long double arg() const { return atan2(y, x); }
  Point operator*(double o) const { return Point(x * o, y * o); }
  Point operator+(const Point& o) const { return Point(x + o.x, y + o.y); }
  Point operator-(const Point& o) const { return Point(x - o.x, y - o.y); }
  Point operator/(double o) const { return Point(x / o, y / o); }
  bool operator<(const Point& o) const {
    return y < o.y || (y == o.y && x < o.x);
  }
  Point scale(double o) const { return *this * (o / abs()); }
  Point rotY() const { return Point(-y, x); }
  Point rotX() const { return Point(y, -x); }
  long long cross(Point b) const { return x * b.y - b.x * y; }
  long long dot(Point b) const { return x * b.x + y * b.y; }
  long double disToSeg(Point& a, Point& b) {
    return fabs(((*this) - a).cross(b - a) / (b - a).abs());
  }
  void readin() { scanf("%lld%lld", &x, &y); }
} p[335], vp[335];
int N;
bool cmp(Point& a, Point& b) { return a.cross(b) < 0; }
long long dp[5][335][335], ans;
void cal() {
  if (N < 4) return;
  sort(vp + 1, vp + 1 + N, cmp);
  for (int(i) = 1; (i) <= (int)(4); (i)++)
    for (int(j) = 0; (j) < (int)(N + 3); (j)++)
      for (int(z) = 0; (z) < (int)(N + 3); (z)++) dp[i][j][z] = 0;
  for (int(i) = 0; (i) < (int)(N); (i)++) dp[1][0][i + 1] = 1;
  for (int num = 1; num < 4; num++) {
    for (int i = 0; i < N; i++) {
      for (int j = i + 1; j < N; j++)
        if (dp[num][i][j]) {
          for (int z = j + 1; z <= N; z++) {
            if ((vp[j] - vp[i]).cross(vp[z] - vp[i]) < 0) {
              dp[num + 1][j][z] += dp[num][i][j];
            }
          }
        }
    }
  }
  Point C = Point(0, 0);
  for (int(i) = 1; (i) <= (int)(N); (i)++)
    for (int j = i + 1; j <= N; j++) {
      if ((vp[j] - vp[i]).cross(C - vp[i]) < 0) {
        ans += dp[4][i][j];
      }
    }
}
void fmain(int tid) {
  scanf("%d", &n);
  for (int(i) = 1; (i) <= (int)(n); (i)++) p[i].readin();
  sort(p + 1, p + 1 + n);
  for (int(i) = 1; (i) <= (int)(n); (i)++) {
    N = 0;
    for (int j = i + 1; j <= n; j++) {
      vp[++N] = (p[j] - p[i]);
    }
    cal();
  }
  printf("%lld\n", ans);
}
int main() {
  int t = 1;
  for (int(i) = 1; (i) <= (int)(t); (i)++) {
    fmain(i);
  }
  return 0;
}
