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

const int INF = 1e9;

class MaxFlow {
	int source;
	int sink;
	vector<int> to;
	vector<int> nxt;
	vector<int> head;
	vector<int> capacity;
	vector<int> distance;
	vector<int> ptr;
 
	void addEdge(int a, int b, int cap) {
		int eid = to.size();
		to.push_back(b);
		capacity.push_back(cap);
		nxt.push_back(head[a]);
		head[a] = eid;
	}
 
public:
	MaxFlow(int n, int source, int sink) {
		this->source = source;
		this->sink = sink;
		head.resize(n, -1);
		distance.resize(n);
	}
 
	void addDirectedEdge(int a, int b, int cap) {
		addEdge(a, b, cap);
		addEdge(b, a, 0);
	}
 
	bool bfs() {
		fill(distance.begin(), distance.end(), INT_MAX);
		distance[source] = 0;
		queue<int> q;
		q.push(source);
		while (!q.empty()) {
			int v = q.front();
			q.pop();
			for (int id = head[v]; id != -1; id = nxt[id]) {
				if (capacity[id] > 0 && distance[to[id]] > distance[v] + 1) {
					distance[to[id]] = distance[v] + 1;
					q.push(to[id]);
				}
			}
		}
		return distance[sink] != INT_MAX;
	}
 
	int dfs(int v, int flow) {
		if (v == sink) {
			return flow;
		}
		for (int &id = ptr[v]; id != -1; id = nxt[id]) {
			if (capacity[id] > 0 && distance[to[id]] == distance[v] + 1) {
				int pushed = dfs(to[id], min(flow, capacity[id]));
				if (pushed > 0) {
					capacity[id] -= pushed;
					capacity[id ^ 1] += pushed;
					return pushed;
				}
			}
		}
		return 0;
	}
 
	int maxFlow() {
		int res = 0;
		while (bfs()) { 
			ptr = head;
			while (int pushed = dfs(source, INT_MAX)) {
				res += pushed;
			}
		}
		return res;
	}
};

class Rect {
public:
	int x1, y1, x2, y2;

	Rect(int x1 = 0, int y1 = 0, int x2 = 0, int y2 = 0) : x1(x1), y1(y1), x2(x2), y2(y2) {}

	int area() {
		return (x2 - x1) * (y2 - y1);
	}
};

bool coverHalf(Rect &r1, Rect &r2) {
	Rect r;
	r.x1 = max(r1.x1, r2.x1);
	r.x2 = min(r1.x2, r2.x2);
	r.y1 = max(r1.y1, r2.y1);
	r.y2 = min(r1.y2, r2.y2);
	if (r.x1 < r.x2 && r.y1 < r.y2) {
		return r.area() * 2 >= r1.area();
	}
	return false;
}

int main() {
	ios_base::sync_with_stdio(false);
	cin.tie(0);
	int tests;
	cin >> tests;
	while (tests--) {
		int m, n;
		cin >> m >> n;
		vector<vector<vector<int>>> bb(2001, vector<vector<int>>(2001));
		vector<Rect> rect(m + n);
		for (int i = 0; i < m + n; ++i) {
			cin >> rect[i].x1 >> rect[i].y1 >> rect[i].x2 >> rect[i].y2;
			assert(rect[i].x2 - rect[i].x1 <= 4);
			assert(rect[i].y2 - rect[i].y1 <= 4);
			assert(rect[i].x1 <= rect[i].x2);
			assert(rect[i].y1 <= rect[i].y2);             
			assert(rect[i].x1 >= 0 && rect[i].x1 <= 2000);
			assert(rect[i].y1 >= 0 && rect[i].y1 <= 2000);
			assert(rect[i].x2 >= 0 && rect[i].x2 <= 2000);
			assert(rect[i].y2 >= 0 && rect[i].y2 <= 2000);
		}
		for (int i = 0; i < m; ++i) {
			bb[rect[i].x1][rect[i].y1].push_back(i);
		}
		MaxFlow maxflow(n + m + 2, n + m, n + m + 1);
		for (int i = 0; i < n; ++i) {
			for (int x1 = max(0, rect[m + i].x1 - 4); x1 <= rect[m + i].x2; ++x1) {
				for (int y1 = max(0, rect[m + i].y1 - 4); y1 <= rect[m + i].y2; ++y1) {
					for (auto index : bb[x1][y1]) {
						if (coverHalf(rect[index], rect[m + i])) {
							maxflow.addDirectedEdge(index, m + i, 1);
						}
					}
				}
			}
		}
		for (int i = 0; i < m; ++i) {
			maxflow.addDirectedEdge(n + m, i, 1);
		}
		for (int i = 0; i < n; ++i) {
			maxflow.addDirectedEdge(m + i, n + m + 1, 1);
		}
		cout << maxflow.maxFlow() << endl;
	}
	return 0;
}