#include <bits/stdc++.h>
using namespace std;
typedef long long ll;
typedef unsigned int ui;
typedef unsigned long long ull;
typedef pair<int, int> pi;
typedef pair<ll, ll> pll;
// using u128 = __uint128_t;
// using i128 = __int128;
const int mod = 1000000007;
const int N = 400005;
const int LOG = 20;
const int inf = 1e9;
const double eps = 1e-11;
void print(int x) {
    cout << x;
}

void print(pi x) {
    cout << "[" << x.first << ", " << x.second << "]";   
}

void print(array<int, 3> x) {
    cout << "[" << x[0] << ", " << x[1] << ", " << x[2] << "]";   
}

void print(array<int, 4> x) {
    cout << "[" << x[0] << ", " << x[1] << ", " << x[2] << ", " << x[3] << "]";   
}

template <class T>
void printa(vector<T> &a) {
    cout << "PRINTED:\n";
    int n = a.size();
    for (int i = 0; i < n; i++) {
        cout << "i: " << i << " ";
        print(a[i]);
        cout << "\n";
    }
    
    cout << "\n";
}

vector<array<int, 3>> mergelines(map<int, vector<pi>> t, bool ty) {
    vector<array<int, 3>> res;
    for (auto [x, v] : t) {
        int l = -1, r = -1;
        sort(v.begin(), v.end());
        for (auto [lx, rx] : v) {
            if (l == -1) l = lx, r = rx;
            else if (lx - r > 1) {
                res.push_back({l, r, (ty ? l - x : x)});
                l = lx, r = rx;
            }
            
            else r = max(r, rx);
        }
        
        if (l != -1) {
            res.push_back({l, r, (ty ? l - x : x)});
        }
    }
    
    return res;
}

int t[N * 4];
void update(int p, int x, int v = 1, int tl = 0, int tr = N - 1) {
    if (tl == tr) {
        t[v] = x;
        return;
    }
    
    int mid = (tl + tr) / 2;
    if (p <= mid) update(p, x, v * 2, tl, mid);
    else update(p, x, v * 2 + 1, mid + 1, tr);
    t[v] = t[v * 2] + t[v * 2 + 1];
}

int query(int ql, int qr, int v = 1, int tl = 0, int tr = N - 1) {
    if (tl > qr || tr < ql) return 0;
    if (tl >= ql && tr <= qr) return t[v];
    int mid = (tl + tr) / 2;
    int left = query(ql, qr, v * 2, tl, mid);
    int right = query(ql, qr, v * 2 + 1, mid + 1, tr);
    return left + right;
}

int n, m, k, qq;
void solve() {
    cin >> n >> m >> qq;
    map<int, vector<pi>> trows, tcols, tdiags;
    ll out = 0;
    for (int i = 0; i < qq; i++) {
        int t, x1, y1, x2, y2;
        cin >> t >> x1 >> y1 >> x2 >> y2;
        if (t == 1) {
            trows[y1].push_back({x1, x2});
        }
        
        if (t == 2) {
            tcols[x1].push_back({y1, y2});
        }
        
        if (t == 3) {
            tdiags[x1 - y1].push_back({x1, x2});
        }
    }
    
    vector<array<int, 3>> rows = mergelines(trows, 0),
    cols = mergelines(tcols, 0), diags = mergelines(tdiags, 1);
    int nr = rows.size(), nc = cols.size(), nd = diags.size();
    vector<pi> cand;
    vector<array<int, 4>> sweep;
    vector<int> comp;
    for (int i = 0; i < nr; i++) {
        auto [l, r, y] = rows[i];
        out += r - l + 1;
        sweep.push_back({y, 2, l, r});
        comp.push_back(l);
        comp.push_back(l + 1);
        comp.push_back(r);
        comp.push_back(r + 1);
        for (int j = 0; j < nd; j++) {
            auto [xd, x2, yd] = diags[j];
            int diff = y - yd, lend = x2 - xd;
            if (y < yd || y > yd + lend) continue;
            if (xd + diff < l || xd + diff > r) continue;
            out--;
            cand.push_back({xd + diff, y});
        }
    }
    
    map<int, vector<pi>> ttcols;
    for (int i = 0; i < nc; i++) {
        auto [l, r, x] = cols[i];
        out += r - l + 1;
        sweep.push_back({l, 1, x, -1});
        sweep.push_back({r + 1, 0, x, -1});
        comp.push_back(x);
        comp.push_back(x + 1);
        ttcols[x].push_back({l, r});
        for (int j = 0; j < nd; j++) {
            auto [xd, x2, yd] = diags[j];
            int diff = x - xd, lend = x2 - xd;
            if (x < xd || x > xd + lend) continue;
            if (yd + diff < l || yd + diff > r) continue;
            out--;
        }
    }
    
    for (int i = 0; i < nd; i++) {
        auto [l, r, y] = diags[i];
        out += r - l + 1;
    }
    
    for (auto [x, y] : cand) {
        if (ttcols[x].empty()) continue;
        auto it = upper_bound(ttcols[x].begin(), ttcols[x].end(), make_pair(y, inf));
        if (it == ttcols[x].begin()) continue;
        it--;
        auto [l, r] = *it;
        if (y >= l && y <= r) out++;
    }
    
    sort(comp.begin(), comp.end());
    int sz = comp.size();
    map<int, int> id;
    int cur = 0;
    for (int i = 1; i < sz; i++) {
        if (comp[i] == comp[i - 1]) continue;
        id[comp[i - 1]] = cur++;
    }
    
    sort(sweep.begin(), sweep.end());
    for (auto [y, t, l, r] : sweep) {
        if (t == 2) {
            out -= query(id[l], id[r]);
        }
        
        else {
            update(id[l], t);
        }
    }
    
    cout << out << "\n";
}

int32_t main() {
    std::ios::sync_with_stdio(false);
    cin.tie(NULL);
    int c;
    cin >> c;
    solve();
}