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 <class T>
inline void cmin(T &a, T b) {
  ((a > b) && (a = b));
}
template <class T>
inline void cmax(T &a, T b) {
  ((a < b) && (a = b));
}
char IO;
template <class T = int>
T rd() {
  T s = 0;
  int f = 0;
  while (!isdigit(IO = getchar())) f |= IO == '-';
  do s = (s << 1) + (s << 3) + (IO ^ '0');
  while (isdigit(IO = getchar()));
  return f ? -s : s;
}
const int N = 310, INF = 1e9 + 10;
const double theta = 114514, eps = 1e-7;
int n, m;
struct Node {
  double x, y;
  Node() {}
  Node(double x, double y) : x(x), y(y) {}
  Node operator-(const Node _) const { return Node(x - _.x, y - _.y); }
  double operator^(const Node _) const { return x * _.y - y * _.x; }
  bool operator<(const Node __) const { return x < __.x; }
  double ang() { return atan2(y, x); }
  void turn() {
    double a = x * cos(theta) - y * sin(theta);
    double b = x * sin(theta) + y * cos(theta);
    x = a, y = b;
  }
} A[N];
long long dp1[N][4], dp2[N][4];
int I[N][N], J[N][N];
void Solve(long long F[N][4], int x) {
  static long long dp[N][N][4];
  memset(dp, 0, sizeof dp);
  for (int i = x + 1, iend = n; i <= iend; ++i) dp[x][i][0] = 1;
  for (int i = x + 1, iend = n; i <= iend; ++i) {
    for (int a = x, aend = i - 1; a <= aend; ++a)
      for (int b = i + 1, bend = n; b <= bend; ++b)
        if (((A[a] - A[i]) ^ (A[b] - A[i])) >= 0)
          for (int d = 0, dend = 2; d <= dend; ++d)
            dp[i][b][d + 1] += dp[a][i][d];
  }
  for (int i = x, iend = n; i <= iend; ++i)
    for (int j = i + 1, jend = n; j <= jend; ++j)
      for (int k = 0, kend = 3; k <= kend; ++k) F[j][k] += dp[i][j][k];
}
int main() {
  n = rd();
  for (int i = 1, iend = n; i <= iend; ++i) A[i].x = rd(), A[i].y = rd();
  for (int i = 1, iend = n; i <= iend; ++i) A[i].turn();
  sort(A + 1, A + n + 1);
  for (int i = 1, iend = n; i <= iend; ++i) {
    for (int j = 1, jend = i - 1; j <= jend; ++j) I[i][j] = j;
    for (int j = i + 1, jend = n; j <= jend; ++j) I[i][j - 1] = j;
    sort(I[i] + 1, I[i] + n, [&](int x, int y) {
      return (A[x] - A[i]).ang() < (A[y] - A[i]).ang();
    });
    for (int j = 1, jend = n - 1; j <= jend; ++j) J[i][I[i][j]] = j;
  }
  long long ans = 0;
  for (int i = 1, iend = n; i <= iend; ++i) {
    memset(dp1, 0, sizeof dp1), memset(dp2, 0, sizeof dp2);
    Solve(dp1, i);
    for (int j = 1, jend = n; j <= jend; ++j) A[j].x *= -1;
    Solve(dp2, i);
    for (int j = i + 1, jend = n; j <= jend; ++j)
      for (int k = 0, kend = 3; k <= kend; ++k)
        ans += dp1[j][k] * dp2[j][3 - k];
  }
  printf("%lld\n", ans);
}
