#include <bits/stdc++.h>
using i64 = long long;

constexpr int N = 2e5 + 10;
constexpr int Q = 1e5 + 10;
int c;
int n, m, q;
struct line {
	int type;
	int x1, y1, x2, y2;
	bool operator < (const line &b) {
		if (type != b.type) {
			return type < b.type;
		}
		if (type == 1) {
			if (y1 != b.y1)
				return y1 < b.y1;
			return x1 < b.x1;
		} else if (type == 2) {
			if (x1 != b.x1)
				return x1 < b.x1;
			return y1 < b.y1;
		} else {
			return x2 - x1 > b.x2 - b.x1;
		}
	}
} qry[Q];

// 离散化
int sx[N << 1], sy[N << 1], rn, rm;

inline int xval(int x) {
	return std::lower_bound(sx + 1, sx + 1 + rn, x) - sx;
}
inline int yval(int y) {
	return std::lower_bound(sy + 1, sy + 1 + rm, y) - sy;
}
std::vector<std::pair<int, int>> yadd[N << 1];

i64 tr[N << 1];
inline int lowbit(int x) {return x & -x;}
inline void add(int x, int k) {
	for (int i = x; i <= rn; i += lowbit(i))
		tr[i] += k;
}
inline i64 query(int x) {
	i64 ans = 0;
	for (int i = x; i > 0; i -= lowbit(i))
		ans += tr[i];
	return ans;
}

struct Chtholly {
	std::map<int, bool> mpx;
	void init(int x) {
		mpx[1] = false;
		mpx[x + 1] = false;
	}
	void split(int x) {
		auto it = std::prev(mpx.upper_bound(x));
		mpx[x] = it->second;
	}
	void cover(int l, int r) {
		split(l);
		split(r + 1);
		auto it = mpx.lower_bound(l);
		while (it->first != r + 1) {
			it = mpx.erase(it);
		}
		mpx[l] = true;
	}
	i64 answer() {
		i64 ans = 0;
		auto it = mpx.begin();
		while (it->first != rn + 1) {
			auto it2 = std::next(it);
			// 插入的时候按 xval 插入
			if (!it->second) {
				ans += query(it2->first - 1) - query(it->first - 1);
			} else {
				ans += sx[it2->first] - sx[it->first];
			}
			it = it2;
		}
		return ans;
	}
};

Chtholly Tree[N << 1];

