#include <cassert>
#include <cstdint>
#include <ios>
#include <iostream>
#include <numeric>
#include <set>
#include <utility>
#include <vector>

template <typename F>
class y_combinator {

private:

    F f;

public:

    explicit y_combinator(F&& f) : f(f) {}

    template <typename... Args>
    decltype(auto) operator()(Args&&... args) const {

        return f(*this, std::forward<Args>(args)...);

    }

};

template <typename F>
y_combinator(F) -> y_combinator<F>;

void solve() {

    bool e;
    std::int32_t n;
    std::int32_t q;

    std::cin >> e >> n >> q;

    std::vector<std::set<std::int32_t>> adj(n);
    std::vector<std::int32_t> comps(n);
    std::vector<std::set<std::int32_t>> grps(n);
    std::vector<std::int64_t> pfxs(q + 1);
    std::int64_t prv = 0;
    std::int64_t tot_pairs = 0;

    std::iota(std::begin(comps), std::end(comps), 0);

    for (std::int32_t i = 0; i < n; ++i) {
        grps[i].insert(i);
    }

    for (std::int32_t i = 0; i < q; ++i) {
        pfxs[i + 1] = pfxs[i];
        std::int32_t tp = 0;
        std::cin >> tp;
        if (tp == 1) {
            std::int64_t x;
            std::int64_t y;
            std::cin >> x >> y;
            if (e) {
                x ^= prv;
                y ^= prv;
            }
            --x;
            --y;
            adj[x].insert(y);
            adj[y].insert(x);
            x = comps[x];
            y = comps[y];
            const std::int64_t sz_1 = std::size(grps[x]);
            const std::int64_t sz_2 = std::size(grps[y]);
            tot_pairs += sz_1 * sz_2;
            if (sz_1 < sz_2) {
                std::swap(x, y);
            }
            for (auto z : grps[y]) {
                comps[z] = x;
            }
            grps[x].merge(grps[y]);
            assert(std::empty(grps[y]));
        } else if (tp == 2) {
            using grp_t = std::vector<std::int32_t>;
            std::int64_t x;
            std::int64_t y;
            std::cin >> x >> y;
            if (e) {
                x ^= prv;
                y ^= prv;
            }
            --x;
            --y;
            adj[x].erase(y);
            adj[y].erase(x);
            const auto dfs = y_combinator(
                [&](auto self, std::int32_t node, std::int32_t par, grp_t& grp) -> void {
                    grp.push_back(node);
                    for (auto x : adj[node]) {
                        if (x != par) {
                            self(x, node, grp);
                        }
                    }
                }
            );
            std::set<std::int32_t>& grp = grps[comps[x]];
            grp_t grp_1;
            grp_t grp_2;
            dfs(x, -1, grp_1);
            dfs(y, -1, grp_2);
            const std::int64_t sz_1 = std::size(grp_1);
            const std::int64_t sz_2 = std::size(grp_2);
            assert(sz_1 + sz_2 == std::int32_t(std::size(grp)));
            pfxs[i + 1] += sz_1 * sz_2;
            if (sz_1 < sz_2) {
                std::swap(grp_1, grp_2);
            }
            for (auto z : grp_2) {
                assert(grp.erase(z) == 1);
                comps[z] = std::size(grps);
            }
            grps.emplace_back(std::begin(grp_2), std::end(grp_2));
        } else {
            std::int64_t t;
            std::cin >> t;
            if (e) {
                t ^= prv;
            }
            prv = tot_pairs - pfxs[i - t];
            std::cout << prv << '\n';
        }
    }

}

int main() {

    std::cin.tie(nullptr);

    std::ios_base::sync_with_stdio(false);

    solve();

    return 0;

}