#pragma GCC optimize("Ofast")
#include <bits/stdc++.h>
using namespace std;
typedef long long int ll;
typedef unsigned long long int ull;

mt19937_64 rng(chrono::steady_clock::now().time_since_epoch().count());
ll myRand(ll B) {
    return (ull) rng() % B;
}

template<typename T>
struct dinic{
    struct edge{
        int to;
        T c,f;
    };
    T eps;
    const T inf=numeric_limits<T>::max();
    int n,m = 0;
    vector<edge> e;
    vector<vector<int>> g;
    vector<int> level, ptr;
    dinic(int n): n(n), g(n), level(n), ptr(n) {
        eps = (T)1 / (T)1e9;
    }
    void add_edge(int s, int t, T c){
        e.push_back({t, c, 0});
        e.push_back({s, 0, 0});
        g[s].push_back(m++);
        g[t].push_back(m++);
    }
    bool bfs(int s, int t){
        fill(level.begin(), level.end(), -1);
        level[s] = 0;
        for(queue<int> q({s});q.size();q.pop()){
            int s = q.front();
            for(int i:g[s]){
                int t = e[i].to;
                if(level[t] == -1 and (e[i].c - e[i].f) > eps){
                    level[t] = level[s] + 1;
                    q.push(t);
                }
            }
        }
        return (level[t] != -1);
    }
    T dfs(int s, int t, T psh){
        if(!(psh > eps) or s == t) return psh;
        for(int &i = ptr[s]; i < (int)g[s].size(); ++i){
            auto &eg = e[g[s][i]];
            if(level[eg.to] != level[s] + 1 or !(eg.c - eg.f > eps)) continue;
            T f = dfs(eg.to, t, min(psh, eg.c-eg.f));
            if(f > eps){
                eg.f += f;
                e[g[s][i]^1].f -= f;
                return f;
            }
        }
        return 0;
    }
    T max_flow(int s, int t){
        T f = 0;
        while(bfs(s,t)){
            fill(ptr.begin(), ptr.end(), 0);
            while(1){
                T c = dfs(s, t, inf);
                if(c > eps){
                    f += c;
                }
                else{
                    break;
                }
            }
        }
        return f;
    }
    // ABC239-G
    vector<bool> min_cut(int s){
        vector<bool> visited(n);
        queue<int> q; q.push(s);
        while(q.size()){
            int p = q.front(); q.pop();
            visited[p] = true;
            for(auto idx:g[p]){
                auto eg = e[idx];
                if(eg.c - eg.f > eps and !visited[eg.to]){
                    visited[eg.to] = true;
                    q.push(eg.to);
                }
            }
        }
        return visited;
    }
};

vector<int> d[2001][2001];

int main() {
    cin.tie(nullptr);
    ios::sync_with_stdio(false);
    int q; cin >> q;
    while (q--) {
        int m,n; cin >> m >> n;
        const int N = m+n;
        vector<int> x1(N),y1(N),x2(N),y2(N);
        for (int i = 0; i < N; ++i) {
            cin >> x1[i] >> y1[i] >> x2[i] >> y2[i];
        }
        for (int i = 0; i < n; ++i) {
            int xx = x1[m+i], yy = y1[m+i];
            d[xx][yy].emplace_back(m+i);
        }
        const int S = N, T = N+1;
        dinic<int> g(N+2);
        // 長方形の共通面積
        auto cal = [&](int i,int j)->int{
            return max(0, min(x2[i],x2[j]) - max(x1[i],x1[j])) * max(0, min(y2[i],y2[j]) - max(y1[i],y1[j]));
        };
        for (int i = 0; i < m; ++i) {
            int x = x1[i], y = y1[i];
            int xx = x2[i], yy = y2[i];
            int area = (xx-x)*(yy-y);
            for (int j = max(x-3,0); j <= xx; ++j) {
                for (int k = max(y-3,0); k <= yy; ++k) {
                    for (int l:d[j][k]) {
                        int s = cal(i,l);
                        if(s*2 >= area) g.add_edge(i,l,1);
                    }
                }
            }
        }
        for (int i = 0; i < m; ++i) {
            g.add_edge(S,i,1);
        }
        for (int i = 0; i < n; ++i) {
            g.add_edge(i+m,T,1);
        }
        cout << g.max_flow(S,T) << "\n";
        for (int i = 0; i < n; ++i) {
            int xx = x1[m+i], yy = y1[m+i];
            d[xx][yy].clear();
        }
    }
}