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

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::int32_t> pars(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]);
        } else if (tp == 2) {
            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);
            pars[x] = -1;
            pars[y] = -1;
            std::set<std::int32_t>& grp = grps[comps[x]];
            std::vector proc_1({std::int32_t(x)});
            std::vector proc_2({std::int32_t(y)});
            bool swp = false;
            std::int64_t sz_1 = 1;
            std::int64_t sz_2 = 1;
            if (!std::empty(adj[x]) && !std::empty(adj[y])) {
                using it_t = std::set<std::int32_t>::iterator;
                it_t it_1;
                it_t it_2;
                std::int32_t ptr_1 = -1;
                std::int32_t ptr_2 = -1;
                while (true) {
                    while (ptr_1 < sz_1) {
                        if (ptr_1 == -1 || it_1 == std::end(adj[proc_1[ptr_1]])) {
                            ++ptr_1;
                            if (ptr_1 < sz_1) {
                                it_1 = std::begin(adj[proc_1[ptr_1]]);
                            }
                            continue;
                        }
                        if (*it_1 != pars[proc_1[ptr_1]]) {
                            break;
                        }
                        ++it_1;
                    }
                    if (ptr_1 < sz_1) {
                        proc_1.push_back(*it_1);
                        pars[*it_1] = proc_1[ptr_1];
                        ++sz_1;
                    } else {
                        swp = true;
                        break;
                    }
                    while (ptr_2 < sz_2) {
                        if (ptr_2 == -1 || it_2 == std::end(adj[proc_2[ptr_2]])) {
                            ++ptr_2;
                            if (ptr_2 < sz_2) {
                                it_2 = std::begin(adj[proc_2[ptr_2]]);
                            }
                            continue;
                        }
                        if (*it_2 != pars[proc_2[ptr_2]]) {
                            break;
                        }
                        ++it_2;
                    }
                    if (ptr_2 < sz_2) {
                        proc_2.push_back(*it_2);
                        pars[*it_2] = proc_2[ptr_2];
                        ++sz_2;
                    } else {
                        break;
                    }
                }
            } else if (std::empty(adj[x])) {
                swp = true;
            }
            const std::int64_t sz = swp ? sz_1 : sz_2;
            pfxs[i + 1] += sz * (std::size(grp) - sz);
            if (swp) {
                std::swap(proc_1, proc_2);
            }
            for (auto z : proc_2) {
                grp.erase(z);
                comps[z] = std::size(grps);
            }
            grps.emplace_back(std::begin(proc_2), std::end(proc_2));
        } else {
            std::int64_t t;
            std::cin >> t;
            if (e) {
                t ^= prv;
            }
            prv = tot_pairs - pfxs[(i + 1) - t];
            std::cout << prv << '\n';
        }
    }

}

int main() {

    std::cin.tie(nullptr);

    std::ios_base::sync_with_stdio(false);

    solve();

    return 0;

}