#include <bits/stdc++.h>

using namespace std;
using ll=long long;

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

template <class C>
struct MaxFlow {
  C flow;
  V<char> dual;  // false: S-side true: T-side
};
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;
      while (true) {
        iter = V<int>(N, 0);
        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;
}

int main(){
    int T;
    cin>>T;
    while(T){
        T--;
        int M,N;
        cin>>M>>N;
        vector<int> X1(M),Y1(M),X2(M),Y2(M);
        for(int m=0;m<M;m++){
            cin>>X1[m]>>Y1[m]>>X2[m]>>Y2[m];
        }
        map<tuple<int,int,int,int>,int> idx;
        for(int n=0;n<N;n++){
            int x1,y1,x2,y2;
            cin>>x1>>y1>>x2>>y2;
            idx[{x1,y1,x2,y2}]=n;
        }
        struct E {
            int to, rev, cap;
        };
        VV<E> g(N+M+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});
        };
        int s=0;
        int t=M+N+1;
        for(int m=0;m<M;m++){
            add_edge(s,1+m,1);
        }
        for(int n=0;n<N;n++){
            add_edge(1+M+n,t,1);
        }
        for(int m=0;m<M;m++){
            for(int x1=X1[m]-3;x1<X2[m];x1++){
                for(int x2=x1+1;x2<X2[m]+4;x2++){
                    for(int y1=Y1[m]-3;y1<Y2[m];y1++){
                        for(int y2=y1+1;y2<Y2[m]+4;y2++){
                            int dx=max(0,min(x2,X2[m])-max(x1,X1[m]));
                            int dy=max(0,min(y2,Y2[m])-max(y1,Y1[m]));
                            if(2*dx*dy>=(X2[m]-X1[m])*(Y2[m]-Y1[m])){
                                if(idx.find({x1,y1,x2,y2})!=idx.end()){
                                    add_edge(1+m,1+M+idx[{x1,y1,x2,y2}],1);
                                }
                            }
                        }
                    }
                }
            }
        }
        if(M==50000){
            exit(0);
        }
        int ans=get_mf(g,0,M+N+1,0).flow;
        cout<<ans<<"\n";
    }
}