#include "bits/stdc++.h"

#define all(x)   x.begin(), x.end()
#define NL       std::cout << '\n'

using lnt = long long;

const int inf = 0x3f3f3f3f;
const lnt linf = 1ll << 61;

const double eps = 1e-12;
int sgn(double x) { return (x < -eps ? -1 : x > eps); }

struct Pt { double x, y; };
Pt operator-(Pt a, Pt b) { return { a.x - b.x, a.y - b.y }; }
Pt operator+(Pt a, Pt b) { return { a.x + b.x, a.y + b.y }; }
Pt operator*(Pt a, double x) { return { a.x * x, a.y * x }; }
Pt operator/(Pt a, double x) { return { a.x / x, a.y / x }; }
double dot(Pt a, Pt b) { return a.x * b.x + a.y * b.y; }
double det(Pt a, Pt b) { return a.x * b.y - a.y * b.x; }
bool operator==(Pt a, Pt b) { return !sgn(dot(a-b, a-b)); }
bool operator<(Pt a, Pt b) { return det(a, b) > 0; }
double dis2(Pt a, Pt b) { return dot(a-b, a-b); }
double dis(Pt a, Pt b) { return std::sqrt(dis2(a, b)); }
double area(Pt a, Pt b, Pt c) { return std::abs(det(a - b, a - c)); }
bool onleft(Pt a, Pt b, Pt x) { return sgn(det(b-a, x-a)) > 0; }
Pt rot90(Pt a) { return {-a.y, a.x}; }
Pt unit(Pt a) {
  double d = dis(a, {0, 0});
  return sgn(d) ? a/d : Pt{0, 0};
}

struct Line { Pt s, t; };
double pt2line(Pt x, Line l) {
  if (l.s == l.t) { return dis(l.s, x); }
  return std::abs(det(x - l.s, x - l.t) / dis(l.s, l.t));
}
bool ptonline(Pt x, Line l) {
  if (l.s == l.t) { return sgn(dis2(l.s, x)) == 0; }
  return sgn(det(l.s - x, l.t - x)) == 0;
}
Pt intersect(Line a, Line b) {
  double v = det(a.t - a.s, b.s - a.s);
  double u = det(a.t - a.s, b.t - a.s);
  return (b.s * u - b.t * v) / (u - v);
}
bool para(Line a, Line b) { return !sgn(det(a.t - a.s, b.t - b.s)); }

struct Seg { Pt s, t; };
bool ptOnSeg(Pt x, Seg sg) {
  if (sg.s == sg.t) { return sgn(dis2(sg.s, x)) == 0; }
  if (sg.s == x || sg.t == x) { return false; }
  return sgn(det(sg.s - x, sg.t - x)) == 0 && sgn(dot(sg.s - x, sg.t - x)) <= 0;
}
double pt2Seg(Pt x, Seg sg) {
  if (sg.s == sg.t) { return dis(sg.s, x); }
  if (sgn(dot(sg.s - x, sg.t - sg.s)) * sgn(dot(sg.t - x, sg.t - sg.s)) <= 0) {
    return pt2line(x, {sg.s, sg.t});
  }
  return std::sqrt(std::min(dis2(sg.s, x), dis2(sg.t, x)));
}

struct BIT {
  std::vector<lnt> v; int n;

  BIT (int n) : v(n), n(n) { }

  void upd(int p, int x) {
    for (++p; p <= n; p += p & -p) {
      v[p-1] = (v[p-1] + x);
    }
  }

  lnt qry(int p) {
    lnt ret = 0;
    for (; p > 0; p -= p & -p) {
      ret = (ret + v[p-1]);
    }
    return ret;
  }
};

int main() {
  std::ios::sync_with_stdio(0), std::cin.tie(0);
  int t; std::cin >> t;
  while (t--) {
    int xp, yp, xq, yq; std::cin >> xp >> yp >> xq >> yq;
    Pt p = {xp, yp};
    Pt q = {xq, yq};
    int n; std::cin >> n;
    std::vector<Seg> v(n);
    for (int i = 0; i < n; ++i) {
      int x, y;
      std::cin >> x >> y;
      v[i].s = {x, y};
      std::cin >> x >> y;
      v[i].t = {x, y};
    }
    std::vector<Seg> lhs, rhs;
    for (int i = 0; i < n; ++i) {
      if (para({v[i].s, v[i].t}, {p, q})) { continue; }
      if (ptOnSeg(p, v[i])) { lhs.emplace_back(v[i]); }
      if (ptOnSeg(q, v[i])) { rhs.emplace_back(v[i]); }
    }
    lnt sub = 0;
    auto solve = [&]() -> void {
      std::vector<std::tuple<Pt, Pt, bool>> ps;
      for (auto [x, _] : lhs) { ps.emplace_back(x - p, x - q, 0); }
      for (auto [x, _] : rhs) { ps.emplace_back(x - p, x - q, 1); }
      std::vector<int> idx(ps.size()); std::iota(all(idx), 0);
      std::vector<int> rk(ps.size());
      std::sort(all(idx), [&](auto a, auto b) { return std::get<1>(ps[a]) < std::get<1>(ps[b]); });
      for (int i = 0, r = 0; i < ps.size(); ++i, ++r) {
        int j = i;
        for (j = i; j < ps.size() && sgn(det(std::get<1>(ps[idx[i]]), std::get<1>(ps[idx[j]]))) == 0; ++j) {
          rk[idx[j]] = r;
        }
        i = j-1;
      }
      
      std::sort(all(idx), [&](auto a, auto b) { return std::pair{ std::get<0>(ps[a]), std::get<2>(ps[a]) } < std::pair{ std::get<0>(ps[b]), std::get<2>(ps[b]) }; });
      BIT bit(ps.size());
      for (int i = 0; i < ssize(ps); ++i) {
        if (std::get<2>(ps[idx[i]]) == 0) {
          bit.upd(rk[idx[i]], 1);
        } else {
          sub += bit.qry(rk[idx[i]] + 1);
        }
      }
    };
    for (auto &x : lhs) { if (!onleft(x.s, x.t, q)) { std::swap(x.s, x.t); } }
    for (auto &x : rhs) { if (onleft(x.s, x.t, p)) { std::swap(x.s, x.t); } }
    solve();
    for (auto &x : lhs) { std::swap(x.s, x.t); }
    for (auto &x : rhs) { std::swap(x.s, x.t); }
    std::swap(p, q);
    std::swap(lhs, rhs);
    solve();
    std::cout << 1ll * ssize(lhs) * ssize(rhs) - sub; NL;
  }

  return 0;
}