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;
int gcd(int a, int b) { return b == 0 ? a : gcd(b, a % b); }
const int MAXN = 300;
struct P {
  int x, y;
  P() {}
  P(int x, int y) : x(x), y(y) {}
};
P operator-(const P &a, const P &b) { return P(a.x - b.x, a.y - b.y); }
long long operator^(const P &a, const P &b) {
  return (long long)a.x * b.y - (long long)a.y * b.x;
}
bool operator<(const P &a, const P &b) {
  bool apos = a.y > 0 || a.y == 0 && a.x > 0;
  bool bpos = b.y > 0 || b.y == 0 && b.x > 0;
  if (apos != bpos) return apos;
  return (a ^ b) > 0;
}
int n;
P p[MAXN];
int byrot[MAXN][MAXN - 1];
int invbyrot[MAXN][MAXN];
pair<P, int> o[MAXN];
int cntinside[MAXN][MAXN][MAXN];
int cntbefore[MAXN][MAXN][MAXN];
int side(const P &a, const P &b, const P &c) {
  long long res = (b - a) ^ (c - a);
  return res < 0 ? -1 : res > 0 ? +1 : 0;
}
int side(int a, int b, int c) { return side(p[a], p[b], p[c]); }
int bit[MAXN + 1];
int bget(int idx) {
  ++idx;
  int ret = 0;
  while (idx > 0) {
    ret += bit[idx];
    idx -= idx & -idx;
  }
  return ret;
}
void bmod(int idx, int by) {
  ++idx;
  while (idx <= n) {
    bit[idx] += by;
    idx += idx & -idx;
  }
}
long long solve() {
  for (int a = (0); a < (n); ++a) {
    int cnt = 0;
    for (int b = (0); b < (n); ++b)
      if (b != a) o[cnt++] = make_pair(p[b] - p[a], b);
    sort(o, o + cnt);
    for (int i = (0); i < (cnt); ++i) byrot[a][i] = o[i].second;
  }
  for (int a = (0); a < (n); ++a)
    for (int b = (0); b < (n); ++b)
      for (int c = (0); c < (n); ++c)
        cntinside[a][b][c] = cntbefore[a][b][c] = 0;
  for (int a = (0); a < (n); ++a)
    for (int b = (0); b < (n); ++b) invbyrot[a][b] = -1;
  for (int a = (0); a < (n); ++a)
    for (int i = (0); i < (n - 1); ++i) invbyrot[a][byrot[a][i]] = i;
  for (int a = (0); a < (n); ++a)
    for (int b = (0); b < (n); ++b)
      if (b != a) {
        int bidx = invbyrot[a][b];
        assert(bidx != -1);
        int aidx = invbyrot[b][a];
        assert(aidx != -1);
        int tot = 0;
        for (int i = (0); i <= (n); ++i) bit[i] = 0;
        for (int i = (1); i < (n - 1); ++i) {
          int c = byrot[a][(bidx + i) % (n - 1)];
          if (side(a, b, c) != -1) continue;
          int idx = invbyrot[b][c];
          assert(idx != -1 && idx < n - 1);
          idx -= aidx;
          if (idx < 0) idx += n - 1;
          int cur = bget(idx);
          cntinside[a][b][c] = tot - cur;
          cntbefore[a][b][c] = cur;
          ++tot;
          bmod(idx, 1);
        }
      }
  long long ret = 0;
  for (int c = (0); c < (n); ++c)
    for (int d = (0); d < (n); ++d)
      if (d != c) {
        int cnta = 0;
        for (int a = (0); a < (n); ++a)
          if (side(c, d, a) == +1) ++cnta;
        long long cur = 0;
        for (int b = (0); b < (n); ++b)
          cur += (long long)cnta * cntbefore[c][d][b];
        for (int e = (0); e < (n); ++e)
          cur += (long long)cnta * cntbefore[e][c][d];
        for (int b = (0); b < (n); ++b)
          cur -= (long long)2 * cntbefore[c][d][b] * cntinside[b][c][d];
        for (int e = (0); e < (n); ++e)
          cur -= (long long)2 * cntbefore[e][c][d] * cntinside[d][e][c];
        for (int a = (0); a < (n); ++a)
          cur += (long long)2 * cntinside[c][a][d] * cntinside[a][d][c];
        ret += cur;
      }
  if (ret % 10 != 0) {
    printf("err ret=%d\n", ret);
  }
  return ret / 10;
}
void run() {
  scanf("%d", &n);
  for (int i = (0); i < (n); ++i) scanf("%d%d", &p[i].x, &p[i].y);
  printf("%lld\n", solve());
}
int solvestupid() {
  int ret = 0;
  for (int a = (0); a < (n); ++a)
    for (int b = (0); b < (n); ++b)
      for (int c = (0); c < (n); ++c)
        for (int d = (0); d < (n); ++d)
          for (int e = (0); e < (n); ++e) {
            if (b == a || c == b || c == a || d == c || d == b || d == a ||
                e == d || e == c || e == b || e == a)
              continue;
            if (side(c, d, a) != +1) continue;
            if (side(c, d, e) != -1) continue;
            if (side(c, d, b) != -1) continue;
            if (side(b, d, a) != +1) continue;
            if (side(e, c, a) != -1) continue;
            if (side(c, b, e) != -1) continue;
            if (side(d, b, e) != -1) continue;
            if (side(c, e, b) != +1) continue;
            if (side(d, e, b) != +1) continue;
            ++ret;
          }
  assert(ret % 5 == 0);
  ret /= 5;
  return ret;
}
void stress() {
  std::mt19937 rnd(213);
  int mnn = 10, mxn = 30, mxcoord = 1000000;
  for (int rep = (0); rep < (1000); ++rep) {
    n = rnd() % (mxn - mnn + 1) + mnn;
    while (true) {
      for (int i = (0); i < (n); ++i)
        p[i].x = rnd() % mxcoord, p[i].y = rnd() % mxcoord;
      bool ok = true;
      for (int i = (0); i < (n); ++i)
        for (int j = (i + 1); j < (n); ++j)
          for (int k = (j + 1); k < (n); ++k)
            if (side(i, j, k) == 0) ok = false;
      if (ok) break;
    }
    int have = solve();
    int want = solvestupid();
    if (have == want) {
      printf(".");
      continue;
    }
    printf("have=%d want=%d\n", have, want);
  }
}
int main() {
  run();
  return 0;
}
