#include <bits/stdc++.h>
using namespace std;

using i32 = int;
using i64 = long long;
template <typename T>
using V = vector<T>;
template <typename T>
using VV = V<V<T>>;
template <typename T>
using VVV = V<VV<T>>;
template <typename T>
bool chmin(T &x, const T &y) {
    if (x > y) {
        x = y;
        return true;
    }
    return false;
}
template <typename T>
bool chmax(T &x, const T &y) {
    if (x < y) {
        x = y;
        return true;
    }
    return false;
}

#define ALL(x) begin(x), end(x)
#define LEN(x) (i32) size(x)
#define OVERRIDE4(a, b, c, d, ...) d
#define REP2(i, n) for (i32 i = 0; i < (i32)(n); ++i)
#define REP3(i, l, r) for (i32 i = (i32)(l); i < (i32)(r); ++i)
#define REP(...) OVERRIDE4(__VA_ARGS__, REP3, REP2)(__VA_ARGS__)
#define PER2(i, n) for (i32 i = (i32)(n)-1; i >= 0; --i)
#define PER3(i, l, r) for (i32 i = (i32)(r)-1; i >= (i32)(l); --i)
#define PER(...) OVERRIDE4(__VA_ARGS__, PER3, PER2)(__VA_ARGS__)

void dbg(i32 x) { cerr << x; }
void dbg(i64 x) { cerr << x; }
template <typename T, typename U>
void dbg(pair<T, U> p) {
    cerr << '(';
    dbg(p.first);
    cerr << ", ";
    dbg(p.second);
    cerr << ')';
}
template <typename T, typename U, typename V>
void dbg(tuple<T, U, V> p) {
    cerr << '(';
    dbg(get<0>(p));
    cerr << ", ";
    dbg(get<1>(p));
    cerr << ", ";
    dbg(get<2>(p));
    cerr << ')';
}
template <typename T>
void dbg(V<T> arr) {
    cerr << '[';
    REP(i, LEN(arr)) {
        if (i) {
            cerr << ", ";
        }
        dbg(arr[i]);
    }
    cerr << ']';
}
void debug() { cerr << '\n'; }
template <typename Head, typename... Tail>
void debug(Head head, Tail... tail) {
    dbg(head);
    cerr << ", ";
    debug(tail...);
}
#ifdef DEBUGF
#define DBG(...)                       \
    do {                               \
        cerr << #__VA_ARGS__ << " : "; \
        debug(__VA_ARGS__);            \
    } while (false)
#else
#define DBG(...) (void)0
#endif

class FenwickTree {
    i32 n;
    V<i32> dat;

public:
    FenwickTree(i32 n) : n(n), dat(n + 1, 0) {}
    void add(i32 idx, i32 v) {
        assert(0 <= idx && idx < n);
        ++idx;
        while (idx <= n) {
            dat[idx] += v;
            idx += idx & -idx;
        }
    }
    i32 sum(i32 k) const {
        assert(0 <= k && k <= n);
        i32 ret = 0;
        while (k > 0) {
            ret += dat[k];
            k -= k & -k;
        }
        return ret;
    }
};

#define y1 PCTprobability
#define y2 probabilityPCT

set<tuple<i32, i32, i32>> merge_lines(
    const V<pair<i32, pair<i32, i32>>> &lines) {
    map<i32, V<pair<i32, i32>>> mp;
    for (auto [x, p] : lines) {
        mp[x].push_back(p);
    }
    set<tuple<i32, i32, i32>> ret;
    for (auto &[x, v] : mp) {
        sort(ALL(v));
        V<pair<i32, i32>> rngs;
        for (auto [l, r] : v) {
            if (!rngs.empty() && rngs.back().second >= l) {
                chmax(rngs.back().second, r);
            } else {
                rngs.emplace_back(l, r);
            }
        }
        for (auto [l, r] : rngs) {
            ret.insert({x, r, l});
        }
    }
    return ret;
}

