#include <bits/stdc++.h>

using namespace std;
using ll = long long;

template <class T>
using V = vector<T>;
template <class T>
using VV = vector<vector<T>>;

struct E {
    int to, rev, cap;
};

template <class C>
struct MaxFlow {
    C flow;
    V<char> dual;
};

template<class C, class E>
struct MFExec {
    static constexpr C INF = numeric_limits<C>::max();
    C eps;
    VV<E>& g;
    int s, t;
    V<int> level, iter;

    C dfs(int v, C f) {
        if(v == t) return f;
        C res = 0;
        for(int& i = iter[v]; i < int(g[v].size()); i++) {
            E& e = g[v][i];
            if(e.cap <= eps || level[v] >= level[e.to]) continue;
            C d = dfs(e.to, min(f, e.cap));
            e.cap -= d;
            g[e.to][e.rev].cap += d;
            res += d;
            f -= d;
            if(f == 0) break;
        }
        return res;
    }

    MaxFlow<C> info;
    MFExec(VV<E>& _g, int _s, int _t, C _eps) : eps(_eps), g(_g), s(_s), t(_t) {
        int N = int(g.size());

        C& flow = (info.flow = 0);
        while(true) {
            queue<int> que;
            level = V<int>(N, -1);
            level[s] = 0;
            que.push(s);
            while(!que.empty()) {
                int v = que.front(); que.pop();
                for(E e : g[v]) {
                    if(e.cap <= eps || level[e.to] >= 0) continue;
                    level[e.to] = level[v] + 1;
                    que.push(e.to);
                }
            }
            if(level[t] == -1) break;
            iter = V<int>(N, 0);
            while(true) {
                C f = dfs(s, INF);
                if(!f) break;
                flow += f;
            }
        }
        for(int i = 0; i < N; i++) info.dual.push_back(level[i] == -1);
    }
};

template <class C, class E>
MaxFlow<C> get_mf(VV<E>& g, int s, int t, C eps) {
    return MFExec<C, E>(g, s, t, eps).info;
}

void solve() {
    int m, n; cin >> m>> n;
    vector<tuple<int, int, int, int>> t(m);
    for(int i = 0; i < m; i++) {
        int x1, y1, x2, y2; cin >> x1 >> y1 >> x2 >> y2;
        t[i] = {x1, y1, x2, y2};
    }
    vector<tuple<int, int, int, int>> d(n);
    map<tuple<int, int, int, int>, int> rd;
    for(int i = 0; i < n; i++) {
        int x1, y1, x2, y2; cin >> x1 >> y1 >> x2 >> y2;
        d[i] = {x1, y1, x2, y2};
        rd[d[i]] = i;
    }
    VV<E> g(m+n+2);
    auto add_edge = [&](int from, int to, int cap) {
        g[from].push_back(E{to, int(g[to].size()), cap});
        g[to].push_back(E{from, int(g[from].size())-1, 0});
    };
    for(int i = 0; i < m; i++) {
        auto [x1, y1, x2, y2] = t[i];
        if(x2 > x1+8) continue;
        if(y2 > y1+8) continue;
        for(int lx = x1-4; lx <= x2; lx++) {
            for(int rx= lx+1; rx <= lx+4; rx++) {
                for(int ly = y1-4; ly <= y2; ly++) {
                    for(int ry = ly+1; ry <= ly+4; ry++) {
                        int dx = min(x2, rx) - max(x1, lx);
                        int dy = min(y2, ry) - max(y1, ly);
                        if(dx < 0 || dy < 0) continue;
                        if(dx*dy*2 >= (x2-x1)*(y2-y1)) {
                            if(rd.count({lx, ly, rx, ry})) {
                                add_edge(i, m+rd[{lx, ly, rx, ry}], 1);
                            }
                        }
                    }
                }
            }
        }
    }
    for(int i = 0; i < m; i++) add_edge(m+n, i, 1);
    for(int i = 0; i < n; i++) add_edge(m+i, m+n+1, 1);
    cout << get_mf(g, m+n, m+n+1, 0).flow << '\n';
}

int main() {
    int t; cin >> t;
    while(t--) solve();
}