/*input
3
2 2
1 1 3 3
3 3 5 5
2 2 4 4
4 4 6 6
2 3
1 1 3 3
3 3 5 5
1 3 3 5
2 1 4 5
3 1 5 3
3 3
1 1 2 2
2 2 3 3
3 3 4 4
1 1 3 3
2 2 4 4
3 3 5 5

*/
#include <bits/stdc++.h>

using namespace std;
#define rep(i, a, b) for(int i = a; i < (b); ++i)
#define all(x) begin(x), end(x)
#define sz(x) (int)(x).size()
typedef long long ll;
typedef pair<int, int> pii;
typedef vector<int> vi;
const int N = 2005;
map<tuple<int, int, int, int>, vector<int>> ve;
//vector<int> ve[N][6][N][6];
const int M = 4e5 + 1e2;
bool dfs(int a, int L, vector<vi>& g, vi& btoa, vi& A, vi& B) {
	if (A[a] != L) return 0;
	A[a] = -1;
	for (int b : g[a]) if (B[b] == L + 1) {
			B[b] = 0;
			if (btoa[b] == -1 || dfs(btoa[b], L + 1, g, btoa, A, B))
				return btoa[b] = a, 1;
		}
	return 0;
}
int hopcroftKarp(vector<vi>& g, vi& btoa) {
	int res = 0;
	vi A(g.size()), B(btoa.size()), cur, next;
	for (;;) {
		fill(all(A), 0);
		fill(all(B), 0);
		cur.clear();
		for (int a : btoa) if (a != -1) A[a] = -1;
		rep(a, 0, sz(g)) if (A[a] == 0) cur.push_back(a);
		for (int lay = 1;; lay++) {
			bool islast = 0;
			next.clear();
			for (int a : cur) for (int b : g[a]) {
					if (btoa[b] == -1) {
						B[b] = lay;
						islast = 1;
					}
					else if (btoa[b] != a && !B[b]) {
						B[b] = lay;
						next.push_back(btoa[b]);
					}
				}
			if (islast) break;
			if (next.empty()) return res;
			for (int a : next) A[a] = lay;
			cur.swap(next);
		}
		rep(a, 0, sz(g))
		res += dfs(a, 0, g, btoa, A, B);
	}
	return res;
}
vector<int> ke[M];
int main() {
	cin.tie(0)->sync_with_stdio(0);
	int t;
	cin >> t;
	while (t-- > 0)
	{
		ve.clear();
		int n , m;
		cin >> n >> m;
		for (int i = 1; i <= n; ++i)
		{
			int x, y, u, v;
			cin >> x >> y >> u >> v;
			ve[make_tuple(x, u - x, y, v - y)].push_back(i);
		}
		for (int i = 1; i <= m; ++i) ke[i].clear();
		for (int i = 1; i <= m; ++i)
		{
			int x, y, u, v;
			cin >> x >> y >> u >> v;
			for (int X = x - 4; X <= u; ++X)
			{
				for (int Y = y - 4; Y <= v; ++Y)
				{
					for (int U = X; U <= X + 4; ++U)
					{
						for (int V = Y; V <= Y + 4; ++V)
						{
							int area = (V - Y) * (U - X);
							int A = max(x, X);
							int B = max(y, Y);
							int C = min(u, U);
							int D = min(v, V);
							if (C < A || D < B) continue;
							if (2 * (C - A) * (D - B) < area) continue;
							if (ve.find(make_tuple(X, U - X, Y, V - Y)) == ve.end()) continue;
							for (auto h : ve[make_tuple(X, U - X, Y, V - Y)])
								ke[i].push_back(h + m);
						}
					}
				}
			}
		}

		/*for (int i = 1; i <= m; ++i)
		{
			for (auto h : ke[i]) cout << h << ' ';
			cout << '\n';
		}*/
		// cout << hopcroftKarps

		vector<vector<int>> g;
		g.resize(m);
		for (int i = 0; i < m;  ++i) {
			for (int j : ke[i + 1])  {
				j -= m + 1;
				g[i].push_back(j);
			}
		}

		vi btoa(n, -1); cout << hopcroftKarp(g, btoa) << '\n';
	}
	return 0;
}