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 int MOD = (int)1e9 + 7;
const int MAXN = (int)303;
const int infint = (int)1e9 + 3;
const long long inf = (long long)1e12;
int x[MAXN], y[MAXN], n, triangle[MAXN][MAXN][MAXN], num[MAXN][MAXN];
bitset<MAXN> out[MAXN], in[MAXN];
struct pt {
  int x, y;
  pt(int a, int b) { x = a, y = b; }
};
bool cw(pt a, pt b, pt c) {
  return 1LL * a.x * (b.y - c.y) + 1LL * b.x * (c.y - a.y) +
             1LL * c.x * (a.y - b.y) <
         0;
}
bool ccw(pt a, pt b, pt c) {
  return 1LL * a.x * (b.y - c.y) + 1LL * b.x * (c.y - a.y) +
             1LL * c.x * (a.y - b.y) >
         0;
}
long long C5(int n) {
  return 1LL * n * (n - 1) * (n - 2) * (n - 3) * (n - 4) / 120;
}
long long C2(int n) { return 1LL * n * (n - 1) / 2; }
int below(int i, int j) { return x[i] == x[j] && y[i] < y[j]; }
int betweenBelow(int i, int j, int k) {
  if (x[i] < x[j]) {
    return x[i] < x[k] && x[k] < x[j] &&
           cw(pt(x[i], y[i]), pt(x[j], y[j]), pt(x[k], y[k]));
  } else {
    return x[j] < x[k] && x[k] < x[i] &&
           cw(pt(x[j], y[j]), pt(x[i], y[i]), pt(x[k], y[k]));
  }
}
int main() {
  ios::sync_with_stdio(false);
  cin.tie(0);
  cout.tie(0);
  cin >> n;
  for (int i = 0; i < n; i++) cin >> x[i] >> y[i];
  for (int i = 0; i < n; i++)
    for (int j = 0; j < n; j++)
      if (x[i] < x[j]) {
        for (int k = 0; k < n; k++)
          if (k != i && k != j) {
            if (below(k, i)) num[i][j]++;
            if (below(k, j)) num[i][j]++;
            if (betweenBelow(i, j, k)) num[i][j] += 2;
          }
        num[j][i] = -num[i][j];
      }
  for (int i = 0; i < n; i++)
    for (int j = i + 1; j < n; j++)
      for (int k = j + 1; k < n; k++) {
        int temp = abs(num[i][j] + num[j][k] + num[k][i]) / 2;
        temp -= betweenBelow(i, j, k);
        temp -= betweenBelow(j, k, i);
        temp -= betweenBelow(k, i, j);
        if (cw(pt(x[i], y[i]), pt(x[j], y[j]), pt(x[k], y[k])))
          triangle[i][j][k] = triangle[j][k][i] = triangle[k][i][j] = temp;
        else
          triangle[i][k][j] = triangle[k][j][i] = triangle[j][i][k] = temp;
      }
  long long ans = C5(n);
  long long cnt = 0;
  for (int i = 0; i < n; i++)
    for (int j = 0; j < n; j++)
      for (int k = 0; k < n; k++) cnt += C2(triangle[i][j][k]);
  ans -= cnt / 3;
  for (int i = 0; i < n; i++) {
    for (int j = 0; j < n; j++) out[j].reset(), in[j].reset();
    for (int j = 0; j < n; j++)
      for (int k = 0; k < n; k++)
        if (i != j && j != k && i != k &&
            cw(pt(x[j], y[j]), pt(x[k], y[k]), pt(x[i], y[i])))
          out[j][k] = 1, in[k][j] = 1;
    long long cnt = 0;
    for (int j = 0; j < n; j++)
      for (int k = 0; k < n; k++)
        if (i != j && j != k && i != k) {
          bitset<MAXN> intersection_1 = (out[j] & in[k]),
                       intersection_2 = (out[k] & in[j]);
          cnt += 1LL * intersection_1.count() * intersection_2.count();
        }
    cnt /= 4;
    for (int j = 0; j < n; j++)
      for (int k = 0; k < n; k++) {
        bitset<MAXN> intersection = (out[k] & in[j]);
        cnt -= 1LL * intersection.count() * triangle[j][k][i];
      }
    ans -= cnt;
  }
  cout << ans;
}
