#include <bits/stdc++.h>
using namespace std;

class dsu_rollback {
  vector<int> ps;  // parent or size
  vector<pair<int, int>> record;
  int ecnt = 0;  // number of edges added.

 public:
  dsu_rollback(int n) : ps(n, -1), record(n - 1) {}
  void clear() {
    fill(ps.begin(), ps.end(), -1);
    ecnt = 0;
  }
  int root(int u) const {
    while (ps[u] >= 0) u = ps[u];
    return u;
  }
  int size(int u) const { return -ps[root(u)]; }
  int edge_cnt() const { return ecnt; }
  bool merge(int u, int v) {
    u = root(u);
    v = root(v);
    if (u == v) return 0;
    if (ps[u] < ps[v]) swap(u, v);
    ps[v] += ps[u];
    record[ecnt++] = {u, ps[u]};
    ps[u] = v;
    return 1;
  }
  void rollback() {
    assert(ecnt > 0);
    auto [u, sz] = record[--ecnt];
    int v = ps[u];
    ps[u] = sz;
    ps[v] -= sz;
  }
  void rollback_to(int edge_cnt) {
    while (ecnt > edge_cnt) rollback();
  }
};

int main() {
  ios::sync_with_stdio(0);
  cin.tie(0);
  int n, m;
  cin >> n >> m;
  vector<int> u(m), v(m), d(m);
  auto comp = [&](int i, int j) { return d[i] > d[j]; };
  for (int i = 0; i < m; i++) {
    cin >> u[i] >> v[i] >> d[i];
    u[i]--;
    v[i]--;
  }
  vector<int> sorted_edges(m);
  iota(sorted_edges.begin(), sorted_edges.end(), 0);
  sort(sorted_edges.begin(), sorted_edges.end(), comp);
  int q;
  cin >> q;
  vector<int> t(q), a(q), b(q), ans(q);
  auto comp2 = [&](int i, int j) { return b[i] > b[j]; };
  dsu_rollback dsu(n);
  vector<int> e(m);  //用于归并排序

  const int B = max(1., sqrt(log2(n) * m));

  vector<int> changed(m);
  vector<int> real_d(m);

  for (int i = 0; i < q;) {
    vector<int> queries;
    int beg = i;
    int end = min(q, i + B);

    for (; i < end; i++) {
      cin >> t[i] >> a[i] >> b[i];
      if (t[i] == 1) {
        a[i]--;
        changed[a[i]] = 1;
      } else {
        queries.push_back(i);
        a[i]--;
      }
    }

    vector<int> changed_edges, unchanged_edges;
    for (int eid: sorted_edges) // eid: edge id
      if (changed[eid])
        changed_edges.push_back(eid);
      else
        unchanged_edges.push_back(eid);

    sort(queries.begin(), queries.end(), comp2);

    auto it = unchanged_edges.begin();

    for (int id: queries) {
      for (; it != unchanged_edges.end() && d[*it] >= b[id]; it++) {
        dsu.merge(u[*it], v[*it]);
      }

      // 对于每条在当前块内被修改过的边，计算它在当前询问时的权值。
      // real_d[j]：第j条边在当前询问时的权值。
      for (int j: changed_edges)
        real_d[j] = d[j];

      for (int j = beg; j < id; j++) {
        if (t[j] == 1)
          real_d[a[j]] = b[j];
      }

      int edge_cnt = dsu.edge_cnt();
      for (int j: changed_edges)
        if (real_d[j] >= b[id]) dsu.merge(u[j], v[j]);

      ans[id] = dsu.size(a[id]);

      dsu.rollback_to(edge_cnt);
    }

    for (int j = beg; j < end; j++)
      if (t[j] == 1)
        d[a[j]] = b[j];

    sort(changed_edges.begin(), changed_edges.end(), comp);
    // 归并
    merge(unchanged_edges.begin(),
          unchanged_edges.end(),
          changed_edges.begin(),
          changed_edges.end(),
          sorted_edges.begin(),
          comp);

    dsu.clear();
    for (int j: changed_edges)
      changed[j] = 0;
  }

  for (int i = 0; i < q; i++) {
    if (t[i] == 2)
      cout << ans[i] << '\n';
  }
}