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;
const long long dx[] = {0, 1, 0, -1};
const long long dy[] = {1, 0, -1, 0};
const long long inf = 2e9;
const long long mod = 998244353;
const long long N = 3e2 + 11;
const long long NMAX = 3e2 + 11;
const long long INF64 = 3e18 + 1;
const double eps = 1e-14;
const double PI = acos(-1);
struct point {
  long long x, y, i;
};
vector<point> P;
long long dp[N][N][10], ans, n;
bool is_clockwise(point a, point b, point c) {
  return ((a.y - b.y) * (c.x - b.x) - (a.x - b.x) * (c.y - b.y)) > 0;
}
long long sub_solve(point s, vector<point> &pts) {
  sort((pts).begin(), (pts).end(),
       [s](point l, point r) { return !is_clockwise(s, l, r); });
  long long m = (long long)((pts).size());
  memset(dp, 0, sizeof(dp));
  vector<point> L, R;
  long long cur_ans = 0;
  for (long long i = 0; i < m; i++) {
    L.clear();
    R.clear();
    auto q = pts[i];
    for (long long j = 0; j < m; j++) {
      if (i == j) continue;
      if (!is_clockwise(s, q, pts[j]))
        R.push_back(pts[j]);
      else
        L.push_back(pts[j]);
    }
    sort((L).begin(), (L).end(),
         [q](point l, point r) { return !is_clockwise(q, l, r); });
    sort((R).begin(), (R).end(),
         [q](point l, point r) { return !is_clockwise(q, l, r); });
    for (long long k = 3; k <= 5; k++) {
      long long l = 0;
      for (long long j = 0; j < (long long)((R).size()); j++) {
        if (k == 3) {
          dp[q.i][R[j].i][k] = 1;
          continue;
        }
        if (j > 0) dp[q.i][R[j].i][k] += dp[q.i][R[j - 1].i][k];
        while (l < (long long)((L).size()) && is_clockwise(R[j], q, L[l])) {
          dp[q.i][R[j].i][k] += dp[L[l].i][q.i][k - 1];
          l++;
        }
        if (k == 5) {
          cur_ans += dp[q.i][R[j].i][k];
        }
      }
    }
  }
  return cur_ans;
}
void solve() {
  cin >> n;
  for (long long i = 1, a, b; i <= n; i++) {
    cin >> a >> b;
    point A = {a, b, i};
    P.push_back(A);
  }
  sort((P).begin(), (P).end(), [](point l, point r) {
    if (l.y == r.y) {
      return l.x < r.x;
    }
    return l.y > r.y;
  });
  long long ans = 0;
  for (long long i = 0; i < n; i++) {
    if (i < n - 1 && P[i].y == P[i + 1].y) continue;
    vector<point> bef;
    for (long long j = 0; j < i; j++) bef.push_back(P[j]);
    ans += sub_solve(P[i], bef);
  }
  cout << ans << '\n';
}
int32_t main() {
  ios_base ::sync_with_stdio(0);
  cin.tie(0);
  cout.tie(0);
  cout << setprecision(20) << fixed;
  long long t = 1;
  while (t--) {
    solve();
  }
}
