#pragma GCC optimize("Ofast,no-stack-protector")
#pragma GCC optimize("unroll-loops")
#pragma GCC optimize("fast-math")
#include <bits/stdc++.h>
#pragma GCC target("sse,sse2,sse3,ssse3,sse4,popcnt,abm,mmx,avx,avx2")

using namespace std;

mt19937 rnd(57);

struct Node {
    int u, v;
    int y;
    Node *l, *r, *pr;
    int sz, sz_ans;

    Node(int _u, int _v) {
        u = _u, v = _v;
        y = rnd();
        l = r = pr = nullptr;
        sz = 1;
        if (u == v) {
            sz_ans = 1;
        } else {
            sz_ans = 0;
        }
    }
};

int sz(Node *root) {
    if (root == nullptr) {
        return 0;
    }
    return root->sz;
}

int sz_ans(Node *root) {
    if (root == nullptr) {
        return 0;
    }
    return root->sz_ans;
}

void relax(Node *root) {
    root->sz = sz(root->l) + sz(root->r) + 1;
    root->sz_ans = sz_ans(root->l) + sz_ans(root->r);
    if (root->u == root->v) {
        root->sz_ans++;
    }
    if (root->l) {
        root->l->pr = root;
    }
    if (root->r) {
        root->r->pr = root;
    }
}

pair<Node *, int> get_root(Node *nw) {
    int ans = sz(nw->l);
    Node *prv = nw;
    nw = nw->pr;
    while (nw != nullptr) {
        if (prv == nw->r) {
            ans += sz(nw->l) + 1;
        }
        prv = nw;
        nw = nw->pr;
    }
    return make_pair(prv, ans);
}

Node *merge(Node *root1, Node *root2) {
    if (root1 == nullptr) {
        return root2;
    }
    if (root2 == nullptr) {
        return root1;
    }
    if (root1->y > root2->y) {
        root1->r = merge(root1->r, root2);
        relax(root1);
        return root1;
    } else {
        root2->l = merge(root1, root2->l);
        relax(root2);
        return root2;
    }
}

pair<Node *, Node *> split_sz(Node *root, int sz_l) {
    if (root == nullptr) {
        return make_pair(nullptr, nullptr);
    }
    if (sz(root->l) >= sz_l) {
        auto [res1, res2] = split_sz(root->l, sz_l);
        root->l = res2;
        relax(root);
        root->pr = nullptr;
        return make_pair(res1, root);
    } else {
        auto [res1, res2] = split_sz(root->r, sz_l - sz(root->l) - 1);
        root->r = res1;
        relax(root);
        root->pr = nullptr;
        return make_pair(root, res2);
    }
}

struct ETT {
    struct cmp {
        size_t operator()(std::pair<int, int> p) const {
            return p.first + (uint64_t(p.second) << 32);
        }
    };
    unordered_map<pair<int, int>, Node *, cmp> edges;

    ETT(int n) {
        for (int i = 0; i < n; ++i) {
            edges[make_pair(i, i)] = new Node(i, i);
        }
    }

    void add_edge(int u, int v) {
        auto [root_u, pos_u] = get_root(edges[make_pair(u, u)]);
        auto [res1_u, res2_u] = split_sz(root_u, pos_u);
        root_u = merge(res2_u, res1_u);
        auto [root_v, pos_v] = get_root(edges[make_pair(v, v)]);
        auto [res1_v, res2_v] = split_sz(root_v, pos_v);
        root_v = merge(res2_v, res1_v);
        edges[make_pair(u, v)] = new Node(u, v);
        edges[make_pair(v, u)] = new Node(v, u);
        merge(merge(root_u, edges[make_pair(u, v)]), merge(root_v, edges[make_pair(v, u)]));
    }

    void del_edge(int u, int v) {
        auto [root, pos_uv] = get_root(edges[make_pair(u, v)]);
        auto [res1, res2] = split_sz(root, pos_uv);
        root = merge(res2, res1);
        split_sz(root, 1);
        auto [_, pos_vu] = get_root(edges[make_pair(v, u)]);
        auto [res3, res4] = split_sz(_, pos_vu);
        split_sz(res4, 1);
    }

    int get_sz(int v) {
        return sz_ans(get_root(edges[make_pair(v, v)]).first);
    }
};

void solve() {
    int e;
    cin >> e;
    int n, q;
    cin >> n >> q;
    vector<long long> ans(q + 1);
    ETT forest(n);
    long long prv = 0;
    long long add = 0;
    for (int t = 0; t < q; ++t) {
        int tp;
        cin >> tp;
        if (tp == 1) {
            long long x, y;
            cin >> x >> y;
            x ^= prv, y ^= prv;
            x--, y--;
            ans[t + 1] = ans[t];
            add += forest.get_sz(x) * 1LL * forest.get_sz(y);
            forest.add_edge(x, y);
        } else if (tp == 2) {
            long long x, y;
            cin >> x >> y;
            x ^= prv, y ^= prv;
            x--, y--;
            forest.del_edge(x, y);
            ans[t + 1] = ans[t] - forest.get_sz(x) * 1LL * forest.get_sz(y);
        } else if (tp == 3) {
            ans[t + 1] = ans[t];
            long long tm;
            cin >> tm;
            tm ^= prv;
            long long ans_nw = ans[max(0LL, t - tm) + 1] + add;
            cout << ans_nw << '\n';
            prv = ans_nw * e;
        }
    }
}

signed main() {
    ios_base::sync_with_stdio(false);
    cin.tie(nullptr);
    int t = 1;
    // cin >> t;
    while (t--) {
        solve();
    }
    return 0;
}