#include <bits/stdc++.h>
#define NIL 0
#define INF INT_MAX
using namespace std;

class BipartiteMatching {
  int U, V;
  vector<vector<int>> adj;
  vector<int> pairU, pairV, dist;

public:
  BipartiteMatching(int U, int V) {
    this->U = U;
    this->V = V;
    adj.resize(U + 1);
    pairU.resize(U + 1, NIL);
    pairV.resize(V + 1, NIL);
    dist.resize(U + 1, INF);
  }

  void addEdge(int u, int v) {
    adj[u].push_back(v);
  }

  bool bfs() {
    queue<int> q;

    for (int u = 1; u <= U; u++) {
      if (pairU[u] == NIL) {
        dist[u] = 0;
        q.push(u);
      } else {
        dist[u] = INF;
      }
    }
    dist[NIL] = INF;

    while (!q.empty()) {
      int u = q.front();
      q.pop();

      if (dist[u] < dist[NIL]) {
        for (int v : adj[u]) {
          if (dist[pairV[v]] == INF) {
            dist[pairV[v]] = dist[u] + 1;
            q.push(pairV[v]);
          }
        }
      }
    }
    return dist[NIL] != INF;
  }

  bool dfs(int u) {
    if (u != NIL) {
      for (int v : adj[u]) {
        if (dist[pairV[v]] == dist[u] + 1 && dfs(pairV[v])) {
          pairV[v] = u;
          pairU[u] = v;
          return true;
        }
      }
      dist[u] = INF;
      return false;
    }
    return true;
  }

  int hopcroftKarp() {
    int matching = 0;

    while (bfs()) {
      for (int u = 1; u <= U; u++) {
        if (pairU[u] == NIL && dfs(u)) {
          matching++;
        }
      }
    }
    return matching;
  }
};

int areaIntersect(array<int, 4> p1, array<int, 4> p2) {
  int x_overlap = max(0, min(p1[2], p2[2]) - max(p1[0], p2[0]));
  int y_overlap = max(0, min(p1[3], p2[3]) - max(p1[1], p2[1]));
  return x_overlap * y_overlap;
}

int area(array<int, 4> p) {
  int x = p[2] - p[0];
  int y = p[3] - p[1];
  return x * y;
}

void solve() {
  int m, n;
  cin >> m >> n;
  BipartiteMatching bm(m, n);
  vector<array<int, 4>> base, target;
  map<pair<float, float>, int> mp;

  for (int i = 0; i < m; i++) {
    int a, b, c, d;
    cin >> a >> b >> c >> d;
    base.push_back({a, b, c, d});
  }

  for (int i = 0; i < n; i++) {
    int a, b, c, d;
    cin >> a >> b >> c >> d;
    target.push_back({a, b, c, d});
    float midx = (float) (a + c)/ 2.0;
    float midy = (float) (b + d)/ 2.0;
    mp[{midx, midy}] = i;
  }

  for (int i = 0; i < m; i++) {
    float midx = (float) (base[i][0] + base[i][2]) / 2.0;
    float midy = (float) (base[i][1] + base[i][3]) / 2.0;

    for (float j = 0; j <= 2.0; j += 0.5) {
      for (float k = 0; k <= 2.0; k += 0.5) {
        if (mp.find({midx + j, midy + k}) != mp.end() && area(base[i]) <= 2 * areaIntersect(base[i], target[mp[{midx + j, midy + k}]])) {
          bm.addEdge(i + 1, mp[{midx + j, midy + k}] + 1);
        }

        if (mp.find({midx + j, midy - k}) != mp.end() && area(base[i]) <= 2 * areaIntersect(base[i], target[mp[{midx + j, midy - k}]])) {
          bm.addEdge(i + 1, mp[{midx + j, midy - k}] + 1);
        }

        if (mp.find({midx - j, midy + k}) != mp.end() && area(base[i]) <= 2 * areaIntersect(base[i], target[mp[{midx - j, midy + k}]])) {
          bm.addEdge(i + 1, mp[{midx - j, midy + k}] + 1);
        }

        if (mp.find({midx - j, midy - k}) != mp.end() && area(base[i]) <= 2 * areaIntersect(base[i], target[mp[{midx - j, midy - k}]])) {
          bm.addEdge(i + 1, mp[{midx - j, midy - k}] + 1);
        }
      }
    }
  }

  int res = bm.hopcroftKarp();
  cout << res << '\n';
}

int main() {
  int t = 1;
  cin >> t;
  while (t--) {
    solve();
  }
}