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

inline int rd() {
	int x = 0;
	bool f = 0;
	char c = getchar();
	for (; !isdigit(c); c = getchar()) f |= (c == '-');
	for (; isdigit(c); c = getchar()) x = x * 10 + (c ^ 48);
	return f ? -x : x;
}

inline bool getmin(int &a, int b) {return a > b ? a = b, true : false;}

template<const int V, const int inf = 1000000000>
struct Hopcraft { 
	bool vis[V];
	vector<int> e[V];
	int nl, nr, ml[V], mr[V], dl[V], dr[V];
	inline void reset(int _nl, int _nr) {
		nl = _nl; nr = _nr;
		for (int i = 1; i <= nl; ++i) e[i].clear();
	}
	inline bool bfs() {
		static int q[V], hd, tl, dT;
		hd = 1; tl = 0; dT = inf;
		memset(dl, -1, sizeof(int) * (nl + 1));
		memset(dr, -1, sizeof(int) * (nr + 1));
		for (int i = 1; i <= nl; ++i) 
			if (!ml[i]) {dl[i] = 0; q[++tl] = i;}
		for (int u; hd <= tl;) {
			if (dl[u = q[hd++]] >= dT) break;
			for (auto v : e[u])
				if (dr[v] == -1) {
					dr[v] = dl[u] + 1;
					if (!mr[v]) getmin(dT, dr[v] + 1);
					else {dl[mr[v]] = dr[v] + 1; q[++tl] = mr[v];}
				}
		}
		return dT != inf;
	}
	bool dfs(int u) {
		for (auto v : e[u]) {
			if (vis[v] || dl[u] + 1 != dr[v]) continue;
			vis[v] = true;
			if (!mr[v] || dfs(mr[v])) {mr[v] = u; ml[u] = v; return true;}
		}
		return false;
	}
	inline void add(int u, int v) {e[u].push_back(v);}
	inline int max_matching() {
		int ans = 0;
		memset(ml, 0, sizeof(ml));
		memset(mr, 0, sizeof(mr));
		while (bfs()) {
			memset(vis, 0, sizeof(bool) * (nr + 1));
			for (int i = 1; i <= nl; ++i)
				if (!ml[i]) ans += dfs(i);
		}
		return ans;
	}
};

#define N 50007

Hopcraft<N> E;

int id[2007][2007];

set<int> tmp;

int lx[N], ly[N], rx[N], ry[N];

inline void work() {
	memset(id, 0, sizeof(id));
	int m = rd(), n = rd();
	E.reset(m, n);
	for (int i = 1; i <= m; ++i) {
		int ax = rd(), ay = rd(), bx = rd(), by = rd();
		lx[i] = ax; ly[i] = ay; rx[i] = bx; ry[i] = by;
		for (int x = ax; x < bx; ++x)
			for (int y = ay; y < by; ++y) id[x][y] = i;
	}
	for (int i = 1; i <= n; ++i) {
		int ax = rd(), ay = rd(), bx = rd(), by = rd();
		tmp.clear();
		for (int x = ax; x < bx; ++x)
			for (int y = ay; y < by; ++y) 
				if (id[x][y] && !tmp.count(id[x][y])) {
					tmp.insert(id[x][y]);
					if (max(0, (min(bx, rx[id[x][y]]) - max(ax, lx[id[x][y]]))) * max(0, (min(by, ry[id[x][y]]) - max(ay, ly[id[x][y]]))) * 2 >= (rx[id[x][y]] - lx[id[x][y]]) * (ry[id[x][y]] - ly[id[x][y]])) {
						E.add(id[x][y], i);
					}
				}
	}
	printf("%d\n", E.max_matching());
}

int main() {
	for (int t = rd(); t; --t) work();
	return 0;
}