#pragma GCC optimize("O3,unroll-loops")
#pragma GCC target("avx2,bmi,bmi2,lzcnt,popcnt")
#include <bits/stdc++.h>
#include <ext/pb_ds/assoc_container.hpp>
#include <ext/pb_ds/tree_policy.hpp> 
#include <ext/pb_ds/detail/standard_policies.hpp>
using namespace __gnu_pbds;
using namespace std;
#define getbit(n, i) (((n) & (1LL << (i))) != 0) 
#define setbit0(n, i) ((n) & (~(1LL << (i)))) 
#define setbit1(n, i) ((n) | (1LL << (i))) 
#define togglebit(n, i) ((n) ^ (1LL << (i))) 
#define lastone(n) ((n) & (-(n))) 
char gap = 32;
#define int long long
#define ll long long 
#define lll __int128_t
#define pb push_back
// #define double long double
#define pii pair<int,int>
typedef tree<
int,
null_type,
less<int>,
rb_tree_tag,
tree_order_statistics_node_update>
ordered_set;
mt19937 rng(chrono::steady_clock::now().time_since_epoch().count());
ll hashPrime = 1610612741;
typedef pair<double, double> pdd;
const double EPS = 1e-12;
const long long flow_inf = 1e18;
struct FlowEdge {
  int v,u,id; long long cap, flow = 0;
  FlowEdge(int v, int u, long long cap,int id=-1) : v(v), u(u), cap(cap),id(id) {}
};
struct Dinic
{
  vector<FlowEdge> edges; vector<vector<int> > adj;
  int n, m = 0; int s, t;
  vector<int> level, ptr,flow_through;
  queue<int> q; vector<bool>vis;
  int maxid=0;
  Dinic() {}
  Dinic(int n) : n(n) {
    vis.resize(n); adj.resize(n);
    level.resize(n); ptr.resize(n);
  }
  void add_edge(int v, int u, long long cap,int id=-1) {
    edges.emplace_back(v, u, cap,id);
    edges.emplace_back(u, v, 0);
    adj[v].push_back(m);
    adj[u].push_back(m + 1);
    m += 2;
    if(id!=-1)maxid++;
  }
  void dfs2(int s) {
    vis[s] = 1;
    for(int i:adj[s]) {
      int id = i; int u = edges[id].v;
      int v = edges[id].u;
      if(edges[id].flow!=edges[id].cap && !vis[v])
      {
        dfs2(v);
      }
    }
  }
  vector<int> getMinCut() {
    dfs2(s); vector<int>ret;
    for(int i=0; i<n; i++) {
      if(vis[i]) ret.push_back(i);
    }
    return ret;
  }
  bool bfs() {
    while (!q.empty()) {
      int v = q.front();
      q.pop();
      for (int id : adj[v])
      {
        if (edges[id].cap - edges[id].flow < 1)
          continue;
        if (level[edges[id].u] != -1)
          continue;
        level[edges[id].u] = level[v] + 1;
        q.push(edges[id].u);
      }
    }
    return level[t] != -1;
  }
  long long dfs(int v, long long pushed) {
    if (pushed == 0) return 0;
    if (v == t) return pushed;
    for (int& cid = ptr[v]; cid < (int)adj[v].size(); cid++){
      int id = adj[v][cid]; int u = edges[id].u;
      if (level[v] + 1 != level[u] || edges[id].cap - edges[id].flow < 1)
        continue;
      long long tr = dfs(u, min(pushed, edges[id].cap - edges[id].flow));
      if (tr == 0)
        continue;
      edges[id].flow += tr; edges[id ^ 1].flow -= tr;
      return tr;
    }
    return 0;
  }
  long long flow(int _s,int _t) {
    s=_s; t=_t;
    long long f = 0;
    while (true)
    {
      fill(level.begin(), level.end(), -1);
      level[s] = 0; q.push(s);
      if (!bfs()) break;
      fill(ptr.begin(), ptr.end(), 0);
      while (long long pushed = dfs(s, flow_inf)){
        f += pushed;
      }
    }
    flow_through.assign(maxid+1, 0);
    for(int i = 0; i < n; i++){
      for(auto j : adj[i]) {
        int idx = j;
        FlowEdge e = edges[idx];
        if(e.id >= 0)flow_through[e.id] = e.flow;
      }
    }
    return f;
  }
};

void solve() {
    int m, n; cin >> m >> n;

    vector<vector<map<pii, int>>> s(2001, vector<map<pii, int>>(2001)); 
    vector<pair<pii, pii>> g, d; 
    for(int i = 1; i <= m; i++) {
        int x1, y1, x2, y2;
        cin >> x1 >> y1 >> x2 >> y2;
        g.pb({{x1, y1}, {x2, y2}});
    }  
    int cnt = 1;
    map<vector<int>, int> mp1;
    for(int i = 1; i <= n; i++) {

        int x1, y1, x2, y2;
        cin >> x1 >> y1 >> x2 >> y2;
        s[x1][y1][{x2, y2}]++;
        if(mp1.find({x1, y1, x2, y2}) == mp1.end()) {
            mp1[{x1, y1, x2, y2}] = cnt++;
        }
    }
    Dinic dinic(m + cnt + 2);
    for(int i = 0; i < m; i++) {
        pair<int, int> tl = g[i].first;
        pair<int, int> br = g[i].second;
        int area = (br.first - tl.first) * (br.second - tl.second);

        dinic.add_edge(0, i + 1, 1);
        
        for(int j = max(0LL, tl.first - 4); j <= min(2000LL, br.first + 4); j++) {
            for(int k = max(0LL, tl.second - 4); k <= min(2000LL, br.second + 4); k++) {
            
                for(auto ending: s[j][k]) {
                    int p = ending.first.first;
                    int q = ending.first.second;
                    int x1 = max(j, tl.first);
                    int y1 = max(k, tl.second);
                    int x2 = min(p, br.first);  
                    int y2 = min(q, br.second);
                    int area1 = (y2 - y1) * (x2 - x1);
                    if(2 * area1 >= area and y2 >= y1 and x2 >= x1) {
                        //cout << i + 1 << " " << m + mp1[{j, k, p, q}] << "\n";
                        dinic.add_edge(i + 1, m + mp1[{j, k, p, q}], 1);
                    }
                }
            }
        }
        // if(flag == 1) {
        //     cout << i << "\n";
        // }
    }
    for(auto x: mp1) {
        //cout << m + x.second << " " << m + cnt + 1 << " " << s[x.first[0]][x.first[1]][{x.first[2], x.first[3]}] << "\n";
        dinic.add_edge(m + x.second, m + cnt + 1, s[x.first[0]][x.first[1]][{x.first[2], x.first[3]}]);
    }
    //cout << "reached\n";
    cout << dinic.flow(0, m + cnt + 1) << "\n";
}
signed main(){

    // ios_base::sync_with_stdio(false);
    // cin.tie(0);
    // cout.tie(0);
    int tc;
    cin>>tc;
    while(tc--)
    solve();
    
    return 0;
}