#include <bits/stdc++.h>
using ul = std::uint32_t;
using li = std::int32_t;
using ull = std::uint64_t;
using ll = std::int64_t;
using vul = std::vector<ul>;
using vb = std::vector<bool>;
using vvb = std::vector<vb>;
using vvvb = std::vector<vvb>;
std::mt19937_64 rands;
class point {
 public:
  li x = 0;
  li y = 0;
  point() = default;
  point(li a, li b) : x(a), y(b) {}
};
bool operator==(const point& a, const point& b) {
  return a.x == b.x && a.y == b.y;
}
point operator+(const point& a, const point& b) {
  return point(a.x + b.x, a.y + b.y);
}
point operator-(const point& a, const point& b) {
  return point(a.x - b.x, a.y - b.y);
}
ll inner(const point& a, const point& b) {
  return ll(a.x) * ll(b.x) + ll(a.y) * ll(b.y);
}
point rotate(const point& a) { return point(-a.y, a.x); }
ul region(ll x, ll y) {
  if (x < 0) {
    if (y < 0) {
      return 2;
    } else {
      return 1;
    }
  } else {
    if (y < 0) {
      return 3;
    } else {
      return 0;
    }
  }
}
bool lesslean(const point& a, const point& b, const point& cor) {
  ll ax = ll(a.x) * ll(cor.x) + ll(a.y) * ll(cor.y);
  ll ay = ll(a.y) * ll(cor.x) - ll(a.x) * ll(cor.y);
  ll bx = ll(b.x) * ll(cor.x) + ll(b.y) * ll(cor.y);
  ll by = ll(b.y) * ll(cor.x) - ll(b.x) * ll(cor.y);
  if (region(ax, ay) != region(bx, by)) {
    return region(ax, ay) < region(bx, by);
  } else {
    return ll(a.x) * ll(b.y) - ll(a.y) * ll(b.x) > 0;
  }
}
std::vector<point> points(2000);
ul n;
ull ans = 0;
int main() {
  std::ios::sync_with_stdio(false);
  std::cin.tie(0);
  rands.seed(std::time(0));
  std::cin >> n;
  points.resize(n);
  for (ul i = 0; i != n; ++i) {
    std::cin >> points[i].x >> points[i].y;
  }
  for (const point& center : points) {
    std::deque<point> reorder;
    for (const point& p : points) {
      if (!(p == center)) {
        reorder.push_back(p);
      }
    }
    std::sort(reorder.begin(), reorder.end(),
              [&](const point& a, const point& b) {
                return lesslean(a - center, b - center, point(1, 0));
              });
    for (ul i = 0; i != reorder.size(); ++i) {
      auto p = reorder.front();
      reorder.pop_front();
      auto it = std::lower_bound(
          reorder.begin(), reorder.end(), center + center - p,
          [&](const point& a, const point& b) {
            return lesslean(a - center, b - center, p - center);
          });
      ul k1 = it - reorder.begin();
      ul k2 = reorder.end() - it;
      ans += ull(k1 * (k1 - 1) >> 1) * ull(k2 * (k2 - 1) >> 1);
      reorder.push_back(p);
    }
  }
  std::cout << (ans >> 1) << std::endl;
  return 0;
}
