#include <bits/stdc++.h>

class ETT {
   private:
    using ind_t = int;
    struct Node {
        ind_t left, right, prev;
        uint32_t y;
        int sz;

        Node() : left(-1), right(-1), prev(-1), sz(1) {
            sizeof(Node);
            static std::mt19937 rnd;
            y = rnd();
        }
    };

    std::vector<Node> data;

    int get_sz(ind_t p) {
        return p != -1 ? data[p].sz : 0;
    }
    void upd_prv(ind_t p, ind_t prv) {
        if (p != -1) {
            data[p].prev = prv;
        }
    }
    void upd(ind_t p) {
        if (p != -1) {
            upd_prv(data[p].left, p);
            upd_prv(data[p].right, p);
            data[p].sz = 1 + get_sz(data[p].left) + get_sz(data[p].right);
        }
    }

    ind_t merge(ind_t a, ind_t b) {
        if (a == -1 || b == -1) {
            return a != -1 ? a : b;
        }
        if (data[a].y < data[b].y) {
            data[a].right = merge(data[a].right, b);
            return upd(a), a;
        } else {
            data[b].left = merge(a, data[b].left);
            return upd(b), b;
        }
    }

    ind_t merge(std::initializer_list<ind_t> list) {
        ind_t rt = -1;
        for (ind_t ptr : list) {
            rt = merge(rt, ptr);
        }
        return rt;
    }

    std::pair<ind_t, ind_t> split(ind_t p, int ind) {
        if (p == -1) {
            return {-1, -1};
        }
        if (get_sz(data[p].left) + 1 <= ind) {
            auto [a, b] = split(((data[p].right != -1 ? data[data[p].right].prev = -1 : 0), data[p].right), ind - (get_sz(data[p].left) + 1));
            data[p].right = a;
            upd(p);
            return {p, b};
        } else {
            auto [a, b] = split(((data[p].left != -1 ? data[data[p].left].prev = -1 : 0), data[p].left), ind);
            data[p].left = b;
            upd(p);
            return {a, p};
        }
    }

    template <int N>
    std::array<ind_t, N> split(ind_t p, std::array<int, N - 1> ar) {
        std::array<ind_t, N> res;
        for (int i = 0; i < N - 1; i++) {
            auto [a, b] = split(p, ar[i] - (i == 0 ? 0 : ar[i - 1]));
            res[i] = a;
            res[i + 1] = b;
            p = b;
        }
        return res;
    }

    std::pair<ind_t, int> ascend(ind_t p) {
        if (p == -1) {
            return {p, 0};
        }
        int ind = get_sz(data[p].left);
        while (data[p].prev != -1) {
            ind += (get_sz(data[data[p].prev].left) + 1) * (p == data[data[p].prev].right);
            p = data[p].prev;
        }
        return {p, ind};
    }

    std::vector<ind_t> vec;
    std::map<std::pair<int, int>, std::pair<ind_t, ind_t>> map;

   public:
    ETT() = default;
    ETT(int n) {
        data.assign(3 * n, Node());
        vec.resize(2 * n);
        for (int i = 0; i < 2 * n; i++) {
            vec[i] = n + i;
        }
    }

    std::pair<int, int> add_edge(int u, int v) {
        if (u > v) {
            std::swap(u, v);
        }
        ind_t rt1 = u, rt2 = v;
        ind_t uv = vec.rbegin()[0], vu = vec.rbegin()[1];
        vec.pop_back(), vec.pop_back();
        data[uv] = Node(), data[uv] = Node();
        map[{u, v}] = {uv, vu};

        auto [r1, ind1] = ascend(rt1);
        auto [r2, ind2] = ascend(rt2);

        int sz1 = get_sz(r1) / 3 + 1;
        int sz2 = get_sz(r2) / 3 + 1;

        auto [x1, y1] = split(r1, ind1);
        auto [x2, y2] = split(r2, ind2);

        auto rt = merge({x1, uv, y2, x2, vu, y1});
        return {sz1, sz2};
    }

    std::pair<int, int> cut_edge(int u, int v) {
        if (u > v) {
            std::swap(u, v);
        }
        auto [uv, vu] = map[{u, v}];
        map.erase({u, v});
        auto [rt, ind1] = ascend(uv);
        auto [__, ind2] = ascend(vu);

        if (ind1 > ind2) {
            std::swap(ind1, ind2);
        }
        auto [a, b, c, d, e] = split<5>(rt, {ind1, ind1 + 1, ind2, ind2 + 1});
        auto f = merge(a, e);
        vec.push_back(b);
        vec.push_back(d);

        int sz1 = get_sz(f) / 2 + 1;
        int sz2 = get_sz(c) / 2 + 1;
        return {sz1, sz2};
    }
};

int32_t main() {
    std::ios_base::sync_with_stdio(false);
    std::cin.tie(nullptr);

    int E;
    int n, q;
    std::cin >> E >> n >> q;

    int64_t all_dlt = 0, cur_sum = 0, last_ans = 0;
    std::vector<int64_t> ans = {0};
    ETT ett(n);

    for (int i = 0; i < q; i++) {
        int tp;
        std::cin >> tp;
        if (tp == 3) {
            int64_t t;
            std::cin >> t;
            if (E == 1) {
                t ^= last_ans;
            }

            ans.push_back(ans.back());
            last_ans = ans.rbegin()[t] + all_dlt;
            std::cout << ans.rbegin()[t] + all_dlt << "\n";
        } else {
            int64_t u, v;
            std::cin >> u >> v;
            if (E == 1) {
                u ^= last_ans;
                v ^= last_ans;
            }
            u--;
            v--;

            if (u > v) {
                std::swap(u, v);
            }

            if (tp == 1) {
                auto [sz1, sz2] = ett.add_edge(u, v);
                int64_t dlt = int64_t(sz1) * sz2;
                ans.push_back(ans.back());
                cur_sum += dlt;

                all_dlt += dlt;
            } else {
                auto [sz1, sz2] = ett.cut_edge(u, v);
                int64_t dlt = int64_t(sz1) * sz2;
                cur_sum -= dlt;
                ans.push_back({cur_sum - all_dlt});
            }
        }
    }

    return 0;
}