#include<bits/stdc++.h>

namespace std {
struct bipartite_matching {
    int N, M, T;
    vector<vector<int>> adj;
    vector<int> match, seen;
    bipartite_matching(int a, int b) : N(a), M(a + b), adj(M), 
            match(M, -1), seen(M, -1), T(0) {}
    void add_edge(int a, int b) {
        assert(0 <= a && a < N && b + N < M && N <= b + N);
        adj[a].push_back(b + N);
    }
    void shuffle_edges() { // useful to break some hairy tests
        mt19937 rng(chrono::steady_clock::now().time_since_epoch().count());
        for (auto& cur : adj)
            shuffle(cur.begin(), cur.end(), rng);
    } 
    bool dfs(int cur) {
        if (seen[cur] == T) return false;
        seen[cur] = T;
        for (int nxt : adj[cur]) 
            if (match[nxt] == -1) {
                match[nxt] = cur, match[cur] = nxt;
                return true;
            }
        for (int nxt : adj[cur]) 
            if (dfs(match[nxt])) {
                match[nxt] = cur, match[cur] = nxt;
                return true;
            }
        return false;
    }
    int solve() {
        int res = 0;
        while (true) {
            int cur = 0; ++T;
            for (int i = 0; i < N; ++i) 
                if (match[i] == -1) cur += dfs(i);
            if (cur == 0) break;
            else res += cur;
        }
        return res;
    }
}; }
int main() {
	using namespace std;
	cin.tie(nullptr)->sync_with_stdio(false);
	int T; cin >> T;

	struct rectangle_t {
		int idx;
		int a, c, b, d;
		rectangle_t intersection(rectangle_t r) {
			return {0, max(r.a, a), max(r.c, c), min(r.b, b), min(r.d, d)};
		}
		int get_area() {
			return (b > a && c < d ? (b - a) * (d - c) : 0);
		}
	};

	const int L = 2022;
	
	while (T--) {
		int M, N; cin >> M >> N;
		
		bipartite_matching flower(M, N);
		
		vector<vector<vector<rectangle_t>>> R(L, vector(L, vector<rectangle_t>()));
		for (int i = 0; i < M; ++i) {
			int a, c, b, d; cin >> a >> c >> b >> d;
			R[a][c].push_back({i, a, c, b, d});
		}

		for (int i = 0; i < N; ++i) {
			int a, c, b, d;
			cin >> a >> c >> b >> d;

			rectangle_t box = {i, a, c, b, d};

			for (int ac = a-4; ac <= a+4; ++ac) {
				if (ac < 0) continue;
				for (int bd = b-4; bd <= b+4; ++bd) {
					if (bd < 0) continue;
					for (auto r : R[ac][bd]) {
						auto inter = box.intersection(r);
						if (inter.get_area() * 2 >= r.get_area()) {
							flower.add_edge(r.idx, i);
						}
					}
				}
			}
		}

		cout << flower.solve() << '\n';
	}
}