#include <bits/stdc++.h>
using namespace std;
using ll = long long;
using vl = vector<ll>;
using str = string;
#define reps(i, a, n) for (ll i = (a); i < ll(n); i++)
#define rep(i, n) reps(i, 0, n)

bool chmin(ll& a, ll b) {
    if (a > b) {
        a = b;
        return true;
    }
    return false;
}

template <class Cap>
struct mf_graph {
   public:
    explicit mf_graph(int n) : _n(n), g(n) {}
    int add_edge(int from, int to, Cap cap) {
        assert(0 <= from and from < _n);
        assert(0 <= to and to < _n);
        assert(0 <= cap);
        int m = int(pos.size());
        pos.push_back({from, int(g[from].size())});
        g[from].push_back(_edge{to, int(g[to].size()), cap});
        g[to].push_back(_edge{from, int(g[from].size()) - 1, 0});
        return m;
    }
    struct edge {
        int from, to;
        Cap cap, flow;
    };
    Cap flow(int s, int t, Cap flow_limit = std::numeric_limits<Cap>::max()) {
        assert(0 <= s and s < _n);
        assert(0 <= t and t < _n);
        assert(s != t);
        std::vector<int> level(_n), iter(_n);
        auto bfs = [&]() {
            std::fill(level.begin(), level.end(), -1);
            level[s] = 0;
            std::queue<int> que;
            que.push(s);
            while (!que.empty()) {
                int v = que.front();
                que.pop();
                for (auto e : g[v]) {
                    if (e.cap == 0 or level[e.to] >= 0) continue;
                    level[e.to] = level[v] + 1;
                    if (e.to == t) return;
                    que.push(e.to);
                }
            }
        };

        auto dfs = [&](auto&& dfs, int v, Cap up) -> Cap {
            if (v == s) return up;
            Cap res = 0;
            int lv = level[v];
            for (int& i = iter[v]; i < int(g[v].size()); i++) {
                _edge& e = g[v][i];
                if (lv <= level[e.to] or g[e.to][e.rev].cap == 0) continue;
                Cap d = dfs(dfs, e.to, std::min(up - res, g[e.to][e.rev].cap));
                if (d <= 0) continue;
                e.cap += d;
                g[e.to][e.rev].cap -= d;
                res += d;
                if (res == up) return res;
            }
            level[v] = _n;
            return res;
        };
        Cap flow = 0;
        while (flow < flow_limit) {
            bfs();
            if (level[t] == -1) break;
            std::fill(iter.begin(), iter.end(), 0);
            Cap f;
            while ((f = dfs(dfs, t, flow_limit - flow)) > 0) {
                flow += f;
            }
        }
        return flow;
    }

   private:
    int _n;
    struct _edge {
        int to, rev;
        Cap cap;
    };
    std::vector<std::pair<int, int>> pos;
    std::vector<std::vector<_edge>> g;
};

void solve() {
    int m, n;
    cin >> m >> n;
    struct Pos2D {
        int x1, y1, x2, y2;
    };
    vector<vector<int>> posb(2001, vector<int>(2001, -1));
    vector<Pos2D> a(m), b(n);
    for (int i = 0; i < m; i++) {
        int x1, y1, x2, y2;
        cin >> x1 >> y1 >> x2 >> y2;
        a[i] = {x1, y1, x2, y2};
    }
    for (int i = 0; i < n; i++) {
        int x1, y1, x2, y2;
        cin >> x1 >> y1 >> x2 >> y2;
        b[i] = {x1, y1, x2, y2};
        for (int x = x1; x < x2; x++)
            for (int y = y1; y < y2; y++) posb[x][y] = i;
    }
    mf_graph<ll> mf(n + m + 2);
    ll S = 0, T = n + m + 1;
    for (int i = 0; i < m; i++) mf.add_edge(S, i + 1, 1);
    for (int i = 0; i < n; i++) mf.add_edge(i + 1 + m, T, 1);
    vector<int> used(n);
    for (int i = 0; i < m; i++) {
        for (int x = a[i].x1; x <= a[i].x2; x++) {
            for (int y = a[i].y1; y <= a[i].y2; y++) {
                if (posb[x][y] == -1) continue;
                int id = posb[x][y];
                if (used[id]) continue;
                used[id] = 1;
                int lx = max(a[i].x1, b[id].x1), rx = min(a[i].x2, b[id].x2);
                int ly = max(a[i].y1, b[id].y1), ry = min(a[i].y2, b[id].y2);
                if (lx > rx or ly > ry) continue;
                int area = (a[i].x2 - a[i].x1) * (a[i].y2 - a[i].y1);
                if (2 * (rx - lx) * (ry - ly) >= area)
                    mf.add_edge(i + 1, id + 1 + m, 1);
            }
        }
        for (int x = a[i].x1; x <= a[i].x2; x++) {
            for (int y = a[i].y1; y <= a[i].y2; y++) {
                if (posb[x][y] == -1) continue;
                used[posb[x][y]] = 0;
            }
        }
    }
    cout << mf.flow(S, T) << endl;
}

int main() {
    ll t = 1;
    cin >> t;
    rep(i, t) solve();
}