#include <bits/stdc++.h>

#define fo(i, x, y) for (int i = int(x); i <= int(y); ++i)
#define fd(i, x, y) for (int i = int(x); i >= int(y); --i)
#define fi first
#define se second

using namespace std;
using pii = pair<int, int>;
using i64 = long long;

constexpr int X = 2e3, N = 1e5 + 5, inf = 1e9;

struct Dinic
{
	int n, m, s, t;
	struct Edge
	{
		int from, to, cap, flow;
	};
	vector<Edge> edges;
	vector<int> G[N];
	bool vis[N];
	int d[N];
	int cur[N];
	void init(int n)
	{
		this->n = n;
		fo(i, 0, n - 1)
			G[i].clear();
		edges.clear();
	}
	void AddEdge(int from, int to, int cap)
	{
		edges.push_back({from, to, cap, 0});
		edges.push_back({to, from, 0, 0});
		m = edges.size();
		G[from].push_back(m - 2);
		G[to].push_back(m - 1);
	}
	bool BFS()
	{
		memset(vis, 0, sizeof(vis));
		memset(d, 0, sizeof(d));
		queue<int> q;
		q.push(s);
		d[s] = 0;
		vis[s] = 1;
		while (q.size())
		{
			int x = q.front();
			q.pop();
			for (int i = 0; i < G[x].size(); i++)
			{
				Edge &e = edges[G[x][i]];
				if (!vis[e.to] && e.cap > e.flow)
				{
					vis[e.to] = 1;
					d[e.to] = d[x] + 1;
					q.emplace(e.to);
				}
			}
		}
		return vis[t];
	}
	int DFS(int x, int a)
	{
		if (x == t || !a) return a;
		int flow = 0, f;
		for (int &i = cur[x]; i < G[x].size(); i++)
		{
			Edge &e = edges[G[x][i]];
			if (d[x] + 1 == d[e.to] && (f = DFS(e.to, min(a, e.cap - e.flow))) > 0)
			{
				e.flow += f;
				edges[G[x][i] ^ 1].flow -= f;
				flow += f;
				a -= f;
				if (!a) break;
			}
		}
		return flow;
	}
	int MaxFlow(int s, int t)
	{
		this->s = s; this->t = t;
		int flow = 0;
		while (BFS())
		{
			memset(cur, 0, sizeof(cur));
			flow += DFS(s, inf);
		}
		return flow;
	}
}fl;

void work()
{
	int m, n;
	cin >> m >> n;
	vector<array<int, 4>> a(m), b(n);
	for (auto& [x, y, xx, yy]: a)
	{
		cin >> x >> y >> xx >> yy;
		xx--; yy--;
	}
	for (auto& [x, y, xx, yy]: b)
	{
		cin >> x >> y >> xx >> yy;
		xx--; yy--;
	}
	fl.init(n + m + 2);
	fl.s = n + m; fl.t = n + m + 1;
	map<int, vector<int>> id;
	fo(i, 0, n - 1)
	{
		auto &[x, y, xx, yy] = b[i];
		fo(p, x, xx)
			fo(q, y, yy)
				id[p * (X + 1) + q].emplace_back(i);
	}
	fo(i, 0, m - 1)
		fl.AddEdge(fl.s, i, 1);
	fo(i, 0, n - 1)
		fl.AddEdge(i + m, fl.t, 1);
	fo(ia, 0, m - 1)
	{
		auto &[x, y, xx, yy] = a[ia];
		vector<int> tid;
		fo(p, x, y)
			fo(q, xx, yy)
			{
				if (!id.count(p * (X + 1) + q)) continue;
				for (auto& i: id[p * (X + 1) + q])
				{
					auto area = [](const array<int, 4>& a)
					{
						auto& [x, y, xx, yy] = a;
						return (xx - x + 1) * (yy - y + 1);
					};
					auto ad = [](const array<int, 4>& a, const array<int, 4>& b) -> array<int, 4>
					{
						auto& [x, y, xx, yy] = a;
						auto& [bx, by, bxx, byy] = b;
						return { max(x, bx), max(y, by), min(xx, bxx), min(yy, byy) };
					};
					auto check = [&](const array<int, 4>& a, const array<int, 4>& b) -> bool
					{
						int s1 = area(a), s2 = area(ad(a, b));
						return 2 * s2 >= s1;
					};
					if (check({ x, y, xx, yy }, b[i]))
						tid.emplace_back(i);
				}
			}
		sort(tid.begin(), tid.end());
		tid.erase(unique(tid.begin(), tid.end()), tid.end());
		for (auto &ib : tid)
			fl.AddEdge(ia, ib + m, 1);
	}
	int ans = fl.MaxFlow(fl.s, fl.t);
	cout << ans << '\n';
}

int main()
{
	ios::sync_with_stdio(0), cin.tie(0);
#ifdef LC
	freopen("t.in", "r", stdin);
	freopen("t.out", "w", stdout);
#endif
	int T;
	cin >> T;
	while (T--)
		work();
	return 0;
}