#include <bits/stdc++.h>
#include <bits/extc++.h>
using namespace __gnu_pbds;
using namespace std;
// Pura Gente del Coach Moy y de la Alexbriza

using ll = long long;
using T = ll;

struct Point {
  int x, y;

  Point() {}
  Point(int x, int y) : x(x), y(y) {}

  void read() {
    cin >> x >> y;
  }

  void print() {
    cout << x << ' ' << y << '\n';
  }

  T sq() { return (T)x * x + (T)y * y; }

  T dot(Point p) { return (T)x * p.x + (T)y * p.y; }
  T cross(Point p) const { return (T)x * p.y - (T)y * p.x; }

  Point operator-(Point p) const { return Point(x - p.x, y - p.y); }
};

int half(Point p, Point v) { return v.cross(p) < 0 || (v.cross(p) == 0 && v.dot(p) < 0); }

vector<int> polarSortAround(Point o, Point dir, vector<Point>& P, bool cw = false) {
  vector<int> ord(int(P.size()));
  iota(ord.begin(), ord.end(), 0);
  sort(ord.begin(), ord.end(), [&](int i, int j) -> bool {
    Point p = P[i], q = P[j];
    auto ta = make_tuple(half(p - o, dir), 0);
    auto tb = make_tuple(half(q - o, dir), (p - o).cross(q - o));
    if (ta != tb) {
      return ta < tb;
    }
    return (p - o).sq() < (q - o).sq();
  });
  if (cw) {
    reverse(ord.begin(), ord.end());
  }
  return ord;
}

struct FT {
  vector<ll> s;
  FT(int n) : s(n) {}
  void update(int pos, ll dif) { // a[pos] += dif
    for (; pos < int(s.size()); pos |= pos + 1) s[pos] += dif;
  }
  ll query(int pos) { // sum of values in [0, pos)
    ll res = 0;
    for (; pos > 0; pos &= pos - 1) res += s[pos-1];
    return res;
  }
};

ll f(Point a, Point b, vector<Point>& P) {
  const int n = int(P.size());

  vector<int> ordA = polarSortAround(a, b - a, P);
  vector<int> rOrdA(n);
  for (int i = 0; i < n; ++i) {
    rOrdA[ordA[i]] = i;
  }

  vector<int> ordB = polarSortAround(b, a - b, P);

  FT ft(n);
  ll ret = 0;
  for (int i = n - 1; i >= 0; --i) {
    int j = rOrdA[ordB[i]];
    ret += ft.query(j);
    ft.update(j, 1);
  }
  return ret;
}

ll gauss(int n) {
  return (ll)n * (n + 1) >> 1;
}

int main() {
  cin.tie(0)->sync_with_stdio(0);

  Point s, e;
  s.read(), e.read();
  
  int n;
  cin >> n;

  vector<Point> P(n);
  for (Point& p : P) {
    p.read();
    p = p - s;
  }

  e = (e - s);
  s = (s - s);

  vector<int> inLine(2);
  vector<Point> L, R;
  for (Point p : P) {
    T ori = e.cross(p);
    if (ori > 0) {
      L.push_back(p);
    } else if (ori < 0) {
      R.push_back(p);
    } else {
      ++inLine[e.dot(p) < 0];
    }
  }

  ll ans = gauss(inLine[0] - 1) + gauss(inLine[1] - 1) + f(s, e, L) + f(s, e, R);
  cout << ans << '\n';
}