#include <bits/stdc++.h>
#define time() cerr << " \n " << "Time : " << 1000.0 * clock() / CLOCKS_PER_SEC << "ms."
#define FOR(i, a, b) for (int i = a, _b = b; i <= _b; ++i)
#define FORD(i, a, b) for (int i = a, _b = b; i >= _b; --i)
#define all(x) x.begin(), x.end()
#define uni(x) x.erase(unique(all(x)), x.end())
using namespace std;
typedef long long ll;
typedef unsigned long long ull;
typedef pair<int, int> pii;
typedef pair<ll, ll> pll;
#define dbg(...) cerr << "[ " << #__VA_ARGS__ << " ] = ", debug(__VA_ARGS__)
template<typename T> void debug(T x) { cerr << x << "\n\n"; }
template<typename T, typename... Args> void debug(T x, Args... args) { cerr << x << " , ", debug(args...); }
// --------------------------------------------------------------------------------------------------------------------
const int maxn = 5e4 + 3;
int n, m, q;
// --------------------------------------------------------------------------------------------------------------------
// Co the khong lien thong, co the co canh trung
struct Ed
{
int u, v, w, id;
Ed() {}
Ed(int u, int v, int w) : u(u), v(v), w(w) {}
bool operator < (const Ed &other) const
{
return w > other.w;
}
};
struct Qr
{
int op, x, y;
};
Ed Feds[100005];
vector<Ed> eds;
Qr qrs[100005];
int lst[100005], ID[100005];
multiset<Ed> tree[100005 << 2];
struct DSU
{
vector<int> e;
vector<pair<int &, int>> history;
void init() {e.assign(n + 3, -1);}
int get(int u) {return e[u] < 0 ? u : get(e[u]);}
bool unite(int u, int v)
{
u = get(u); v = get(v);
if (u == v) return false;
if (e[u] > e[v]) swap(u, v);
history.push_back({e[u], e[u]});
history.push_back({e[v], e[v]});
e[u] += e[v];
e[v] = u;
return true;
}
void rollback(int until)
{
while (history.size() > until)
{
history.back().first = history.back().second;
history.pop_back();
}
}
} dsu;
void updEd(int id, int l, int r, int u, int v, Ed ed)
{
if (l > v || r < u) return;
if (l >= u && r <= v) return void(tree[id].insert(ed));
int mid = l + r >> 1;
updEd(id << 1, l, mid, u, v, ed);
updEd(id << 1 | 1, mid + 1, r, u, v, ed);
}
void build(int id, int l, int r)
{
if (l == r) return void(ID[l] = id);
int mid = l + r >> 1;
build(id << 1, l, mid);
build(id << 1 | 1, mid + 1, r);
}
bool cmpE(const Ed &x, const Ed &y)
{
return x.w > y.w;
}
void solve()
{
cin >> n >> m;
FOR(i, 1, m)
{
cin >> Feds[i].u >> Feds[i].v >> Feds[i].w;
if (Feds[i].u > Feds[i].v) swap(Feds[i].u, Feds[i].v);
lst[i] = 0;
}
dsu.init();
cin >> q;
build(1, 0, q);
FOR(iq, 1, q)
{
cin >> qrs[iq].op >> qrs[iq].x >> qrs[iq].y;
if (qrs[iq].op == 1)
{
int id = qrs[iq].x, val = qrs[iq].y;
updEd(1, 0, q, lst[id], iq - 1, Ed(Feds[id].u, Feds[id].v, Feds[id].w));
lst[id] = iq;
Feds[id].w = val;
}
}
// Add edge until the last
FOR(id, 1, m)
{
updEd(1, 0, q, lst[id], q, Ed(Feds[id].u, Feds[id].v, Feds[id].w));
}
FOR(iq, 1, q << 2)
{
if (tree[iq].empty()) continue;
vector<Ed> vecDel;
auto it = tree[iq].begin();
for (; it != tree[iq].end(); ++it)
{
if (!dsu.unite(it->u, it->v))
{
vecDel.push_back(*it);
}
}
for (Ed ed : vecDel) tree[iq].erase(tree[iq].find(ed));
dsu.rollback(0);
}
FOR(iq, 1, q)
{
if (qrs[iq].op == 1) continue;
int id = ID[iq], S = qrs[iq].x, cur_w = qrs[iq].y;
while (id)
{
for (Ed ed : tree[id])
{
if (ed.w < cur_w) break;
dsu.unite(ed.u, ed.v);
}
id >>= 1;
}
cout << -dsu.e[dsu.get(S)] << '\n';
dsu.rollback(0);
}
}
signed main()
{
ios_base::sync_with_stdio(false); cin.tie(NULL); cout.tie(NULL);
#define TASK "test"
if (fopen(TASK".INP", "r"))
{
freopen(TASK".INP", "r", stdin);
freopen(TASK".OUT", "w", stdout);
}
solve();
time();
return 0;
}
