#include <bits/stdc++.h>

using namespace std;
using ll = long long;

struct DSU {
    vector<int> fa, sz;
    vector<pair<int, int>> upd;
    vector<int> stk;

    void init(int n) {
        fa.assign(n, 0);
        iota(fa.begin(), fa.end(), 0);
        sz.assign(n, 1);
        stk.clear(), upd.clear();
    }

    int find(int x) {
        while (x != fa[x]) {
            x = fa[x];
        }
        return x;
    }

    void unite(int a, int b) {
        stk.push_back(upd.size());
        a = find(a), b = find(b);
        if (a == b) {
            return;
        }
        if (sz[a] < sz[b]) {
            swap(a, b);
        }
        fa[b] = a;
        sz[a] += sz[b];
        upd.push_back({a, b});
    }

    void pop() {
        assert(!stk.empty());
        while (upd.size() > stk.back()) {
            auto [a, b] = upd.back();
            upd.pop_back();
            fa[b] = b;
            sz[a] -= sz[b];
        }
        stk.pop_back();
    }
};

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

    int E;
    cin >> E;

    int n, q;
    cin >> n >> q;

    if (E != 0) {
        vector<set<int>> adj(n);
        auto dfs = [&](auto self, int v, int par) -> int {
            int s = 1;
            for (int to: adj[v]) {
                if (to != par) {
                    s += self(self, to, v);
                }
            }
            return s;
        };

        ll q3 = 0;
        vector<ll> add(q + 1), after(q + 1);
        for (int i = 1; i <= q; ++i) {
            int type;
            cin >> type;
            after[i] = after[i - 1];
            if (type == 1) {
                ll x, y;
                cin >> x >> y;
                if (E) {
                    x ^= q3, y ^= q3;
                }
                --x, --y;
                int szx = dfs(dfs, x, -1);
                int szy = dfs(dfs, y, -1);
                after[i] += 1LL * szx * szy;
                add[i] = 1LL * szx * szy;
                adj[x].insert(y);
                adj[y].insert(x);
            } else if (type == 2) {
                ll x, y;
                cin >> x >> y;
                if (E) {
                    x ^= q3, y ^= q3;
                }
                --x, --y;
                adj[x].extract(y);
                adj[y].extract(x);
                int szx = dfs(dfs, x, -1);
                int szy = dfs(dfs, y, -1);
                after[i] -= 1LL * szx * szy;
            } else {
                ll t;
                cin >> t;
                if (E) {
                    t ^= q3;
                }
                ll sum = after[i - t];
                for (int k = i - t + 1; k <= i; ++k) {
                    sum += add[k];
                }
                cout << sum << '\n';
                q3 = sum;
            }
        }
    } else {
        map<pair<int, int>, int> mp; // last time
        int sz = 1 << __lg(q) + 1;
        vector<vector<pair<int, int>>> tree(sz * 2);
        vector<pair<int, int>> query(sz, {0, 0});
        vector<ll> add(q + 1), after(q + 1);
        DSU d;
        d.init(n + 1);
        auto rangeAdd = [&](int lx, int rx, auto f) {
            cout << f.first << " " << f.second << ": " << lx << "-" << rx << endl;
            for (lx += sz, rx += sz; lx < rx; lx >>= 1, rx >>= 1) {
                if (lx & 1) tree[lx++].push_back(f);
                if (rx & 1) tree[--rx].push_back(f);
            }
        };
        for (int i = 1; i <= q; ++i) {
            int type;
            cin >> type;
            after[i] = after[i - 1];
            if (type == 1) {
                ll x, y;
                cin >> x >> y;
                if (x < y) {
                    swap(x, y);
                }
                query[i] = {x, y};
                mp[{x, y}] = i;
            } else if (type == 2) {
                ll x, y;
                cin >> x >> y;
                if (x < y) {
                    swap(x, y);
                }
                query[i] = {-x, -y};
                int lx = mp[{x, y}] + 1;
                int rx = i;
                rangeAdd(lx, rx, pair<int, int>(x, y));
                mp.erase({x, y});
            } else {
                ll t;
                cin >> t;
                query[i] = {0, t};
            }
        }
        for (auto [u, v] : mp) {
            rangeAdd(v + 1, q + 1, u);
        }
        auto dfs = [&](auto self, int x) -> void {
            for (auto [u, v] : tree[x]) {
                d.unite(u, v);
            }
            if (x >= sz) {
                auto [i, j] = query[x - sz];
                if (i != 0) {
                    if (i < 0) {
                        i = -i, j = -j;
                        add[x - sz] = -1LL * d.sz[d.find(i)] * d.sz[d.find(j)];
                    } else {
                        add[x - sz] = 1LL * d.sz[d.find(i)] * d.sz[d.find(j)];
                    }
                }
            } else {
                self(self, x * 2);
                self(self, x * 2 + 1);
            }
            for (auto [u, v] : tree[x]) {
                d.pop();
            }
        };
        dfs(dfs, 1);
//        for (int i = 1; i <= q; ++i) {
//            cout << add[i] << " ";
//        }
//        cout << endl;
        for (int i = 1; i <= q; ++i) {
            after[i] = after[i - 1] + add[i];
            if (query[i].first == 0) {
                int t = query[i].second;
                ll sum = after[i - t];
                for (int k = i - t + 1; k <= i; ++k) {
                    sum += max(0LL, add[k]);
                }
                cout << sum << '\n';
            }
        }
        return 0;
    }
}