/**
* @title Template
*/
#include <iostream>
#include <algorithm>
#include <utility>
#include <numeric>
#include <vector>
#include <array>
#include <cassert>
#include <tuple>
#include <stack>
template <class T, class U>
bool chmin(T &lhs, const U &rhs) {
if (lhs > rhs) {
lhs = rhs;
return true;
}
return false;
}
template <class T, class U>
bool chmax(T &lhs, const U &rhs) {
if (lhs < rhs) {
lhs = rhs;
return true;
}
return false;
}
/**
* @title Chmin/Chmax
*/
class range {
public:
class iterator {
private:
int64_t M_position;
public:
iterator(int64_t position) noexcept: M_position(position) { }
void operator ++ () noexcept { ++M_position; }
bool operator != (iterator other) const noexcept { return M_position != other.M_position; }
int64_t operator * () const noexcept { return M_position; }
};
class reverse_iterator {
private:
int64_t M_position;
public:
reverse_iterator(int64_t position) noexcept: M_position(position) { }
void operator ++ () noexcept { --M_position; }
bool operator != (reverse_iterator other) const noexcept { return M_position != other.M_position; }
int64_t operator * () const noexcept { return M_position; }
};
private:
const iterator M_first, M_last;
public:
range(int64_t first, int64_t last) noexcept: M_first(first), M_last(std::max(first, last)) { }
iterator begin() const noexcept { return M_first; }
iterator end() const noexcept { return M_last; }
reverse_iterator rbegin() const noexcept { return reverse_iterator(*M_last - 1); }
reverse_iterator rend() const noexcept { return reverse_iterator(*M_first - 1); }
};
/**
* @title Range
*/
#include <type_traits>
#include <iterator>
template <class T>
class rev_impl {
public:
using iterator = decltype(std::declval<T>().rbegin());
private:
const iterator M_begin;
const iterator M_end;
public:
rev_impl(T &&cont) noexcept: M_begin(cont.rbegin()), M_end(cont.rend()) { }
iterator begin() const noexcept { return M_begin; }
iterator end() const noexcept { return M_end; }
};
template <class T>
rev_impl<T> rev(T &&cont) {
return rev_impl<T>(std::forward<T>(cont));
}
/**
* @title Reverser
*/
using i32 = int32_t;
using i64 = int64_t;
using u32 = uint32_t;
using u64 = uint64_t;
constexpr i32 inf32 = (i32(1) << 30) - 1;
constexpr i64 inf64 = (i64(1) << 62) - 1;
constexpr size_t Bucket = 800;
struct query_t {
i32 u, v, c;
query_t(i32 u_, i32 v_, i32 c_): u(u_), v(v_), c(c_) { }
};
int main() {
std::ios_base::sync_with_stdio(false);
std::cin.tie(nullptr);
i32 N, M;
std::cin >> N >> M;
assert(N <= 1000);
std::vector<i32> U(M), V(M), C(M);
for (auto i: range(0, M)) {
std::cin >> U[i] >> V[i] >> C[i];
--U[i]; --V[i];
}
i32 Q;
std::cin >> Q;
i32 B = (Q + Bucket - 1) / Bucket;
std::vector<std::vector<query_t>> qs1(B);
std::vector<std::vector<std::tuple<i32, i32, i32>>> qs2(B);
for (auto i: range(0, Q)) {
i32 t;
std::cin >> t;
if (t == 1) {
i32 b, r;
std::cin >> b >> r;
--b;
qs2[i / Bucket].emplace_back(b, r, i);
}
else {
i32 u, c;
std::cin >> u >> c;
--u;
qs1[i / Bucket].emplace_back(u, -(i + 1), c);
}
}
std::vector<i32> answer(Q);
for (auto step: range(0, B)) {
auto &q1 = qs1[step];
const auto &q2 = qs2[step];
q1.reserve(q1.size() + M);
std::vector<bool> change(M);
for (const auto &q: q2) {
change[std::get<0>(q)] = true;
}
for (auto i: range(0, M)) {
if (!change[i]) {
q1.emplace_back(U[i], V[i], C[i]);
}
}
std::sort(q1.begin(), q1.end(), [](const query_t &x, const query_t &y) {
if (x.c != y.c) return x.c > y.c;
return x.v > y.v;
});
std::vector<i32> parent(N, -1);
const auto find = [&](i32 u) {
while (parent[u] >= 0) {
u = parent[u];
}
return u;
};
for (const auto &q: q1) {
if (q.v >= 0) {
i32 u = find(q.u), v = find(q.v);
if (u == v) continue;
if (parent[u] > parent[v]) std::swap(u, v);
parent[u] += parent[v];
parent[v] = u;
}
else {
const i32 idx = -(q.v + 1);
std::stack<std::tuple<i32, i32, i32, i32>> st;
std::stack<std::pair<i32, i32>> eo;
for (const auto &r: q2) {
const i32 b = std::get<0>(r);
if (std::get<2>(r) < idx) {
eo.emplace(b, C[b]);
C[b] = std::get<1>(r);
}
if (C[b] < q.c) continue;
i32 u = find(U[b]), v = find(V[b]);
if (u == v) continue;
if (parent[u] > parent[v]) std::swap(u, v);
st.emplace(u, parent[u], v, parent[v]);
parent[u] += parent[v];
parent[v] = u;
}
answer[idx] = -parent[find(q.u)];
while (!st.empty()) {
i32 u, up, v, vp;
std::tie(u, up, v, vp) = st.top();
st.pop();
parent[u] = up;
parent[v] = vp;
}
while (!eo.empty()) {
C[eo.top().first] = eo.top().second;
eo.pop();
}
}
}
for (const auto &q: q2) {
C[std::get<0>(q)] = std::get<1>(q);
}
}
for (auto x: answer) {
if (x != 0) {
std::cout << x << '\n';
}
}
return 0;
}
