#include <bits/stdc++.h>
using namespace std;
const int64_t inf = 1e15;
class lazy_segtree {
struct node {
int64_t max_val, lazy;
node *l, *r;
node(int64_t k) : max_val(-k), lazy(0), l(nullptr), r(nullptr) {}
~node() {
delete l;
delete r;
}
};
node *t;
int64_t k;
int n;
void push(node *t) {
t->max_val += t->lazy;
t->l = t->l ? t->l : new node(k);
t->r = t->r ? t->r : new node(k);
t->l->lazy += t->lazy;
t->r->lazy += t->lazy;
t->lazy = 0;
}
void pull(node *t) {
t->max_val = max(t->l->max_val, t->r->max_val);
}
void add(node *t, int tl, int tr, int l, int r, int64_t del) {
push(t);
if (tr < l || r < tl || l > r) return;
if (l <= tl && tr <= r) {
t->lazy += del;
push(t);
return;
}
int tm = (tl + tr) / 2;
add(t->l, tl, tm, l, r, del);
add(t->r, tm + 1, tr, l, r, del);
pull(t);
}
int64_t query(node *t, int tl, int tr, int l, int r) {
push(t);
if (tr < l || r < tl || l > r) return -inf;
if (l <= tl && tr <= r) return t->max_val;
int tm = (tl + tr) / 2;
return max(query(t->l, tl, tm, l, r), query(t->r, tm + 1, tr, l, r));
}
public:
lazy_segtree(int n, int64_t k) : n(n), k(k), t(new node(k)) {}
~lazy_segtree() { delete t; }
void add(int l, int r, int64_t del) { add(t, 0, n - 1, l, r, del); }
int64_t query(int l, int r) { return query(t, 0, n - 1, l, r); }
};
class lazy_2dtree {
int64_t k;
int n, m;
vector<lazy_segtree *> trees;
public:
lazy_2dtree(int n, int m, int64_t k) : n(n), m(m), k(k), trees(n) {
for (int i = 0; i < n; ++i) {
trees[i] = new lazy_segtree(m, k);
}
}
~lazy_2dtree() {
for (auto &i : trees) { delete i; }
}
void add(int lx, int rx, int ly, int ry, int64_t del) {
for (int i = lx; i <= rx; ++i) {
trees[i]->add(ly, ry, del);
}
}
int64_t query(int lx, int rx, int ly, int ry) {
int64_t ans = -inf;
for (int i = lx; i <= rx; ++i) {
ans = max(ans, trees[i]->query(ly, ry));
}
return ans;
}
};
struct query {
int lx, rx, ly, ry, c;
};
int main() {
cin.tie(nullptr)->sync_with_stdio(false);
int n, m, q;
int64_t k;
cin >> n >> m >> q >> k;
swap(n, m);
vector<query> queries(q);
vector<int> buff_x, buff_y;
for (auto &[lx, rx, ly, ry, c] : queries) {
cin >> lx >> rx >> ly >> ry >> c;
swap(lx, ly), swap(rx, ry);
--lx, --ly, --rx, --ry;
buff_x.push_back(lx), buff_x.push_back(rx);
buff_y.push_back(ly), buff_y.push_back(ry);
}
sort(buff_x.begin(), buff_x.end());
sort(buff_y.begin(), buff_y.end());
buff_x.erase(unique(buff_x.begin(), buff_x.end()), buff_x.end());
buff_y.erase(unique(buff_y.begin(), buff_y.end()), buff_y.end());
auto comp_x = [&](int i) { return lower_bound(buff_x.begin(), buff_x.end(), i) - buff_x.begin(); };
auto comp_y = [&](int i) { return lower_bound(buff_y.begin(), buff_y.end(), i) - buff_y.begin(); };
n = buff_x.size(), m = buff_y.size();
int min_x = n, max_x = -1, min_y = m, max_y = -1;
for (auto &[lx, rx, ly, ry, c] : queries) {
lx = comp_x(lx), ly = comp_y(ly), rx = comp_x(rx), ry = comp_y(ry);
min_x = min(min_x, lx);
min_y = min(min_y, ly);
max_x = max(max_x, rx);
max_y = max(max_y, ry);
if (min_x > max_x || min_y > max_y) {
cout << "0\n";
} else {
cout << int64_t(buff_x[max_x] - buff_x[min_x] + 1) * (buff_y[max_y] - buff_y[min_y] + 1) << '\n';
}
}
}
