#include <bits/stdc++.h>

using i64 = long long;
using u64 = unsigned long long;
using u32 = unsigned;
using u128 = unsigned __int128;

int main() {
    std::ios::sync_with_stdio(false);
    std::cin.tie(nullptr);
    
    int E;
    std::cin >> E;
    
    int N, Q;
    std::cin >> N >> Q;
    
    std::vector<int> siz(2 * N, 1), bel(N);
    std::iota(bel.begin(), bel.end(), 0);
    int curbel = N;
    
    std::vector<std::set<int>> adj(N);
    
    auto link = [&](int x, int y) {
        if (siz[bel[y]] > siz[bel[x]]) {
            std::swap(x, y);
        }
        siz[bel[x]] += siz[bel[y]];
        auto dfs = [&](auto &&self, int a, int p) -> void {
            bel[a] = bel[x];
            for (auto b : adj[a]) {
                if (b == p) {
                    continue;
                }
                self(self, b, a);
            }
        };
        dfs(dfs, y, -1);
        adj[x].insert(y);
        adj[y].insert(x);
    };
    
    auto cut = [&](int x, int y) -> void {
        adj[x].erase(y);
        adj[y].erase(x);
        std::vector<std::pair<int, std::set<int>::iterator>> sx, sy;
        sx.emplace_back(x, adj[x].begin());
        sy.emplace_back(y, adj[y].begin());
        
        std::vector<int> vx {x}, vy {y};
        while (!sx.empty() && !sy.empty()) {
            {
                auto &[a, it] = sx.back();
                if (it == adj[a].end()) {
                    sx.pop_back();
                } else {
                    int b = *(it++);
                    if (sx.size() == 1 || b != sx[sx.size() - 2].first) {
                        sx.emplace_back(b, adj[b].begin());
                        vx.push_back(x);
                    }
                }
            }
            {
                auto &[a, it] = sy.back();
                if (it == adj[a].end()) {
                    sy.pop_back();
                } else {
                    int b = *(it++);
                    if (sy.size() == 1 || b != sy[sy.size() - 2].first) {
                        sy.emplace_back(b, adj[b].begin());
                        vy.push_back(y);
                    }
                }
            }
        }
        
        if (sx.empty()) {
            siz[bel[y]] -= vx.size();
            for (auto i : vx) {
                bel[i] = curbel;
            }
            siz[curbel++] = vx.size();
        } else {
            siz[bel[x]] -= vy.size();
            for (auto i : vy) {
                bel[i] = curbel;
            }
            siz[curbel++] = vy.size();
        }
    };
    
    i64 cur = 0;
    i64 lst = 0;
    
    std::vector<i64> pre(Q + 1);
    std::vector<i64> val(Q + 1);
    
    for (int i = 1; i <= Q; i++) {
        int o;
        std::cin >> o;
        
        if (o == 1) {
            i64 x, y;
            std::cin >> x >> y;
            if (E) {
                x ^= lst;
                y ^= lst;
            }
            x--;
            y--;
            cur += 1LL * siz[bel[x]] * siz[bel[y]];
            link(x, y);
            
            val[i] = cur;
            pre[i] = pre[i - 1] + val[i] - std::min(val[i - 1], val[i]);
        } else if (o == 2) {
            i64 x, y;
            std::cin >> x >> y;
            if (E) {
                x ^= lst;
                y ^= lst;
            }
            x--;
            y--;
            cut(x, y);
            cur -= 1LL * siz[bel[x]] * siz[bel[y]];
            
            val[i] = cur;
            pre[i] = pre[i - 1] + val[i] - std::min(val[i - 1], val[i]);
        } else {
            i64 t;
            std::cin >> t;
            if (E) {
                t ^= lst;
            }
            
            val[i] = cur;
            pre[i] = pre[i - 1] + val[i] - std::min(val[i - 1], val[i]);
            
            lst = pre[i] - pre[i - t] + val[i - t];
            std::cout << lst << "\n";
        }
    }
    
    return 0;
}