#include <bits/stdc++.h>

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

struct horyzontal {
    int l, r, id;

    auto operator<=>(const horyzontal &) const = default;
};

struct vertical {
    int pos, add, id;

    auto operator<=>(const vertical &) const = default;
};

ll now = 0;

struct DSU {
    vector<int> pred, cnt;

    DSU(int n) : pred(n), cnt(n, 1) {
        iota(pred.begin(), pred.end(), 0);
    }

    int find(int x) { return (x == pred[x] ? x : pred[x] = find(pred[x])); }

    void unite(int x, int y) {
        x = find(x), y = find(y);
        if (x == y)return;
        if (cnt[x] > cnt[y])swap(x, y);
        pred[x] = y;
        cnt[y] += cnt[x];
        --now;
    }
};

void solve() {
    int n, m, k;
    cin >> n >> m >> k;
    vector<vector<horyzontal>> hor(n + 1);
    vector<vector<vertical>> vec(n + 1);
    for (int i = 0; i < k; ++i) {
        int r1, c1, r2, c2;
        cin >> r1 >> c1 >> r2 >> c2;
        --r1, --r2, --c1, --c2;
        if (r1 == r2) {
            hor[r1].push_back({c1, c2, i});
        } else {
            vec[r1].push_back({c1, 1, i});
            vec[r2 + 1].push_back({c1, -1, i});
        }
    }
    DSU dsu(k);
    now = 0;
    ll black = 0;
    set<pi> s;
    auto merge = [&](const vector<horyzontal> &from, const vector<pi> &to) {
        ll ptr = 0;
        for (auto [l, r, id]: from) {
            while (ptr < to.size() && to[ptr].first < l) {
                ++ptr;
            }
            while (ptr < to.size() && to[ptr].first >= l && to[ptr].first <= r) {
                dsu.unite(id, to[ptr++].second);
            }
        }
    };
    for (int i = 0; i < n; ++i) {
        sort(hor[i].begin(), hor[i].end());
        sort(vec[i].begin(), vec[i].end());
        now += hor[i].size();
        {
            for (auto [l, r, id]: hor[i]) {
                black += r - l + 1;
                auto it = s.lower_bound({l, -1});
                while (it != s.end() && it->first >= l && it->first <= r) {
                    dsu.unite(it->second, id);
                    ++it;
                }
            }
        }
        if (i - 1 >= 0) {
            vector<pi> top;
            for (auto [l, r, id]: hor[i - 1]) {
                top.emplace_back(l, id);
                top.emplace_back(r, id);
            }
            merge(hor[i], top);
        }
        if (i - 1 >= 0) {
            vector<pi> top;
            for (auto [l, r, id]: hor[i]) {
                top.emplace_back(l, id);
                top.emplace_back(r, id);
            }
            merge(hor[i - 1], top);
        }
        vector<pi> top;
        for (auto [pos, add, id]: vec[i]) {
            if (add == 1) {
                ++now;
                s.insert({pos, id});
                top.push_back({pos, id});
            } else {
                s.erase({pos, id});
            }
        }
        if (i - 1 >= 0)merge(hor[i - 1], top);
        {
            vector<pi> it;
            for (auto [l, r, id]: hor[i]) {
                it.push_back({l, id});
                it.push_back({r, id});
            };
            for (auto [pos, add, id]: vec[i]) {
                if (add == 1)it.push_back({pos, id});
            }
            sort(it.begin(), it.end());
            for (auto [l, r, id]: hor[i]) {
                {
                    auto zxc = lower_bound(it.begin(), it.end(), pi{r + 1, -1});
                    if (zxc != it.end() && zxc->first == r + 1)dsu.unite(id, zxc->second);
                }
                {
                    auto zxc = lower_bound(it.begin(), it.end(), pi{l - 1, -1});
                    if (zxc != it.end() && zxc->first == l - 1)dsu.unite(id, zxc->second);
                }
            }
            for (auto [pos, add, id]: vec[i]) {
                if (add == 1) {
                    auto zxc = lower_bound(it.begin(), it.end(), pi{pos + 1, -1});
                    if (zxc != it.end() && zxc->first == pos + 1)dsu.unite(id, zxc->second);
                };
            }
            for (auto [pos, id]: it) {
                {
                    auto zxc = s.lower_bound(pi{pos + 1, -1});
                    if (zxc != s.end() && zxc->first == pos + 1)dsu.unite(id, zxc->second);
                }
                {
                    auto zxc = s.lower_bound(pi{pos - 1, -1});
                    if (zxc != s.end() && zxc->first == pos - 1)dsu.unite(id, zxc->second);
                }
            }
        }
        black += s.size();
        cout << black << " " << now << "\n";
    }
}

int main() {
    cin.tie(0)->sync_with_stdio(false);
    int t;
    cin >> t;
    while (t--) {
        solve();
    }
}