i64 count_crosspoints(const set<tuple<i32, i32, i32>> &xrl,
                      const set<tuple<i32, i32, i32>> &yrl) {
    V<i32> xs, ys;
    for (auto [x, r, l] : xrl) {
        REP(d, -1, 2) xs.push_back(x + d);
        REP(d, -1, 2) ys.push_back(r + d);
        REP(d, -1, 2) ys.push_back(l + d);
    }
    for (auto [y, r, l] : xrl) {
        ys.push_back(y);
        xs.push_back(r);
        xs.push_back(l);
    }
    sort(ALL(xs));
    xs.erase(unique(ALL(xs)), xs.end());
    sort(ALL(ys));
    ys.erase(unique(ALL(ys)), ys.end());
    i32 h = LEN(xs);
    i32 w = LEN(ys);
    VV<pair<i32, i32>> add(h + 1);
    VV<i32> plus(h + 1), minus(h + 1);
    for (auto [x, r, l] : xrl) {
        x = (i32)(lower_bound(ALL(xs), x) - begin(xs));
        l = (i32)(lower_bound(ALL(ys), l) - begin(ys));
        r = (i32)(lower_bound(ALL(ys), r) - begin(ys));
        add[x].emplace_back(l, r);
    }
    for (auto [y, r, l] : yrl) {
        y = (i32)(lower_bound(ALL(ys), y) - begin(ys));
        l = (i32)(lower_bound(ALL(xs), l) - begin(xs));
        r = (i32)(lower_bound(ALL(xs), r) - begin(xs));
        plus[r].push_back(y);
        minus[l].push_back(y);
    }
    FenwickTree fw(w + 1);
    i64 ans = 0;
    REP(i, h + 1) {
        for (i32 j : minus[i]) {
            ans -= fw.sum(j + 1);
        }
        for (i32 j : plus[i]) {
            ans += fw.sum(j + 1);
        }
        for (auto [l, r] : add[i]) {
            fw.add(l, 1);
            fw.add(r, -1);
        }
    }
    return ans;
}

int main() {
    cin.tie(nullptr);
    ios::sync_with_stdio(false);
    i32 testcase;
    cin >> testcase;
    i32 n, m, q;
    cin >> n >> m >> q;
    struct Op {
        i32 type, x1, y1, x2, y2;
    };
    V<Op> ops(q);
    for (Op &op : ops) {
        cin >> op.type >> op.x1 >> op.y1 >> op.x2 >> op.y2;
        --op.x1;
        --op.y1;
        if (op.type == 1) {
            --op.y2;
        }
        if (op.type == 2) {
            --op.x2;
        }
    }
    V<pair<i32, pair<i32, i32>>> t1, t2, t3;
    for (Op op : ops) {
        if (op.type == 1) {
            // y1 == y2
            t1.emplace_back(op.y1, pair<i32, i32>(op.x1, op.x2));
        } else if (op.type == 2) {
            // x1 == x2
            t2.emplace_back(op.x1, pair<i32, i32>(op.y1, op.y2));
        } else {
            t3.emplace_back(op.x1 - op.y1, pair<i32, i32>(op.x1, op.x2));
        }
    }
    set<tuple<i32, i32, i32>> yrl = merge_lines(t1);
    set<tuple<i32, i32, i32>> xrl = merge_lines(t2);
    set<tuple<i32, i32, i32>> xyrl = merge_lines(t3);

    i64 ans = 0;
    for (auto [y, r, l] : yrl) {
        ans += r - l;
    }
    DBG(ans);
    for (auto [x, r, l] : xrl) {
        ans += r - l;
    }
    DBG(ans);
    /*for (auto [x, r1, l1] : xrl) {
        for (auto [y, r2, l2] : yrl) {
            if (l2 <= x && x < r2 && l1 <= y && y < r1) {
                --ans;
            }
        }
    }*/
    ans -= count_crosspoints(xrl, yrl);
    DBG(ans);
    for (auto [xy, r, l] : xyrl) {
        ans += r - l;
    }
    DBG(ans);
    for (auto [xy, r_, l_] : xyrl) {
        i32 x1 = l_;
        i32 x2 = r_;
        i32 y1 = x1 - xy;
        i32 y2 = x2 - xy;
        for (auto [x, r, l] : xrl) {
            i32 y = y1 + (x - x1);
            if (l <= y && y < r && x1 <= x && x < x2) {
                --ans;
            }
        }
    }
    DBG(ans);
    for (auto [xy, r_, l_] : xyrl) {
        i32 x1 = l_;
        i32 x2 = r_;
        i32 y1 = x1 - xy;
        i32 y2 = x2 - xy;
        for (auto [y, r, l] : yrl) {
            i32 x = x1 + (y - y1);
            if (l <= x && x < r && y1 <= y && y < y2) {
                --ans;
                // if (x, y) is in xrl
                auto itr = xrl.lower_bound(tuple<i32, i32, i32>(x, y + 1, 0));
                if (itr != end(xrl) && get<0>(*itr) == x && get<2>(*itr) <= y) {
                    ++ans;
                }
            }
        }
    }
    DBG(ans);
    cout << ans << '\n';
}