#include <bits/stdc++.h>
using namespace std;
using ll = long long;

struct P { ll x; ll y; };

P diff(P a, P b) {
  return {b.x-a.x, b.y-a.y};
}

ll cross(P a, P b) {
  return a.x*b.y - a.y*b.x;
}

ll dot(P a, P b) {
  return a.x*b.x + a.y*b.y;
}

int naive(int n, vector<P> points) {
  auto triangle_include = [&](P p, P q, P r, P x) {
    p = diff(x, p);
    q = diff(x, q);
    r = diff(x, r);
    if(cross(p, q) > 0 && cross(q, r) > 0 && cross(r, p) > 0) return true;
    if(cross(p, q) < 0 && cross(q, r) < 0 && cross(r, p) < 0) return true;
    return false;
  };
  int ans = 0;
  for(int i = 0; i < n; i++) for(int j = 0; j < i; j++) for(int k = 0; k < j; k++) for(int l = 0; l < k; l++) {
    array<P, 4> poly = {points[i], points[j], points[k], points[l]};
    bool valid = true;
    for(int x = 0; x < n; x++) {
      if(x == i) continue;
      if(x == j) continue;
      if(x == k) continue;
      if(x == l) continue;
      int cnt = 0;
      for(int u = 0; u < 4; u++) for(int v = 0; v < u; v++) for(int w = 0; w < v; w++) {
        if(triangle_include(poly[u], poly[v], poly[w], points[x])) cnt++;
      }
      if(cnt == 2) valid = false;
    }
    if(valid) ans++;
  }
  return ans;
}

int solve(int n, vector<P> points) {
  auto triangle_include = [&](P p, P q, P r, P x) {
    p = diff(x, p);
    q = diff(x, q);
    r = diff(x, r);
    if(cross(p, q) > 0 && cross(q, r) > 0 && cross(r, p) > 0) return true;
    if(cross(p, q) < 0 && cross(q, r) < 0 && cross(r, p) < 0) return true;
    return false;
  };
  auto between = [&](int i, int j) {
    if(points[i].x > points[j].x) swap(i, j);
    int ret = 0;
    for(int k = 0; k < n; k++) {
      if(points[k].x <= points[i].x) continue;
      if(points[j].x <= points[k].x) continue;
      if(cross(diff(points[i], points[k]), diff(points[i], points[j])) > 0) ret++;
    }
    return ret;
  };
  vector bet(n, vector<int>(n));
  for(int i = 0; i < n; i++) for(int j = i+1; j < n; j++) {
    bet[i][j] = bet[j][i] = between(i, j);
  }
  map<ll, vector<int>> xi;
  for(int i = 0; i < n; i++) {
    xi[points[i].x].push_back(i);
  }
  for(auto& [k, v] : xi) {
    sort(v.begin(), v.end(), [&](int i, int j) { return points[i].y < points[j].y; });
  }
  vector<int> below(n);
  for(int i = 0; i < n; i++) {
    const auto& xv = xi[points[i].x];
    below[i] = lower_bound(xv.begin(), xv.end(), i, [&](int i, int j) { return points[i].y < points[j].y; }) - xv.begin();
  }
  auto valid_triangle = [&](int i, int j, int k) {
    array<int, 3> is = {i, j, k};
    sort(is.begin(), is.end(), [&](int i, int j) { return points[i].x < points[j].x; });
    int inner = 0;
    inner += bet[is[0]][is[2]] - bet[is[0]][is[1]] - bet[is[1]][is[2]];
    const auto& xv = xi[points[is[1]].x];
    if(points[is[0]].x < points[is[1]].x && points[is[1]].x < points[is[2]].x) {
      if(cross(diff(points[is[0]], points[is[1]]), diff(points[is[0]], points[is[2]])) > 0) {
        inner -= below[is[1]] + 1;
      } else {
        inner -= below[is[1]];
      }
    }
    return inner == 0;
  };
  ll all = 0, not_convex = 0;
  for(int i = 0; i < n; i++) for(int j = i+1; j < n; j++) {
    vector<int> valid_oppos;
    for(int k = 0; k < n; k++) {
      if(k == i) continue;
      if(k == j) continue;
      if(valid_triangle(i, j, k)) valid_oppos.push_back(k);
    }
    auto a = points[i], b = points[j];
    auto arg_cmp = [&](P p, P q, P start) {
      ll pc = cross(start, p);
      ll qc = cross(start, q);
      bool p_0 = pc == 0 && dot(p, start) > 0;
      bool q_0 = qc == 0 && dot(q, start) > 0;
      if(p_0 && q_0) return false;
      if(p_0 && !q_0) return true;
      if(!p_0 && q_0) return false;
      int pp = pc > 0 ? 0 : pc == 0 ? 1 : 2;
      int qp = qc > 0 ? 0 : pc == 0 ? 1 : 2;
      if(pp != qp) return pp < qp;
      return cross(p, q) > 0;
    };
    vector<int> by_b = valid_oppos;
    sort(by_b.begin(), by_b.end(), [&](int x, int y) { return arg_cmp(diff(b, points[x]), diff(b, points[y]), diff(b, a)); });
    vector<int> by_a = valid_oppos;
    sort(by_a.begin(), by_a.end(), [&](int x, int y) { return arg_cmp(diff(a, points[x]), diff(a, points[y]), diff(a, b)); });
    auto is_above = [&](int k) {
      return cross(diff(a, b), diff(a, points[k])) > 0;
    };
    int num_above = 0;
    for(int k : valid_oppos) {
      if(is_above(k)) num_above++;
    }
    int b_start = 0;
    while(b_start < by_b.size() && !is_above(by_b[b_start])) b_start++;
    int a_end = 0;
    while(a_end < by_a.size() && is_above(by_a[a_end])) a_end++;
    for(int k : valid_oppos) {
      if(is_above(k)) continue;
      all += num_above;
    }
    {
      int j = b_start;
      for(int bi = 0; bi < b_start; bi++) {
        auto c = points[by_b[bi]];
        while(j < by_b.size() && cross(diff(b, c), diff(b, points[by_b[j]])) > 0) j++;
        not_convex += j - b_start;
      }
    }
    {
      int j = 0;
      for(int ai = a_end; ai < by_a.size(); ai++) {
        auto c = points[by_a[ai]];
        while(j < by_a.size() && cross(diff(a, c), diff(a, points[by_a[j]])) > 0) j++;
        not_convex += a_end - j;
      }
    }
  }
  return all - (all-not_convex)/2;
}

int main() {
  int n; cin >> n;
  vector<P> points(n);
  for(int i = 0; i < n; i++) cin >> points[i].x >> points[i].y;
  cout << solve(n, points) << endl;
}