#include <bits/stdc++.h>
using namespace std;
mt19937 rnd(chrono::high_resolution_clock::now().time_since_epoch().count());
mt19937_64 rnd64(
    chrono::high_resolution_clock::now().time_since_epoch().count());
long long power(long long a, long long m, long long mod) {
  long long ans = 1;
  while (m) {
    if (m % 2) ans *= a, ans %= (mod);
    a = (a * a) % mod;
    m >>= 1;
  }
  return ans;
}
struct custom_hash {
  static uint64_t splitmix64(uint64_t x) {
    x += 0x9e3779b97f4a7c15;
    x = (x ^ (x >> 30)) * 0xbf58476d1ce4e5b9;
    x = (x ^ (x >> 27)) * 0x94d049bb133111eb;
    return x ^ (x >> 31);
  }
  size_t operator()(uint64_t x) const {
    static const uint64_t FIXED_RANDOM =
        chrono::steady_clock::now().time_since_epoch().count();
    return splitmix64(x + FIXED_RANDOM);
  }
  size_t operator()(pair<int64_t, int64_t> Y) const {
    static const uint64_t FIXED_RANDOM =
        chrono::steady_clock::now().time_since_epoch().count();
    return splitmix64(Y.first * 31 + Y.second + FIXED_RANDOM);
  }
};
const long long inf = 1e18;
const long long M = 1000000007;
struct dsu_save {
  int v, rnkv, u, rnku;
  dsu_save() {}
  dsu_save(int _v, int _rnkv, int _u, int _rnku)
      : v(_v), rnkv(_rnkv), u(_u), rnku(_rnku) {}
};
struct dsu_with_rollbacks {
  vector<int> p, sz;
  stack<dsu_save> op;
  dsu_with_rollbacks() {}
  dsu_with_rollbacks(int n) {
    p.resize(n);
    sz.resize(n);
    for (int i = 0; i < n; i++) {
      p[i] = i;
      sz[i] = 1;
    }
  }
  int find_set(int v) { return (v == p[v]) ? v : find_set(p[v]); }
  bool unite(int v, int u) {
    v = find_set(v);
    u = find_set(u);
    if (v == u) return false;
    if (sz[v] > sz[u]) swap(v, u);
    op.push(dsu_save(v, sz[v], u, sz[u]));
    p[v] = u;
    sz[u] += sz[v];
    sz[v] = 0;
    return true;
  }
  void rollback() {
    if (op.empty()) return;
    dsu_save x = op.top();
    op.pop();
    p[x.v] = x.v;
    sz[x.v] = x.rnkv;
    p[x.u] = x.u;
    sz[x.u] = x.rnku;
  }
};
struct query {
  int v, u;
  bool united;
  query(int _v, int _u) : v(_v), u(_u) {}
};
vector<long long> which(500010, 0);
struct QueryTree {
  vector<vector<query>> t;
  dsu_with_rollbacks dsu;
  int T;
  QueryTree() {}
  QueryTree(int _T, int n) : T(_T) {
    dsu = dsu_with_rollbacks(n);
    t.resize(4 * T + 4);
  }
  void add_to_tree(int v, int l, int r, int ul, int ur, query& q) {
    if (ul > ur) return;
    if (l == ul && r == ur) {
      t[v].push_back(q);
      return;
    }
    int mid = (l + r) / 2;
    add_to_tree(2 * v, l, mid, ul, min(ur, mid), q);
    add_to_tree(2 * v + 1, mid + 1, r, max(ul, mid + 1), ur, q);
  }
  void add_query(query q, int l, int r) { add_to_tree(1, 0, T - 1, l, r, q); }
  void dfs(int v, int l, int r, vector<int>& ans) {
    for (query& q : t[v]) {
      q.united = dsu.unite(q.v, q.u);
    }
    if (l == r) {
      ans[l] = dsu.sz[dsu.find_set(which[l])];
    } else {
      int mid = (l + r) / 2;
      dfs(2 * v, l, mid, ans);
      dfs(2 * v + 1, mid + 1, r, ans);
    }
    for (query q : t[v]) {
      if (q.united) dsu.rollback();
    }
  }
  vector<int> solve() {
    vector<int> ans(T);
    dfs(1, 0, T - 1, ans);
    return ans;
  }
};
void solve() {
  long long i, j, _;
  long long n, q, k, x, y;
  cin >> n >> q >> k;
  QueryTree dsu(q + 2, n);
  list<pair<long long, pair<long long, long long>>> queue;
  long long now = 1, t = 1, day = 1;
  vector<long long> v;
  unordered_map<pair<long long, long long>, long long, custom_hash> mp, no;
  while (q--) {
    cin >> j;
    if (j == 1) {
      cin >> x >> y;
      if (x > y) swap(x, y);
      --x, --y;
      if (mp.find({x, y}) == mp.end()) mp[{x, y}] = t;
      queue.push_back({day, {x, y}});
      no[{x, y}]++;
    }
    if (j == 2) {
      cin >> x;
      --x;
      which[t] = x;
      v.push_back(t);
    }
    if (j == 3) {
      ++day;
      while (queue.front().first <= day - k) {
        auto it = mp.find(queue.front().second);
        queue.pop_front();
        long long x = (*it).first.first;
        long long y = (*it).first.second;
        no[{x, y}]--;
        if (no[{x, y}]) continue;
        no.erase({x, y});
        dsu.add_query(query(x, y), (*it).second, t - 1);
        mp.erase({x, y});
      }
    }
    ++t;
  }
  while (queue.size()) {
    auto it = mp.find(queue.front().second);
    queue.pop_front();
    long long x = (*it).first.first;
    long long y = (*it).first.second;
    no[{x, y}]--;
    if (no[{x, y}]) continue;
    no.erase({x, y});
    dsu.add_query(query(x, y), (*it).second, t - 1);
    mp.erase({x, y});
  }
  vector<int> ans = dsu.solve();
  for (auto i : v) cout << ans[i] << '\n';
}
int main() {
  ios::sync_with_stdio(0);
  cin.tie(0);
  long long T = 1;
  while (T--) {
    solve();
  }
  return 0;
}
