#include <bits/stdc++.h>

using namespace std;

typedef long long ll;
typedef long double ld;
#define all(a) (a).begin(), (a).end()
#define X first
#define Y second

const ll INF = LLONG_MAX;
const int MOD = 1e9 + 7, MAXN = 2e5 + 1337;
const ld EPS = 1e-6;

void solve();

int main() {
#ifdef LOCAL
    freopen("../main_cpp/input.txt", "r", stdin);
#else
    cin.tie(nullptr)->sync_with_stdio(false);
#endif
    int _ = 1;
    cin >> _;
    while (_--) {
        solve();
    }
}

vector<pair<int, int>> g[MAXN];

struct Rect {
    int x1, y1, x2, y2;

    int sq() {
        if (min(x2 - x1, y2 - y1) <= 0) return 0;
        return (x2 - x1) * (y2 - y1);
    }

    int intersec(const Rect oth) const {
        Rect ans;
        ans.x1 = max(x1, oth.x1);
        ans.y1 = max(y1, oth.y1);
        ans.x2 = min(x2, oth.x2);
        ans.y2 = min(y2, oth.y2);
        return ans.sq();
    }
};

const int MX = 2000 + 10;

vector<int> have[MX][MX];

struct Dinic {
    struct edge {
        int v, to;
        ll f, c;

        edge(int a, int b, ll C, ll d) : v(a), to(b), f(C), c(d) {}

        edge() = default;
    };

    vector<vector<int>> g;
    vector<edge> e;
    vector<int> dist, pnt;
    ll low = 1;
    int s, t, n;

    Dinic() = default;

    Dinic(int n, int ss = -1, int tt = -1) : n(n + 2), s(ss == -1 ? n : ss), t(tt == -1 ? n + 1 : tt), dist(n + 2),
                                             pnt(n + 2, 0) {
        g.assign(n + 2, {});
    }

    void init(int nn, int ss, int tt) {
        n = nn + 2, s = (ss == -1 ? nn : ss), t = (tt == -1 ? nn + 1 : tt);
        dist.resize(n), pnt.assign(n, 0), g.assign(n, {});
    }

    void create(int v, int to, ll c) {
        g[v].push_back(e.size());
        e.emplace_back(v, to, 0, c);
        g[to].push_back(e.size());
        e.emplace_back(to, v, 0, 0);
    }

    bool bfs() {
        fill(dist.begin(), dist.end(), INT_MAX);
        dist[s] = 0;
        queue<int> q;
        q.push(s);
        while (!q.empty()) {
            int v = q.front();
            q.pop();
            for (int i: g[v])
                if (e[i].c - e[i].f >= low && dist[e[i].to] == INT_MAX) {
                    dist[e[i].to] = dist[v] + 1;
                    q.push(e[i].to);
                }
        }
        return dist[t] != INT_MAX;
    }

    ll dfs(int v, ll minC = INF) {
        if (v == t) return minC;
        while (pnt[v] < g[v].size()) {
            int i = g[v][pnt[v]];
            if (dist[e[i].to] == dist[v] + 1 && e[i].c - e[i].f >= low) {
                ll delta = dfs(e[i].to, min(minC, e[i].c - e[i].f));
                if (delta) {
                    e[i].f += delta;
                    e[i ^ 1].f -= delta;
                    return delta;
                }
            }
            ++pnt[v];
        }
        return 0;
    }

    ll flow(int S = -1, int Tt = -1) {
        low = 1;
        s = (S == -1 ? s : S), t = (S == -1 ? t : Tt);
        ll ans = 0;
        while (bfs()) {
            fill(pnt.begin(), pnt.end(), 0);
            while (ll y = dfs(s))
                ans += y;
        }
        return ans;
    }
};

void solve() {
    for (int i = 0; i < MX; ++i) for (int j = 0; j < MX; ++j) have[i][j].clear();
    int n, m;
    cin >> n >> m;
    int sz = n + m + 10;
    for (int i = 1; i <= sz; ++i) {
        g[i].clear();
    }
    vector<Rect> a(n + 1);
    for (int i = 1; i <= n; ++i) {
        cin >> a[i].x1 >> a[i].y1 >> a[i].x2 >> a[i].y2;
        for (int x = a[i].x1; x <= a[i].x2; ++x) {
            for (int y = a[i].y1; y <= a[i].y2; ++y) {
                have[x][y].push_back(i);
            }
        }
    }
    for (int i = 1; i <= m; ++i) {
        int ind = i + n;
        Rect cur;
        cin >> cur.x1 >> cur.y1 >> cur.x2 >> cur.y2;
        for (int x = cur.x1; x <= cur.x2; ++x) {
            for (int y = cur.y1; y <= cur.y2; ++y) {
                for (auto &el : have[x][y]) {
                    if (a[el].intersec(cur) * 2 >= a[el].sq()) {
                        g[el + 1].push_back({ind + 1, 1});
                    }
                }
            }
        }
    }
    int ans = 0;
    for (int i = 2; i <= n + 1; ++i) {
        g[1].push_back({i, 1});
    }
    for (int i = n + 2; i <= n + m + 3; ++i) {
        g[i].emplace_back(sz - 1, 1);
    }
    Dinic dinic(sz + 10);
    for (int i = 1; i <= sz; ++i) {
        sort(all(g[i])), g[i].resize(unique(all(g[i])) - g[i].begin());
        for (auto &[to, c] : g[i]) {
            dinic.create(i, to, c);
        }
    }
    cout << dinic.flow(1, sz - 1) << "\n";
}