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;
using pii = pair<int, int>;
using LL = long long;
const int NN = 300;
bitset<NN> bit[NN][NN];
pii p[NN];
istream& operator>>(istream& in, pii& a) {
  in >> a.first >> a.second;
  return in;
}
void operator<<(ostream& out, pii& a) { out << a.first << ' ' << a.second; }
pii operator-(const pii& a, const pii& b) {
  return {a.first - b.first, a.second - b.second};
}
LL operator^(const pii& a, const pii& b) {
  return (LL)a.first * b.second - (LL)a.second * b.first;
}
int main() {
  int n;
  cin >> n;
  for (int i = 0; i < n; i++) {
    cin >> p[i];
    for (int j = 0; j < n; j++) bit[i][j].reset();
  }
  for (int i = 0; i < n; i++) {
    for (int j = i + 1; j < n; j++) {
      for (int k = 0; k < n; k++) {
        if (k == i || k == j) continue;
        if ((p[k] - p[j] ^ p[i] - p[j]) > 0)
          bit[i][j].set(k);
        else
          bit[j][i].set(k);
      }
    }
  }
  LL s1 = 0, s2 = 0;
  for (int I = 0; I < n; I++) {
    for (int J = I + 1; J < n; J++) {
      for (int K = J + 1; K < n; K++) {
        int i = I, j = J, k = K;
        if ((p[k] - p[j] ^ p[i] - p[j]) < 0) swap(k, j);
        int t = (bit[i][j] & bit[j][k] & bit[k][i]).count(), t1;
        s1 += t * (t - 1) / 2;
        t1 = (bit[i][j] & bit[j][k]).count();
        s2 += t * (t1 - t);
        t1 = (bit[j][k] & bit[k][i]).count();
        s2 += t * (t1 - t);
        t1 = (bit[k][i] & bit[i][j]).count();
        s2 += t * (t1 - t);
      }
    }
  }
  cout << ((LL)n * (n - 1) * (n - 2) * (n - 3) * (n - 4) / 120 - s1 - s2 / 2)
       << endl;
  return 0;
}
