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

const int M = 2010;
const int N = 112345;

struct rect {
    int x1, y1, x2, y2, index;
    int a() {
        if (x2 <= x1 || y2 <= y1) return 0;
        return (x2 - x1) * (y2 - y1);
    }
    rect inter(rect o) {
        int xx1 = max(o.x1, x1);
        int yy1 = max(o.y1, y1);
        int xx2 = min(o.x2, x2);
        int yy2 = min(o.y2, y2);
        return {xx1, yy1, xx2, yy2};
    }
};

vector<rect> g[M][M];

using num = long long;
const num INF = 1e12;

struct dinic {
    struct edge {
        int form, to;
        num c, f;
    };
    vector<edge> edges;
    vector<int> adj[N];

    void add_edge(int i, int j, num c) {
        edges.push_back({i, j, c, 0}); adj[i].push_back(edges.size() - 1);
        edges.push_back({j, i, 0, 0}); adj[j].push_back(edges.size() - 1);
    }

    int turn, seen[N], dist[N], st[N];
    bool bfs(int s, int t) {
        seen[t] = ++turn;
        dist[t] = 0;
        queue<int> q({t});
        while (q.size()) {
            int u = q.front(); q.pop();
            st[u] = 0;
            for (auto e: adj[u]) {
                int v = edges[e].to;
                if (seen[v] != turn && edges[e ^ 1].c != edges[e ^ 1].f) {
                    seen[v] = turn;
                    dist[v] = dist[u] + 1;
                    q.push(v);
                }
            }
        }
        return seen[s] == turn;
    }
    num dfs(int s, int t, num f) {
        if (s == t || f == 0)
            return f;
        for (int &i = st[s]; i < adj[s].size(); i++) {
            int e = adj[s][i], v = edges[e].to;
            if (seen[v] == turn && dist[v] + 1 == dist[s] && edges[e].c > edges[e].f) {
                if (num nf = dfs(v, t, min(f, edges[e].c - edges[e].f))) {
                    edges[e].f += nf;
                    edges[e ^ 1].f -= nf;
                    return nf;
                }
            }
        }
        return 0;
    }
    num max_flow(int s, int t) {
        num resp = 0;
        while (bfs(s, t)) {
            while (num val = dfs(s, t, INF))
                resp += val;
        }
        return resp;
    }
};

void solve() {
    dinic d;
    for (int i = 0; i < M; i++) {
        for (int j = 0; j < M; j++) {
            g[i][j].clear();
        }
    }
    int m, n; scanf("%d %d", &m, &n);
    for (int i = 0; i < m; i++) {
        int x1, y1, x2, y2;
        scanf("%d %d %d %d", &x1, &y1, &x2, &y2);
        g[x1][y1].push_back({x1, y1, x2, y2, i});
        d.add_edge(i, n + m + 1, 1);
    }
    for (int i = 0; i < n; i++) {
        int x1, y1, x2, y2;
        scanf("%d %d %d %d", &x1, &y1, &x2, &y2);
        rect r = {x1, y1, x2, y2, i};
        d.add_edge(n + m, i + m, 1);
        for (int x = x1 - 4; x <= x1 + 4; x++) {
            if (x < 0) continue;
            for (int y = y1 - 4; y <= y1 + 4; y++) {
                if (y < 0) continue;
                for (auto gg: g[x][y]) {
                    rect ii = r.inter(gg);
                    if (2 * ii.a() >= gg.a()) {
                        d.add_edge(i + m, gg.index, 1);
                    }
                }
            }
        }
    }
    num x = d.max_flow(n + m, n + m + 1);
    printf("%lld\n", x);
}

int main() {
    int t; scanf("%d", &t);
    while (t--)
        solve();
}