/*
 * author:  ADMathNoob
 * created: 05/08/24 11:56:45
 * problem: https://qoj.ac/problem/2297
 */

/*
Comments about problem:


*/

#include <bits/stdc++.h>

using namespace std;

#ifdef _DEBUG
#include "debug.h"
#else
#define debug(...) 42
#endif

template <class T>
int sgn(T x) {
  return (x > 0) - (x < 0);
}

template <class T>
struct Point {
  typedef Point P;
  T x, y;
  explicit Point(T x_ = 0, T y_ = 0) : x(x_), y(y_) {}
  bool operator<(P p) const { return tie(x, y) < tie(p.x, p.y); }
  bool operator==(P p) const { return tie(x, y) == tie(p.x, p.y); }
  P operator+(P p) const { return P(x + p.x, y + p.y); }
  P operator-(P p) const { return P(x - p.x, y - p.y); }
  P operator*(T d) const { return P(x * d, y * d); }
  P operator/(T d) const { return P(x / d, y / d); }
  T dot(P p) const { return x * p.x + y * p.y; }
  T cross(P p) const { return x * p.y - y * p.x; }
  T cross(P a, P b) const { return (a - *this).cross(b - *this); }
  T dist2() const { return x * x + y * y; }
  double dist() const { return sqrt((double) dist2()); }
  // angle to x-axis in interval [-pi, pi]
  double angle() const { return atan2(y, x); }
  P unit() const { return *this / dist(); }  // makes dist()=1
  P perp() const { return P(-y, x); }        // rotates +90 degrees
  P normal() const { return perp().unit(); }
  // returns point rotated 'a' radians ccw around the origin
  P rotate(double a) const { return P(x * cos(a) - y * sin(a), x * sin(a) + y * cos(a)); }
  // friend ostream& operator<<(ostream& os, P p) { return os << "(" << p.x << "," << p.y << ")"; }
};

template <typename T>
string to_string(const Point<T>& p) {
  string res = "(" + to_string(p.x) + ", " + to_string(p.y) + ")";
  return res;
}

template <typename T>
class Fenwick {
 public:
  const int n;
  const int max_power; // smallest power of 2 larger than n
  vector<T> tree;

  Fenwick(int _n) : n(_n), max_power(1 << (32 - __builtin_clz(n))), tree(n) {
    assert(n > 0);
  }

  T get(int x) const {
    assert(-1 <= x && x < n);
    T res{};
    while (x >= 0) {
      res += tree[x];
      x = (x & (x + 1)) - 1;
    }
    return res;
  }

  void modify(int x, T v) {
    assert(0 <= x && x < n);
    while (x < n) {
      tree[x] += v;
      x |= (x + 1);
    }
  }
};

using P = Point<long long>;

int main() {
  ios::sync_with_stdio(0);
  cin.tie(0);
  int xs, ys, xe, ye;
  cin >> xs >> ys >> xe >> ye;
  P s(xs, ys);
  P e(xe, ye);
  int n;
  cin >> n;
  vector<P> ps(n);
  for (int i = 0; i < n; i++) {
    int x, y;
    cin >> x >> y;
    ps[i] = P(x, y);
  }
  long long ans = 0;
  int onL = 0;
  int onR = 0;
  for (P p : ps) {
    if (s.cross(e, p) == 0) {
      if ((e - s).dot(p - s) < 0) {
        ans += onL;
        onL += 1;
      } else {
        ans += onR;
        onR += 1;
      }
    }
  }
  
  for (int rot = 0; rot < 2; rot++) {
    vector<pair<P, int>> a;
    for (P p : ps) {
      if (s.cross(e, p) > 0) {
        a.emplace_back(p, -1);
      }
    }
    sort(a.begin(), a.end(), [&](auto pp, auto qq) {
      P p = pp.first;
      P q = qq.first;
      long long cs = s.cross(p, q);
      if (cs != 0) return cs > 0;
      long long ce = e.cross(p, q);
      return ce < 0;
    });
    int sz = a.size();
    for (int i = 0; i < sz; i++) {
      a[i].second = i;
    }
    sort(a.begin(), a.end(), [&](auto pp, auto qq) {
      P p = pp.first;
      P q = qq.first;
      long long ce = e.cross(p, q);
      if (ce != 0) return ce > 0;
      long long cs = s.cross(p, q);
      return cs < 0;
    });
    debug(a);
    Fenwick<int> ft(sz + 1);
    for (int z = sz - 1; z >= 0; z--) {
      int i = a[z].second;
      ans += ft.get(i);
      ft.modify(i, +1);
    }
    
    swap(s, e);
  }
  cout << ans << '\n';
  return 0;
}