int main() {
	std::ios::sync_with_stdio(false);
	std::cin.tie(nullptr);

	i64 ans = 0;
	std::cin >> c;
	std::cin >> n >> m >> q;
	for (int _ = 1; _ <= q; _++) {
		std::cin >> qry[_].type;
		std::cin >> qry[_].x1 >> qry[_].y1;
		std::cin >> qry[_].x2 >> qry[_].y2;
	}

	std::sort(qry + 1, qry + 1 + q);

	// 对于 2, 先按 x, y 排序, 合并线段
	for (int i = 1; i <= q; i++) {
		if (qry[i].type == 2) {
			int j = i + 1;
			// x 相同时按 y1 排序
			while (j <= q && qry[j].type == 2 && qry[i].x1 == qry[j].x1) {
				if (qry[j - 1].y2 >= qry[j].y1) {
					qry[j].y2 = std::max(qry[j].y2, qry[j - 1].y2);
					qry[j - 1].y2 = qry[j].y1 - 1;
				}
				j++;
			}
			j--;
			i = j;
		}
		if (qry[i].type == 1) {
			int j = i + 1;
			while (j <= q && qry[j].type == 1 && qry[i].y1 == qry[j].y1) {
				if (qry[j - 1].x2 >= qry[j].x1) {
					qry[j].x2 = std::max(qry[j].x2, qry[j - 1].x2);
					qry[j - 1].x2 = qry[j].x1 - 1;
				}
				j++;
			}
			j--;
			i = j;
		}
	}

	for (int _ = 1; _ <= q; _++) {
		sx[++rn] = qry[_].x1;
		sx[++rn] = qry[_].x2;
		sx[++rn] = qry[_].x1 - 1;
		sx[++rn] = qry[_].x2 + 1;
		sy[++rm] = qry[_].y1;
		sy[++rm] = qry[_].y2;
	}
	sx[++rn] = 0;
	sx[++rn] = 1, sx[++rn] = n + 1;
	sy[++rm] = 1, sy[++rm] = m;
	std::sort(sx + 1, sx + 1 + rn);
	std::sort(sy + 1, sy + 1 + rm);
	rn = std::unique(sx + 1, sx + 1 + rn) - sx - 1;
	rm = std::unique(sy + 1, sy + 1 + rm) - sy - 1;

	for (int i = 1; i <= rm; i++)
		Tree[i].init(rn);
	int pos = 1e9;
	for (int i = 1; i <= q; i++) {
		if (qry[i].type == 2) {
			if (qry[i].y1 <= qry[i].y2) {
				yadd[yval(qry[i].y1)].emplace_back(xval(qry[i].x1),  1);
				yadd[yval(qry[i].y2)].emplace_back(xval(qry[i].x1), -1);
			}
		} else if (qry[i].type == 1) {
			if (qry[i].x1 <= qry[i].x2)
				Tree[yval(qry[i].y1)].cover(xval(qry[i].x1), xval(qry[i].x2));			
		} else {
			if (pos == (int)1e9)
				pos = i;
		}
	}
	// 横竖线的答案
	for (int i = 1; i <= rm; i++) {
		ans += query(rn) * (sy[i] - 1 - sy[i - 1]);
		for (int j = 0; j < (int)yadd[i].size(); j++) {
			if (yadd[i][j].second == 1)
				add(yadd[i][j].first, 1);
		}
		ans += Tree[i].answer();
		for (int j = 0; j < (int)yadd[i].size(); j++) {
			if (yadd[i][j].second == -1)
				add(yadd[i][j].first, -1);
		}
	}

	for (int i = pos; i <= q; i++) {
		for (int j = i - 1; j >= pos; j--) {
			// 在同一条斜线上
			if (qry[j].x1 == -1)
				continue;
			if (qry[i].y1 - qry[j].y1 == qry[i].x1 - qry[j].x1) {
				// 在中间
				if ((qry[i].x1 >= qry[j].x1 && qry[i].x1 <= qry[j].x2) || (qry[i].x2 >= qry[j].x1 && qry[i].x2 <= qry[j].x2)) {
					qry[j].x2 = std::max(qry[i].x2, qry[j].x2);
					qry[j].y2 = std::max(qry[i].y2, qry[j].y2);
					qry[j].x1 = std::min(qry[i].x1, qry[j].x1);
					qry[j].y1 = std::min(qry[i].y1, qry[j].y1);
					qry[i].x1 = qry[i].x2 = -1;
					qry[i].y1 = qry[i].y2 = -1;
				}
			}
		}
	}
	for (int i = pos; i <= q; i++) {
		if (qry[i].x1 == -1)
			continue;
		ans += qry[i].x2 - qry[i].x1 + 1;

		std::vector<std::pair<int, int>> cross;
		for (int j = 1; j < pos; j++) {
			if (qry[j].type == 1) {
				int delta = qry[j].y1 - qry[i].y1;
				int x = qry[i].x1 + delta;
				int y = qry[j].y1;
				if (x < qry[i].x1 || x > qry[i].x2)
					continue;
				if (x < qry[j].x1 || x > qry[j].x2)
					continue;
				cross.emplace_back(x, y);
			} else if (qry[j].type == 2) {
				int delta = qry[j].x1 - qry[i].x1;
				int y = qry[i].y1 + delta;
				int x = qry[j].x1;
				if (y < qry[i].y1 || y > qry[i].y2)
					continue;
				if (y < qry[j].y1 || y > qry[j].y2)
					continue;
				cross.emplace_back(x, y);
			}
		}
		std::sort(cross.begin(), cross.end());
		cross.erase(std::unique(cross.begin(), cross.end()), cross.end());
		ans -= cross.size();
	}
	std::cout << ans << '\n';
	return 0;
}