#include "bits/stdc++.h"
using namespace std;
using ll = long long;
using vvi = vector<vector<int>>;
using vb = vector<bool>;
using vi = vector<int>;

namespace atcoder {
    template <class Cap> struct mf_graph {
        public:
        mf_graph(int n) : _n(n), g(n) {}

        int add_edge(int from, int to, Cap cap){
            int m = int(pos.size());
            pos.push_back({from, int(g[from].size())});
            int from_id = int(g[from].size());
            int to_id = int(g[to].size());
            if(from == to)to_id++;
            g[from].push_back(_edge{to, to_id, cap});
            g[to].push_back(_edge{from, from_id, 0});
            return m;
        }

        struct edge {
            int from, to;
            Cap cap, flow;
        };

        Cap flow(int s, int t){
            return flow(s, t, numeric_limits<Cap>::max());
        }

        Cap flow(int s, int t, Cap flow_limit) {
            vi level(_n), iter(_n);
            queue<int> que;
            auto bfs = [&](){
                fill(level.begin(),level.end(), -1);
                level[s] = 0;
                while(!que.empty())que.pop();
                que.push(s);
                while(!que.empty()){
                    int v = que.front();
                    que.pop();
                    for(auto e : g[v]){
                        if(e.cap == 0 || level[e.to] >= 0)continue;
                        level[e.to] = level[v] + 1;
                        if(e.to== t)return;
                        que.push(e.to);
                    }
                }
            };
            auto dfs = [&](auto self, int v, Cap up){
                if(v == s)return up;
                Cap res = 0;
                int level_v = level[v];
                for(int& i = iter[v]; i < int(g[v].size()); i++){
                    _edge& e = g[v][i];
                    if(level_v <= level[e.to] || g[e.to][e.rev].cap == 0)continue;
                    Cap d = self(self, e.to, min(up - res, g[e.to][e.rev].cap));
                    if(d <= 0)continue;
                    g[v][i].cap += d;
                    g[e.to][e.rev].cap -= d;
                    res += d;
                    if(res == up)break;
                }
                return res;
            };
            Cap flow = 0;
            while(flow < flow_limit){
                bfs();
                if(level[t] == -1)break;
                fill(iter.begin(), iter.end(), 0);
                while(flow < flow_limit) {
                    Cap f = dfs(dfs, t, flow_limit - flow);
                    if(!f)break;
                    flow += f;
                }
            } 
            return flow;
        }
        private:
    int _n;
    struct _edge {
        int to, rev;
        Cap cap;
    };
    vector<pair<int,int>> pos;
    vector<vector<_edge>> g;
    };
};

using namespace atcoder;

int main(){
    int t;
    cin >> t;
    while(t -- ){
        int m,n;
        cin >> m >> n;
        vector<vector<vi>> v(2010,vvi(2010));
        vector<int> sz(m);
        for(int i = 0; i < m; i++){
            int x1,y1,x2,y2;
            cin >> x1 >> y1 >> x2 >> y2;
            sz[i] = (x2-x1) * (y2-y1);
            for(int x = x1; x < x2; x++){
                for(int y = y1; y < y2; y++){
                    v[x][y].push_back(i);
                }
            }
        }
        vector<int> cnt(m);
        mf_graph<ll> g(m + n + 2);
        int s = m + n;
        int t = s + 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);
        for(int i = 0; i < n; i++){
            int x1,y1,x2,y2;
            cin >> x1 >> y1 >> x2 >> y2;
            set<int> S;
            for(int x = x1; x < x2; x++){
                for(int y = y1; y < y2; y++){
                    for(auto e: v[x][y]){
                        S.insert(e);
                        cnt[e]++;
                    }
                }
            }
            for(auto e: S){
                // cout << e << " " << i << " " << cnt[e] << " " << sz[e] << endl;
                if(sz[e] <= 2 * cnt[e]){
                    // cout << "!" << e << " " << i << endl;
                    g.add_edge(e, m + i, 1);
                }
                cnt[e] = 0;
            }
        }
        cout << g.flow(s, t) << endl;
    }
}