#include <bits/stdc++.h>
#ifdef SHARAELONG
#include "../../cpp-header/debug.hpp"
#endif
using namespace std;
typedef long long ll;
typedef pair<int, int> pii;

struct HopcroftKarp {
    int n, m;
    vector<vector<int>> g;
    vector<int> dst, le, ri;
    vector<char> visit, track;
    HopcroftKarp(int n, int m): n(n), m(m), g(n), dst(n), le(n, -1), ri(m, -1), visit(n), track(n+m) {}

    void add_edge(int s, int e) {
        g[s].push_back(e);
    }

    bool bfs() {
        bool res = false;
        queue<int> que;
        fill(dst.begin(), dst.end(), 0);
        for (int i=0; i<n; ++i) {
            if (le[i] == -1) que.push(i), dst[i] = 1;
        }
        while (!que.empty()) {
            int v = que.front();
            que.pop();
            for (auto i: g[v]) {
                if (ri[i] == -1) res = true;
                else if (!dst[ri[i]]) dst[ri[i]] = dst[v]+1, que.push(ri[i]);
            }
        }
        return res;
    }

    bool dfs(int v) {
        if (visit[v]) return false;
        visit[v] = 1;
        for (auto i: g[v]) {
            if (ri[i] == -1 || !visit[ri[i]] && dst[ri[i]] == dst[v]+1 && dfs(ri[i])) {
                le[v] = i;
                ri[i] = v;
                return true;
            }
        }
        return false;
    }

    int maximum_matching() {
        int res = 0;
        fill(le.begin(), le.end(), -1);
        fill(ri.begin(), ri.end(), -1);
        while (bfs()) {
            fill(visit.begin(), visit.end(), 0);
            for (int i=0; i<n; ++i) {
                if (le[i] == -1) res += dfs(i);
            }
        }
        return res;
    }
};

void solve() {
    int m, n;
    cin >> m >> n;
    vector<array<int, 4>> gr(m), de(n);
    for (int i=0; i<m; ++i) {
        for (int j=0; j<4; ++j) cin >> gr[i][j];
    }
    for (int i=0; i<n; ++i) {
        for (int j=0; j<4; ++j) cin >> de[i][j];
    }

    map<pii, vector<int>> mp;
    for (int i=0; i<n; ++i) {
        auto&[x1, y1, x2, y2] = de[i];
        mp[{ x1,y1 }].push_back(i);
        mp[{ x1,y2 }].push_back(i);
        mp[{ x2,y1 }].push_back(i);
        mp[{ x2,y2 }].push_back(i);
    }
    
    auto inter = [](const array<int, 4>& g, const array<int, 4>& d) {
        if (min(g[2], d[2]) < max(g[0], d[0])) return false;
        if (min(g[3], d[3]) < max(g[1], d[1])) return false;
        int sz = (min(g[2], d[2]) - max(g[0], d[0])) * (min(g[3], d[3]) - max(g[1], d[1]));
        return (2*sz >= (g[2]-g[0])*(g[3]-g[1]));
    };

    auto search = [&](int i, pii c, set<int>& s) {
        for (int x=c.first-4; x<=c.first+4; ++x) {
            for (int y=c.second-4; y<=c.second+4; ++y) {
                if (mp.find({ x,y }) != mp.end()) {
                    auto& v = mp[{ x,y }];
                    for (int j: v) {
                        if (inter(gr[i], de[j])) s.insert(j);
                    }
                }
            }
        }
    };

    HopcroftKarp g(m, n);
    for (int i=0; i<m; ++i) {
        auto[x1, y1, x2, y2] = gr[i];
        set<int> s;
        search(i, { x1,y1 }, s);
        search(i, { x1,y2 }, s);
        search(i, { x2,y1 }, s);
        search(i, { x2,y2 }, s);
        for (int j: s) g.add_edge(i, j);
    }
    cout << g.maximum_matching() << '\n';
}

int main() {
    ios_base::sync_with_stdio(false);
    cin.tie(nullptr);

    int cases;
    cin >> cases;
    while (cases--) solve();
}