#include <bits/stdc++.h>

using namespace std;

typedef long long ll;
typedef pair<int, int> pii;

void mcin() {}

template<typename T, typename ...Tail>
void mcin(T &&arg, Tail &&...args) {
    cin >> arg;
    mcin(args...);
}
#define in(type, ...) type __VA_ARGS__; mcin(__VA_ARGS__);

template<typename T1, typename T2>
istream &operator>>(istream &in, pair<T1, T2> &p) {
    return in >> p.first >> p.second;
}

template<typename T>
istream &operator>>(istream &in, vector<T> &v) {
    for (auto &item: v)
        in >> item;
    return in;
}

#define all(c) c.begin(), c.end()

struct dsu {

    dsu(int n) : p(n), rk(n, 0), sz(n, 0), sign(n, -1) {
        iota(all(p), 0);
    }

    int player(int v) {
        return sign[root(v)];
    }

    void create(int v, int player) {
        sz[v] = 1;
        sign[v] = player;
    }

    int size(int v) {
        return sz[root(v)];
    }

    int merge(int u, int v) {
        u = root(u), v = root(v);
        if (rk[u] < rk[v]) swap(u, v);
        p[v] = u;
        sz[u] += sz[v];
        if (rk[u] == rk[v]) rk[u]++;
        return u;
    }

private:

    vector<int> p, rk;
    vector<int> sz, sign;

    int root(int v) {
        if (p[v] == v) return v;
        return p[v] = root(p[v]);
    }

};

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

    in(int, a, b, c, m, p)
    int d1 = b * c, d2 = c;

    auto conv = [&](int i, int j, int k) {
        return i * d1 + j * d2 + k;
    };
    auto ok = [&](int i, int j, int k) {
        return i >= 0 && i < a &&
               j >= 0 && j < b &&
               k >= 0 && k < c;
    };

    int n = a * b * c;
    map<tuple<int, int, int>, dsu> board;
    for (int i = -1; i <= 1; i++) {
        for (int j = -1; j <= 1; j++) {
            for (int k = -1; k <= 1; k++) {
                if (i == 0 && j == 0 && k == 0) continue;
                auto idx = make_tuple(-i, -j, -k);
                if (board.count(idx)) continue;
                board.insert({idx, dsu(n)});
            }
        }
    }

    vector<multiset<int>> res(p);
    for (int q = 0; q < m; q++) {
        in(int, player, x, y, z)
        int cell = conv(--x, --y, --z);
        auto &stat = res[--player];

        for (auto &info: board) {
            int i = get<0>(info.first), j = get<1>(info.first), k = get<2>(info.first);
            auto &dir = info.second;

            dir.create(cell, player);
            stat.insert(1);

            for (int d = -1; d <= 1; d += 2) {
                if (!ok(x + d * i, y + d * j, z + d * k)) continue;
                int nbr = conv(x + d * i, y + d * j, z + d * k);
                if (dir.player(nbr) == player) {
                    stat.erase(stat.find(dir.size(cell)));
                    stat.erase(stat.find(dir.size(nbr)));
                    stat.insert(dir.size(dir.merge(cell, nbr)));
                }
            }
        }
        cout << *stat.rbegin() << '\n';
    }

}