#include <bits/stdc++.h>

#ifdef LOCAL
using std::cerr;
#define safe cerr << __PRETTY_FUNCTION__ << " Line " << __LINE__ << " safe\n"
#define debug(args...) qqbx(#args, args)
#define orange(args...) danb(#args, args)
template <typename ...T> void qqbx(const char *s, T ...args) {
    int cnt = sizeof...(T);
    ((cerr << "\033[1;32m(" << s << ")=("), ...,
    (cerr << args << (--cnt?", ":")\e[0m\n")));
}
template <typename T> void danb(const char *s, T L, T R) {
    cerr << "\033[1;32m[ " << s << " ] = [ ";
    for (int f = 0; L != R; ++L) cerr << (f++?", ":"") << *L;
    cerr << " ]\033[0m\n";
}
#else
#define safe ((void)0)
#define debug(...) ((void)0)
#define orange(...) ((void)0)
#endif

#define F first
#define S second
#define pb push_back
#define ALL(x) begin(x), end(x)
#define lowbit(x) (x & (-x))

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

struct Rect {
    int x1, y1, x2, y2;
    Rect() {}
    Rect(int _x1, int _y1, int _x2, int _y2) : x1(_x1), y1(_y1), x2(_x2), y2(_y2) {}
};

struct Dinic {
    const int INF = 1<<30;
    static const int MAXN = 50005 * 2;
    struct Edge {
        int u, v;
        int cap, rest;
    };

    int n, m, s, t, d[MAXN], cur[MAXN];
    vector<Edge> edges;
    vector<int> G[MAXN];

    void init() {
        edges.clear();
        for (int i = 0; i < MAXN; i++) {
            G[i].clear();
        }
    }
    
    void add_edge(int u, int v, int cap) {
        edges.push_back({u, v, cap, cap});
        edges.push_back({v, u, 0, 0});
        m = edges.size();
        G[u].push_back(m-2);
        G[v].push_back(m-1);
    }

    bool bfs() {
        memset(d, -1, sizeof(d));
        queue<int> que;
        que.push(s); d[s] = 0;
        while (!que.empty()) {
            int u = que.front(); que.pop();
            for (int ei : G[u]) {
                Edge &e = edges[ei];
                if (d[e.v] < 0 && e.rest > 0) {
                    d[e.v] = d[u] + 1;
                    que.push(e.v);
                }
            }
        }
        return d[t] >= 0;
    }

    int dfs(int u, int a) {
        if (u == t || a == 0) return a;
        int flow = 0, f;
        for (int &i = cur[u]; i < (int)G[u].size(); i++) {
            Edge &e = edges[G[u][i]];
            if (d[u] + 1 != d[e.v]) continue;
            f = dfs(e.v, min(a, e.rest));
            if (f > 0) {
                e.rest -= f;
                edges[G[u][i] ^ 1].rest += f;
                flow += f;
                a -= f;
                if (a == 0) break;
            }
        }
        return flow;
    }

    int maxflow(int s, int t) {
        this->s = s, this->t = t;
        int flow = 0, mf;
        while (bfs()) {
            memset(cur, 0, sizeof(cur));
            while ((mf = dfs(s, INF))) {
                flow += mf;
            }
        }
        return flow;
    }
};

int n, m;
Rect ground[50005];
int area[50005];
Rect detect[50005];
set<pair<pii, int>> mp[2005][2005];
set<int> connect[50005];

int intersect(Rect a, Rect b) {
    int x1, y1, x2, y2;
    x1 = max(a.x1, b.x1);
    y1 = max(a.y1, b.y1);
    x2 = min(a.x2, b.x2);
    y2 = min(a.y2, b.y2);
    return (x2 - x1) * (y2 - y1);
}

void sol() {
    Dinic *flow = new Dinic();
    flow->init();

    for (int i = 0; i < 2000+1; i++) {
        for (int j = 0; j < 2000+1; j++) {
            mp[i][j] = set<pair<pii, int>>();
        }
    }
    for (int i = 0; i < n; i++) connect[i] = set<int>();

    for (int i = 0; i < m; i++) {
        auto [x1, y1, x2, y2] = ground[i];
        area[i] = 0;
        mp[x1][y1].insert({{x2, y2}, i});
    }

    int nc = 0, mc = 0;
    for (int i = 0; i < n; i++) {
        auto [x1, y1, x2, y2] = detect[i];
        int v = 0;
        for (int x = max(0, x1-4); x < min(2000, x2+4)+1; x++) {
            for (int y = max(0, y1-4); y < min(2000, y2+4)+1; y++) {
                for (auto [rxy, j] : mp[x][y]) {
                    auto [rx, ry] = rxy;
                    if (intersect(Rect(x, y, rx, ry), detect[i]) * 2 >= (rx - x) * (ry - y)) {
                        connect[i].insert(j);
                        v = 1;
                    }
                }
            }
        }
        nc += v;
    }
    
    set<int> seen;
    for (int i = 0, id = 0; i < n; i++) {
        if (connect[i].size()) {
            for (int j : connect[i]) {
                flow->add_edge(id, nc+j, 1);
                seen.insert(j);
            }
            id++;
        }
    }
    mc = seen.size();
    safe;
    for (int i = 0; i < nc; i++) {
        flow->add_edge(nc+mc, i, 1);
    }
    safe;
    for (int i = nc; i < nc+mc; i++) {
        flow->add_edge(i, nc+mc+1, 1);
    }
    safe;
    ll ans = flow->maxflow(nc+mc, nc+mc+1);
    cout << ans << '\n';
    safe;
}

signed main() {
    ios::sync_with_stdio(0), cin.tie(0);
    #ifdef LOCAL
    freopen("input.txt", "r", stdin);
    #endif
    int tc = 1;
    cin >> tc;
    while (tc--) {
        cin >> m >> n;
        int x1, y1, x2, y2;
        for (int i = 0; i < m; i++) {
            cin >> x1 >> y1 >> x2 >> y2;
            if (x1 > x2) swap(x1, x2);
            if (y1 > y2) swap(y1, y2);
            ground[i] = Rect(x1, y1, x2, y2);
        }
        for (int i = 0; i < n; i++) {
            cin >> x1 >> y1 >> x2 >> y2;
            if (x1 > x2) swap(x1, x2);
            if (y1 > y2) swap(y1, y2);
            detect[i] = Rect(x1, y1, x2, y2);
        }
        sol();
    }
    return 0;
}