#include <bits/stdc++.h>

#define lsb(x) (x & (-x))

using ull = unsigned long long;
using ll = long long;

using namespace std;

struct DSU {
    DSU(int n) {
        par.resize(n + 1);
        cntJoin = 0;
    }

    int root(int x) {
        return par[x] == 0 ? x : par[x] = root(par[x]);
    }

    void join(int x, int y) {
        x = root(x), y = root(y);
        if (x != y) {
            cntJoin++;
            par[x] = y;
        }
    }

    vector<int> par;
    int cntJoin;
};

struct Line {
    int r1, c1, r2, c2;
    int id;

    bool isV() {
        return c1 == c2;
    }

    bool isH() {
        return r1 == r2;
    }

    bool operator<(const Line& rhs) const {
        return r1 < rhs.r1;    
    }
};

struct SegLine {
    Line l;

    SegLine(Line l) {
        this->l = l;
    }
    
    bool operator<(const SegLine& rhs) const {
        return l.c1 < rhs.l.c1;
    }
};

int main() {
#ifdef HOME
    ifstream cin("input.in");
    ofstream cout("output.out");
#endif
    ios::sync_with_stdio(false);
    cin.tie(0), cout.tie(0);

    int T;
    cin >> T;
    while (T--) {
        int n, m, k;
        cin >> n >> m >> k;

        vector<Line> lines;
        for (int i = 1; i <= k; i++) {
            int r1, c1, r2, c2;
            cin >> r1 >> c1 >> r2 >> c2;
            lines.push_back({r1, c1, r2, c2, i});
        }
        sort(lines.begin(), lines.end());

        DSU dsu(k + 1);

        set<SegLine> vLines;

        auto cmp = [](const SegLine& s1, const SegLine& s2) {
            if (s1.l.r2 == s2.l.r2) {
                return s1.l.id < s2.l.id;
            }
            return s1.l.r2 < s2.l.r2;
        };
        set<SegLine, decltype(cmp)> vLinesExp{cmp}; 

        set<SegLine> prevLines;

        long long answerSize = 0;

        int pos = 0;
        for (int row = 1; row <= n; row++) {
            while (vLinesExp.size()) {
                Line l = (*vLinesExp.begin()).l;
                if (l.r2 == row - 1) {
                    vLines.erase(SegLine(l));
                    vLinesExp.erase(vLinesExp.begin());
                    prevLines.insert(SegLine(l));
                } else {
                    break;
                }
            }

            int i = pos;
            while (i < k && lines[i].r1 == row) {
                Line l = lines[i];
                if (l.isH()) {
                    answerSize += l.c2 - l.c1 + 1;
                }

                auto itr = prevLines.upper_bound(SegLine(l));
                if (itr != prevLines.begin()) {
                    itr = prev(itr);
                }
                while (itr != prevLines.end() && itr->l.c1 <= l.c2) {
                    if (max(itr->l.c1, l.c1) <= min(itr->l.c2, l.c2)) {
                        dsu.join(l.id, itr->l.id);
                    }
                    itr = next(itr);
                }

                i++;
            }

            
            {
                i = pos;
                while (i < k && lines[i].r1 == row) {
                    Line l = lines[i];

                    auto itr = vLines.upper_bound(SegLine(l));
                    if (itr != vLines.end() && itr->l.c1 == l.c2 + 1) {
                        dsu.join(l.id, itr->l.id);
                    }

                    if (itr != vLines.begin()) {
                        auto prv = prev(itr);
                        if (prv->l.c2 + 1 == l.c1) {
                            dsu.join(l.id, prv->l.id);
                        }
                    }

                    i++;
                }
            }

            prevLines.clear();

            i = pos;
            while (i < k && lines[i].r1 == row) {
                Line l = lines[i];
                if (l.isV() && l.r1 != l.r2) {
                    vLines.insert(SegLine(l));
                    vLinesExp.insert(SegLine(l));
                }
                prevLines.insert(SegLine(l));
                i++;
            }

            {
                auto itr = prevLines.begin();
                while (itr != prevLines.end() && next(itr) != prevLines.end()) {
                    auto nxt = next(itr);
                    Line l1 = itr->l;
                    Line l2 = nxt->l;
                    if (l1.c2 == l2.c1 - 1) {
                        dsu.join(l1.id, l2.id);
                    }
                    itr = nxt;
                }
            }

            answerSize += vLines.size();
            pos = i;

            cout << answerSize << " " << pos - dsu.cntJoin << "\n";
        }
    }

    return 0;
}