#include <bits/stdc++.h>
using namespace std;

typedef long long i64;
typedef pair<int, int> pii;

const int maxn = 2200000;
const int prm = 998244353;
const i64 inf = 1000000007;
const i64 inf2 = inf*inf;

vector<int> g[maxn];
int cur[maxn];
int ee, vv[maxn], cap[maxn], flow[maxn];
void init(int n) { // ATTENTION: TO BE CALLED
  ee = 0;
  for (int i = 1; i <= n; ++i) {
    g[i].clear();
  }
}
void adj(int u, int v, int w) {
  cap[ee] = w;
  flow[ee] = 0;
  vv[ee] = v;
  g[u].push_back(ee);
  ++ee;
  cap[ee] = 0;
  flow[ee] = 0;
  vv[ee] = u;
  g[v].push_back(ee);
  ++ee;
}

int dinic(int n, int S, int T) {
  static int lev[maxn];

  auto bfs = [&]() {
    for (int i = 1; i <= n; ++i) {
      cur[i] = 0;
      lev[i] = inf;
    }
    static queue<int> q;
    lev[S] = 0;
    q.push(S);
    while (!q.empty()) {
      int u = q.front(); q.pop();
      for (int i = 0; i < g[u].size(); ++i) {
        int e = g[u][i], v = vv[e];
        if (cap[e] > flow[e] && lev[v] == inf) {
          lev[v] = lev[u] + 1;
          q.push(v);
        }
      }
    }
  };

  std::function<int(int, int)> dfs = [&](int u, int c) {
    if (u == T) {
      return c;
    }
    int ret = 0;
    for (int& i = cur[u]; i < g[u].size(); ++i) {
      int e = g[u][i], v = vv[e];
      if (cap[e] <= flow[e] || lev[v] != lev[u] + 1) {
        continue;
      }
      int tmp = dfs(v, min(c, cap[e]-flow[e]));
      flow[e] += tmp;
      flow[e^1] -= tmp;
      ret += tmp;
      c -= tmp;
      if (c == 0) {
        break;
      }
    }
    return ret;
  };

  int ret = 0;
  while (true) {
    bfs();
    int tmp = dfs(S, inf);
    if (tmp == 0) {
      break;
    }
    ret += tmp;
  }
  return ret;
}

vector<int> G[2020][2020];
void once() {
  int m, n;
  scanf("%d %d", &m, &n);
  init(m+n+2);
  int S = m+n+1, T = S+1;
  for (int i = 1; i <= m; ++i) {
    adj(S, i, 1);
  }
  for (int i = 1; i <= n; ++i) {
    adj(i+m, T, 1);
  }

  for (int i = 1; i <= 2000; ++i) {
    for (int j = 1; j <= 2000; ++j) {
      G[i][j].clear();
    }
  }

  static int w[maxn];
  for (int i = 1; i <= m; ++i) {
    int u1, v1, u2, v2;
    scanf("%d %d %d %d", &u1, &v1, &u2, &v2);
    w[i] = (u2 - u1) * (v2 - v1);
    for (int j = u1+1; j <= u2; ++j) {
      for (int k = v1+1; k <= v2; ++k) {
        G[j][k].emplace_back(i);
      }
    }
  }

  static int a[maxn];
  for (int i = 1; i <= n; ++i) {
    vector<int> vt;

    int u1, v1, u2, v2;
    scanf("%d %d %d %d", &u1, &v1, &u2, &v2);
    for (int j = u1+1; j <= u2; ++j) {
      for (int k = v1+1; k <= v2; ++k) {
        for (auto e: G[j][k]) {
          vt.emplace_back(e);
        }
      }
    }

    for (auto e: vt) {
      a[e]++;
    }
    sort(vt.begin(), vt.end());
    vt.erase(unique(vt.begin(), vt.end()), vt.end());
    for (auto e: vt) {
      if (a[e] * 2 >= w[e]) {
        adj(e, i+m, 1);
      }
      a[e] = 0;
    }
  }

  printf("%d\n", dinic(T, S, T));
}
int main() {
  int tes;
  scanf("%d", &tes);
  while (tes--) {
    once();
  }
  return 0;
}