#include<bits/stdc++.h>

using namespace std;
using pi=pair<int,int>;

struct UnionFind {
  vector<int> data;
  UnionFind(int size) : data(size, -1) { }
  bool unionSet(int x, int y) {
    x = root(x); y = root(y);
    if (x != y) {
      if (data[y] < data[x]) swap(x, y);
      data[x] += data[y]; data[y] = x;
    }
    return x != y;
  }
  bool findSet(int x, int y) {
    return root(x) == root(y);
  }
  int root(int x) {
    return data[x] < 0 ? x : data[x] = root(data[x]);
  }
  int size(int x) {
    return -data[root(x)];
  }
};

int main(){
  ios::sync_with_stdio(false);
  cin.tie(nullptr);
  int t;
  cin >> t;
  while(t>0){
    t--;
    int n,m,k;
    cin >> n >> m >> k;
    vector<long long> rw(n+1,0);
    set<vector<int>> sh;
    set<vector<int>> sv;
    vector<int> p(k),q(k),r(k),s(k);

    vector<vector<int>> mem(n+1);
    for(int i=0;i<k;i++){
      int a,b,c,d;
      cin >> a >> b >> c >> d;
      a--;b--;c--;d--;
      p[i]=a;
      q[i]=b;
      r[i]=c;
      s[i]=d;
      if(a==c){
        rw[a]+=(d-b+1);
        rw[a+1]-=(d-b+1);
        sh.insert({a,b,c,d,i});
      }
      else{
        rw[a]++;
        rw[c+1]--;
        sv.insert({b,a,d,c,i});
      }
      mem[a].push_back(i);
    }

    vector<vector<int>> vh,vv;
    for(auto &nx : sh){vh.push_back(nx);}
    for(auto &nx : sv){vv.push_back(nx);}

    vector<vector<pair<int,int>>> unq(n+1);

    for(int i=1;i<vv.size();i++){
      // Vertical - Vertical :
      if(vv[i-1][2]==vv[i][0] && vv[i-1][3]+1==vv[i][1]){
        unq[vv[i][1]].push_back({vv[i-1][4],vv[i][4]});
      }
    }
    for(auto &tg : vv){
      // Vertical - Vertical ||
      auto it=sv.lower_bound({tg[0]+1,tg[1],-1,-1,-1});
      if(it!=sv.begin()){it--;}
      while(it!=sv.end()){
        vector<int> cur=(*it);
        if(cur[0]>tg[0]+1){break;}
        if(cur[0]<tg[0]+1){it++;continue;}
        if(tg[3]<cur[1]){break;}
        if(cur[3]<tg[1]){it++;continue;}
        int upmost=max(cur[1],tg[1]);
        unq[upmost].push_back({cur[4],tg[4]});
        it++;
      }

      // Vertical - Horizontal
      int x,y;
      x=tg[1]-1;
      y=tg[0];
      {
        auto it=sh.lower_bound({x,y+1,-1,-1,-1});
        if(it!=sh.begin()){it--;}
        if(it!=sh.end()){
          vector<int> cur=(*it);
          if(cur[0]==x && cur[1]<=y && y<=cur[3]){
            unq[tg[1]].push_back({cur[4],tg[4]});
          }
        }
      }

      x=tg[3]+1;
      y=tg[2];
      {
        auto it=sh.lower_bound({x,y+1,-1,-1,-1});
        if(it!=sh.begin()){it--;}
        if(it!=sh.end()){
          vector<int> cur=(*it);
          if(cur[0]==x && cur[1]<=y && y<=cur[3]){
            unq[tg[3]+1].push_back({cur[4],tg[4]});
          }
        }
      }
    }

    for(int i=1;i<vh.size();i++){
      // Horizontal - Horizontal --
      if(vh[i-1][2]==vh[i][0] && vh[i-1][3]+1==vh[i][1]){
        unq[vh[i][0]].push_back({vh[i-1][4],vh[i][4]});
      }
    }
    for(auto &tg : vh){
      // Horizontal - Horizontal =
      auto it=sh.lower_bound({tg[0]+1,tg[1],-1,-1,-1});
      if(it!=sh.begin()){it--;}
      while(it!=sh.end()){
        vector<int> cur=(*it);
        if(cur[0]>tg[0]+1){break;}
        if(cur[0]<tg[0]+1){it++;continue;}
        if(tg[3]<cur[1]){break;}
        if(cur[3]<tg[1]){it++;continue;}
        int upmost=max(cur[0],tg[0]);
        unq[upmost].push_back({cur[4],tg[4]});
        it++;
      }

      // Horizontal - Vertical
      int x,y;
      x=tg[1]-1;
      y=tg[0];
      {
        auto it=sv.lower_bound({x,y+1,-1,-1,-1});
        if(it!=sv.begin()){it--;}
        if(it!=sv.end()){
          vector<int> cur=(*it);
          if(cur[0]==x && cur[1]<=y && y<=cur[3]){
            unq[tg[0]].push_back({cur[4],tg[4]});
          }
        }
      }

      x=tg[3]+1;
      y=tg[2];
      {
        auto it=sv.lower_bound({x,y+1,-1,-1,-1});
        if(it!=sv.begin()){it--;}
        if(it!=sv.end()){
          vector<int> cur=(*it);
          if(cur[0]==x && cur[1]<=y && y<=cur[3]){
            unq[tg[0]].push_back({cur[4],tg[4]});
          }
        }
      }
    }

    long long r1=0;
    int r2=0;
    UnionFind uf(k);
    for(int i=0;i<n;i++){
      if(i){rw[i]+=rw[i-1];}
      r1+=rw[i];
      cout << r1 << " ";
      r2+=mem[i].size();
      for(auto &nx : unq[i]){
        if(!uf.findSet(nx.first,nx.second)){
          r2--;
          uf.unionSet(nx.first,nx.second);
        }
      }
      cout << r2 << "\n";
    }
  }
  return 0;
}