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 INF = 1e9;
namespace dbl_utils {
const double EPS = 1e-9;
bool eq(double a, double b) { return fabs(a - b) < EPS; }
bool ne(double a, double b) { return !eq(a, b); }
bool lt(double a, double b) { return a < b && !eq(a, b); }
bool le(double a, double b) { return !lt(b, a); }
bool ge(double a, double b) { return !lt(b, a); }
bool gt(double a, double b) { return lt(b, a); }
int sign(double x) {
  if (eq(x, 0)) return 0;
  if (x > 0) return 1;
  return -1;
}
}  // namespace dbl_utils
using namespace dbl_utils;
template <typename T>
struct _pt {
  T x, y;
  _pt<T>() {}
  _pt<T>(T _x, T _y) : x(_x), y(_y) {}
  _pt<T> operator+(const _pt<T> &p) const { return _pt<T>(x + p.x, y + p.y); }
  _pt<T> &operator+=(const _pt<T> &p) { return *this = *this + p; }
  _pt<T> operator-(const _pt<T> &p) const { return _pt<T>(x - p.x, y - p.y); }
  _pt<T> &operator-=(const _pt<T> &p) { return *this = *this - p; }
  _pt<T> operator*(T d) const { return _pt<T>(x * d, y * d); }
  _pt<T> &operator*=(T d) { return *this = *this * d; }
  T operator*(const _pt<T> &p) const { return x * p.y - y * p.x; }
  T operator%(const _pt<T> &p) const { return x * p.x + y * p.y; }
  T d2() const { return *this % *this; }
  double d() const { return sqrt((double)d2()); }
  double ang() const { return atan2((double)y, (double)x); }
  _pt<T> rotate90() const { return _pt<T>(-y, x); }
  _pt<T> rotate(double ang) {
    return _pt<T>(x * cos(ang) - y * sin(ang), x * sin(ang) + y * cos(ang));
  }
  int turn(const _pt<T> &p) const { return sign((*this) * p); }
  bool operator<(const _pt<T> &p) const {
    if (!eq(x, p.x)) return lt(x, p.x);
    return lt(y, p.y);
  }
  bool operator==(const _pt<T> &p) const { return eq(x, p.x) && eq(y, p.y); }
  void read() { cin >> x >> y; }
};
const int N = 303;
long long dp[3][N][N];
long long solve(vector<_pt<long long>> a) {
  int n = a.size();
  sort(a.begin(), a.end());
  vector<vector<vector<int>>> ok(n, vector<vector<int>>(n));
  for (int i = 0; i < n; i++) {
    for (int j = 0; j < n; j++) {
      for (int k = 0; k < n; k++) {
        if ((a[j] - a[i]) * (a[k] - a[j]) > 0) {
          ok[i][j].push_back(k);
        }
      }
    }
  }
  long long ans = 0;
  for (int i = 0; i < n; i++) {
    vector<pair<_pt<long long>, int>> bb;
    for (int j = i + 1; j < n; j++) {
      bb.push_back({a[j] - a[i], j});
    }
    sort(bb.begin(), bb.end(),
         [&](const pair<_pt<long long>, int> &p1,
             const pair<_pt<long long>, int> &p2) {
           return p1.first * p2.first > 0;
         });
    vector<_pt<long long>> b;
    for (auto o : bb) b.push_back(o.first);
    int m = b.size();
    vector<int> rid(n, -1);
    for (int i = 0; i < m; i++) rid[bb[i].second] = i;
    const int K = 3;
    memset(dp, 0, sizeof(dp));
    for (int i = 0; i < m; i++) {
      for (int j = i + 1; j < m; j++) {
        dp[0][i][j]++;
        for (int kk : ok[bb[i].second][bb[j].second]) {
          int k = rid[kk];
          if (k <= j) continue;
          if (1) {
            for (int t = 0; t < K - 1; t++) {
              dp[t + 1][j][k] += dp[t][i][j];
            }
          }
        }
        ans += dp[K - 1][i][j];
      }
    }
  }
  return ans;
}
void test() {
  int n = 300;
  vector<_pt<long long>> a(n);
  mt19937 rnd;
  for (int i = 0; i < n; i++) {
    a[i].x = rnd() % (int)1e6;
    a[i].y = rnd() % (int)1e6;
  }
  cout << solve(a) << endl;
  cerr << "time: " << clock() * 1.0 / CLOCKS_PER_SEC << endl;
  exit(0);
}
int main() {
  int n;
  while (cin >> n) {
    vector<_pt<long long>> a(n);
    for (int i = 0; i < n; i++) {
      cin >> a[i].x >> a[i].y;
    }
    cout << solve(a) << endl;
  }
}
