#include <bits/stdc++.h>
using namespace std;
namespace IO {
template <class T>
void _R(T &x) {
  cin >> x;
}
void _R(int &x) { scanf("%d", &x); }
void _R(long long &x) { scanf("%lld", &x); }
void _R(double &x) { scanf("%lf", &x); }
void _R(char &x) { x = getchar(); }
void _R(char *x) { scanf("%s", x); }
void R() {}
template <class T, class... U>
void R(T &head, U &...tail) {
  _R(head), R(tail...);
}
template <class T>
void _W(const T &x) {
  cout << x;
}
void _W(const int &x) { printf("%d", x); }
void _W(const long long &x) { printf("%lld", x); }
void _W(const double &x) { printf("%.16f", x); }
void _W(const char &x) { putchar(x); }
void _W(const char *x) { printf("%s", x); }
template <class T, class U>
void _W(const pair<T, U> &x) {
  _W(x.first), putchar(' '), _W(x.second);
}
template <class T>
void _W(const vector<T> &x) {
  for (auto i = x.begin(); i != x.end(); _W(*i++))
    if (i != x.cbegin()) putchar(' ');
}
void W() {}
template <class T, class... U>
void W(const T &head, const U &...tail) {
  _W(head), putchar(sizeof...(tail) ? ' ' : '\n'), W(tail...);
}
}  // namespace IO
using namespace IO;
const int maxn = 2005;
const int mod = 1e9 + 7;
long long qp(long long a, long long n) {
  long long res = 1;
  n %= mod - 1;
  if (n < 0) n += mod - 1;
  while (n > 0) {
    if (n & 1) res = res * a % mod;
    a = a * a % mod;
    n >>= 1;
  }
  return res;
}
long long qp(long long a, long long n, int mod) {
  long long res = 1;
  n %= mod - 1;
  if (n < 0) n += mod - 1;
  while (n > 0) {
    if (n & 1) res = res * a % mod;
    a = a * a % mod;
    n >>= 1;
  }
  return res;
}
const double EPS = 1e-9;
inline int sign(double a) { return a < -EPS ? -1 : a > EPS; }
inline int cmp(double a, double b) { return sign(a - b); }
struct P {
  double x, y;
  P() {}
  P(double _x, double _y) : x(_x), y(_y) {}
  P operator+(P p) { return {x + p.x, y + p.y}; }
  P operator-(P p) { return {x - p.x, y - p.y}; }
  P operator*(double d) { return {x * d, y * d}; }
  P operator/(double d) { return {x / d, y / d}; }
  bool operator<(P p) const {
    int c = cmp(x, p.x);
    if (c) return c == -1;
    return cmp(y, p.y) == -1;
  }
  bool operator==(P o) const { return cmp(x, o.x) == 0 && cmp(y, o.y) == 0; }
  double dot(P p) { return x * p.x + y * p.y; }
  double det(P p) { return x * p.y - y * p.x; }
  double distTo(P p) { return (*this - p).abs(); }
  double alpha() { return atan2(y, x); }
  void read() { cin >> x >> y; }
  void write() { cout << "(" << x << "," << y << ")" << endl; }
  double abs() { return sqrt(abs2()); }
  double abs2() { return x * x + y * y; }
  P rot90() { return P(-y, x); }
  P unit() { return *this / abs(); }
  int quad() const { return sign(y) == 1 || (sign(y) == 0 && sign(x) >= 0); }
  P rot(double an) {
    return {x * cos(an) - y * sin(an), x * sin(an) + y * cos(an)};
  }
};
struct L {
  P ps[2];
  P &operator[](int i) { return ps[i]; }
  P dir() { return ps[1] - ps[0]; }
  L(P a, P b) {
    ps[0] = a;
    ps[1] = b;
  }
  bool include(P p) { return sign((ps[1] - ps[0]).det(p - ps[0])) > 0; }
  L push() {
    const double eps = 1e-8;
    P delta = (ps[1] - ps[0]).rot90().unit() * eps;
    return {ps[0] + delta, ps[1] + delta};
  }
};
bool cmp2(P a, P b) {
  if (a.quad() != b.quad()) {
    return a.quad() < b.quad();
  } else {
    return sign(a.det(b)) > 0;
  }
}
int n;
int cal(int i, int j) { return (j - i + n - 1) % (n - 1); }
long long C(int x) { return x <= 1 ? 0 : 1ll * x * (x - 1) / 2; }
int main(int argc, char *argv[]) {
  R(n);
  vector<P> a(n);
  for (int i = 0; i < n; ++i) R(a[i].x, a[i].y);
  long long res = 0;
  for (int i = 0; i < n; ++i) {
    vector<P> x;
    for (int j = 0; j < n; ++j) {
      if (i == j) continue;
      x.push_back(a[j] - a[i]);
    }
    sort(x.begin(), x.end(), cmp2);
    int r = 0;
    for (int j = 0; j < n - 1; ++j) {
      if (r == j) (++r) %= n - 1;
      while (sign(x[j].det(x[r])) > 0) (++r) %= n - 1;
      res += C(cal(j, r) - 1) * C(n - 1 - cal(j, r));
    }
  }
  W(res / 2);
  return 0;
}
