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;
namespace fastIO {
bool IOerror = 0;
inline bool blank(char ch) {
  return ch == ' ' || ch == '\n' || ch == '\r' || ch == '\t';
}
inline long long read() {
  bool sign = 0;
  char ch = getchar();
  long long x = 0;
  for (; blank(ch); ch = getchar())
    ;
  if (IOerror) return 0;
  if (ch == '-') sign = 1, ch = getchar();
  for (; ch >= '0' && ch <= '9'; ch = getchar()) x = x * 10 + ch - '0';
  if (sign) x = -x;
  return x;
}
};  // namespace fastIO
using namespace fastIO;
int x[1000010], y[1000010];
struct node {
  int dy, dx;
};
vector<node> v1[1000010], v2[1000010];
inline bool cmp(node a, node b) {
  if (a.dy == 0) {
    if (a.dx >= 0) return b.dy > 0;
    return !(b.dy == 0 && b.dx < 0);
  }
  if (b.dy == 0) return (b.dx >= 0) * (a.dy < 0);
  if (a.dy > 0) return (b.dy > 0) * (1ll * a.dx * b.dy > 1ll * b.dx * a.dy);
  if (b.dy > 0) return 1;
  return 1ll * a.dx * b.dy > 1ll * b.dx * a.dy;
}
struct node2 {
  node x;
  int id;
};
vector<node2> b;
vector<int> v[1000010];
bool cmp2(node2 a, node2 b) { return cmp(a.x, b.x); }
signed main() {
  int n = read();
  long long ans = 0;
  for (int i = 1; i <= n; i++) x[i] = read(), y[i] = read();
  for (int i = 1; i <= n; i++) {
    b.clear();
    for (int j = 1; j <= n; j++) {
      if (i != j) b.push_back((node2){(node){y[j] - y[i], x[j] - x[i]}, j});
    }
    sort(b.begin(), b.end(), cmp2);
    for (auto j : b) v[i].push_back(j.id);
  }
  for (int i = 1; i <= n; i++) {
    for (int j = 1; j <= n; j++) {
      for (int k = 1; k <= n; k++) {
        if (i == j || j == k || i == k) continue;
        node d1 = (node){y[j] - y[i], x[j] - x[i]},
             d2 = (node){y[k] - y[j], x[k] - x[j]};
        if (cmp(d1, d2)) v1[k].push_back(d2);
        d1 = (node){y[i] - y[j], x[i] - x[j]},
        d2 = (node){y[j] - y[k], x[j] - x[k]};
        if (cmp(d2, d1)) v2[k].push_back(d2);
      }
    }
    for (int j = 1; j <= n; j++)
      sort(v1[j].begin(), v1[j].end(), cmp),
          sort(v2[j].begin(), v2[j].end(), cmp);
    for (int j = 1; j <= n; j++) {
      int num = 0;
      for (auto k : v[j]) {
        if (i == j || i == k) continue;
        node d = (node){y[k] - y[j], x[k] - x[j]};
        while (num < v1[j].size() && cmp(v1[j][num], d)) num++;
        ans += 1ll * num *
               (v2[k].end() - upper_bound(v2[k].begin(), v2[k].end(), d, cmp));
      }
    }
    for (int j = 1; j <= n; j++) v1[j].clear(), v2[j].clear();
  }
  cout << ans;
  return 0;
}
