#include <algorithm>
#include <array>
#include <bitset>
#include <cassert>
#include <chrono>
#include <cmath>
#include <complex>
#include <cstring>
#include <functional>
#include <iomanip>
#include <iostream>
#include <map>
#include <numeric>
#include <queue>
#include <random>
#include <set>
#include <vector>
#include <unordered_set>
#include <climits>
#include <list>
using namespace std;
 
using ll = long long;
using ul = unsigned long long;
using db = long double;
using pi = pair<int, int>;
using vi = vector<int>;
using vl = vector<ll>;
using vpi = vector<pi>;
#define mp make_pair
#define pb push_back
#define eb emplace_back
#define x first
#define y second

template<class T> using V = vector<T>; 
template<class T, size_t SZ> using AR = array<T,SZ>; 

#define FOR(i,a,b) for (int i = (a); i < (b); ++i)
#define F0R(i,a) FOR(i,0,a)
#define ROF(i,a,b) for (int i = (b)-1; i >= (a); --i)
#define R0F(i,a) ROF(i,0,a)
#define each(a,x) for (auto& a: x)
 
#define sz(x) int((x).size())
#define all(x) (x).begin(), (x).end()
#define rep(i,a,b) for(int i = (a); i < (b); i++)
#define per(i,a,b) for(int i = (b) - 1; i >= (a); i--)

#ifdef LOCAL 
template<class A, class B> auto& operator<<(auto &o, pair<A, B> p) { return o << '(' << p.x << ", " << p.y << ')'; }
auto& operator<<(auto& o, auto a) {
    o << "{";
    for (auto b : a) o << b << ", ";
    return o << "}";
}
void dump(auto... x) { ((cerr << x << ", "), ...) << "\n"; }
#define debug(x...) cerr << "[" #x "]: ", dump(x)
#else
#define debug(...) ;
#endif

template<class T> bool ckmin(T& a, const T& b) { return b < a ? a = b, 1 : 0; }
template<class T> bool ckmax(T& a, const T& b) { return a < b ? a = b, 1 : 0; }
template<class T> int lwb(V<T>& a, const T& b) { return int(lower_bound(all(a),b)-begin(a)); }
template<class T> int upb(V<T>& a, const T& b) { return int(upper_bound(all(a),b)-begin(a)); }
template<class T> void remDup(vector<T>& v) { sort(all(v)); v.erase(unique(all(v)),end(v)); }

const int MX = 2e5+10;

// https://github.com/bqi343/cp-notebook/blob/master/Implementations/content/graphs%20(12)/Advanced/LCT.h
typedef struct snode* sn;
struct snode { //////// VARIABLES
	sn p, c[2]; // parent, children
	bool flip = 0; // subtree flipped or not
	int sz; // value in node, # nodes in current splay tree
	snode() {
		p = c[0] = c[1] = NULL; calc(); }
	friend int getSz(sn x) { return x?x->sz:0; }
	void prop() { // lazy prop
		if (!flip) return;
		swap(c[0],c[1]); flip = 0;
		F0R(i,2) if (c[i]) c[i]->flip ^= 1;
	}
	void calc() { // recalc vals
		F0R(i,2) if (c[i]) c[i]->prop();
		sz = 1+getSz(c[0])+getSz(c[1]);
	}
	//////// SPLAY TREE OPERATIONS
	int dir() {
		if (!p) return -2;
		F0R(i,2) if (p->c[i] == this) return i;
		return -1; // p is path-parent pointer
	} // -> not in current splay tree
	// test if root of current splay tree
	bool isRoot() { return dir() < 0; } 
	friend void setLink(sn x, sn y, int d) {
		if (y) y->p = x;
		if (d >= 0) x->c[d] = y; }
	void rot() { // assume p and p->p propagated
		assert(!isRoot()); int x = dir(); sn pa = p;
		setLink(pa->p, this, pa->dir());
		setLink(pa, c[x^1], x); setLink(this, pa, x^1);
		pa->calc();
	}
	void splay() {
		while (!isRoot() && !p->isRoot()) {
			p->p->prop(), p->prop(), prop();
			dir() == p->dir() ? p->rot() : rot();
			rot();
		}
		if (!isRoot()) p->prop(), prop(), rot();
		prop(); calc();
	}
	sn fbo(int b) { // find by order
		prop(); int z = getSz(c[0]); // of splay tree
		if (b == z) { splay(); return this; }
		return b < z ? c[0]->fbo(b) : c[1] -> fbo(b-z-1);
	}
	//////// BASE OPERATIONS
	void access() { // bring this to top of tree, propagate
		for (sn v = this, pre = NULL; v; v = v->p) {
			v->splay(); // now switch virtual children
			v->c[1] = pre; v->calc(); pre = v;
		}
		splay(); assert(!c[1]); // right subtree is empty
	}
	void makeRoot() { 
		access(); flip ^= 1; access(); assert(!c[0] && !c[1]); }
	//////// QUERIES
	friend sn lca(sn x, sn y) {
		if (x == y) return x;
		x->access(), y->access(); if (!x->p) return NULL;
		x->splay(); return x->p?:x; // y was below x in latter case
	} // access at y did not affect x -> not connected
	friend bool connected(sn x, sn y) { return lca(x,y); } 
	// # nodes above
	int distRoot() { access(); return getSz(c[0]); } 
	sn getRoot() { // get root of LCT component
		access(); sn a = this; 
		while (a->c[0]) a = a->c[0], a->prop();
		a->access(); return a;
	}
	sn getPar(int b) { // get b-th parent on path to root
		access(); b = getSz(c[0])-b; assert(b >= 0);
		return fbo(b);
	} // can also get min, max on path to root, etc
	//////// MODIFICATIONS
	friend void link(sn x, sn y, bool force = 1) { 
		assert(!connected(x,y)); 
		if (force) y->makeRoot(); // make x par of y
		else { y->access(); assert(!y->c[0]); }
		x->access(); setLink(y,x,0); y->calc();
	}
	friend void cut(sn y) { // cut y from its parent
		y->access(); assert(y->c[0]);
		y->c[0]->p = NULL; y->c[0] = NULL; y->calc(); }
	friend void cut(sn x, sn y) { // if x, y adj in tree
		x->makeRoot(); y->access(); 
		assert(y->c[0] == x && !x->c[0] && !x->c[1]); cut(y); }
};
sn LCT[MX];


int n, m, q;
const int N = 2e5+100;
const int LOG = 20;

struct Query {
    int type;
    int u, v, k;
    ll d;
    void get() {
        cin >> type;
        if (type == 1) {
            cin >> u >> v >> d;
            u--; v--;
        }
        else if (type == 2) {
            cin >> u >> v;
            u--; v--;
        }
        else if (type == 3) {
            cin >> u >> d >> k;
            u--;
        }
        else {
            cin >> u;
            u--;
        }
    }
};

vector<Query> queries;

// BEGIN SOLVE 1

int tim = 0;

struct segment_tree {
    int base;
    vpi tree; // time of update, color

    void init(int _n) {
        base = 1;
        while (base <= _n) base *= 2;
        tree.resize(2 * base);
    }

    pi query(int idx) {
        idx += base;
        pi cur = tree[idx];
        idx /= 2;
        while (idx) {
            ckmax(cur, tree[idx]);
            idx /= 2;
        }
        return cur;
    }

    void upd(int node, int left, int right, int l, int r, pi val) {
        if (left > r || right < l) return;
        if (left >= l && right <= r) {
            tree[node] = val;
            return;
        }
        int mid = (left + right) / 2;
        upd(2 * node, left, mid, l, r, val);
        upd(2 * node + 1, mid + 1, right, l, r, val);
    }

    void upd(int l, int r, int c) {
        pi val = {++tim, c};
        upd(1, 0, base - 1, l, r, val);
    }
};

// Centroid based on https://github.com/bqi343/cp-notebook/blob/master/Implementations/content/graphs%20(12)/Trees%20(10)/Centroid%20(10.3).h
vector<pair<int, ll>> adj[N];
bool done[N];
int sub[N];
int cen[N];
int lev[N];
ll dist[LOG][N];
segment_tree stor[N];
vl dists[N];

void ae(int a, int b, ll c) {
    adj[a].eb(b, c);
    adj[b].eb(a, c);
}

void dfs(int x, int p) {
    sub[x] = 1;
    for (auto [y, _] : adj[x]) {
        if (!done[y] && y != p) {
            dfs(y, x);
            sub[x] += sub[y];
        }
    }
}

int centroid(int x) {
    dfs(x, -1);
    for (int sz = sub[x];;) {
        pi mx = {0, 0};
        for (auto [y, _] : adj[x]) {
            if (!done[y] && sub[y] < sub[x]) {
                ckmax(mx, {sub[y], y});
            }
        }
        if (mx.x * 2 <= sz) return x;
        x = mx.y;
    }
    assert(false);
    return -1;
}

void gen_dist(int x, int p, int level, ll c, int CEN) {
    // debug(x, p, level, c, CEN);
    dist[level][x] = dist[level][p] + c;
    dists[CEN].pb(dist[level][x]);
    for (auto [y, nc] : adj[x]) {
        if (!done[y] && y != p) {
            gen_dist(y, x, level, nc, CEN);
        }
    }
}

void gen(int CEN, int _x) { // CEN = centroid above x
    int x = centroid(_x);
    done[x] = 1;
    cen[x] = CEN;
    sub[x] = sub[_x];
    lev[x] = (CEN == -1 ? 0 : lev[CEN] + 1);
    dist[lev[x]][x] = 0;
    stor[x].init(sub[x]);
    dists[x].reserve(sub[x]);
    dists[x].pb(0);
    for (auto [y, c] : adj[x]) {
        if (!done[y]) {
            gen_dist(y, x, lev[x], c, x);
        }
    }
    for (auto [y, c] : adj[x]) {
        if (!done[y]) {
            gen(x, y);
        }
    }
    assert(sz(dists[x]) == sub[x]);
    sort(all(dists[x]));
}

void init() {
    fill(done, done + n, false);
    gen(-1, 0);
}

void upd(int x, ll y, int c) {
    int cur = x;
    per(i,0,lev[x] + 1) {
        int idx = upb(dists[cur], y - dist[i][x]);
        if (idx > 0) {
            stor[cur].upd(0, idx - 1, c);
        }
        cur = cen[cur];
    }
}

int query_centro(int x) {
    int cur = x;
    pi ans = {-1, -1};
    per(i,0,lev[x] + 1) {
        int idx = upb(dists[cur], dist[i][x]);
        if (idx > 0) {
            ckmax(ans, stor[cur].query(idx - 1));
        }
        cur = cen[cur];
    }
    return ans.y;
}

void solve_static() {
    init();

    for (auto qry : queries) {
        assert(qry.type == 3 || qry.type == 4);
        if (qry.type == 3) {
            upd(qry.u, qry.d, qry.k);
        }
        else {
            int res = query_centro(qry.u);
            cout << res << '\n';
        }
    }
}

// ==== end solve static

// ==== begin brut

vector<set<pi>> g;
vi col;

void dfs_brut(int u, ll l, int k, int p = -1) {
    if (l < 0) return;
    col[u] = k;
    for (auto [v, d] : g[u]) {
        if (v == p) continue;
        dfs_brut(v, l - d, k, u);
    }
}

void solve_brut() {
    for (auto qry : queries) {
        if (qry.type == 1) {
            g[qry.u].insert({qry.v, qry.d});
            g[qry.v].insert({qry.u, qry.d});
        }
        else if (qry.type == 2) {
            int a = qry.u;
            int b = qry.v;
            auto ita = g[a].lower_bound({b,-1});
            auto itb = g[b].lower_bound({a,-1});
            assert(ita != g[a].end());
            assert(itb != g[b].end());
            assert(ita->x == b);
            assert(itb->x == a);
            g[a].erase(ita);
            g[b].erase(itb);
        }
        else if (qry.type == 3) {
            dfs_brut(qry.u, qry.d, qry.k);            
        }
        else {
            cout << col[qry.u] << '\n';
        }
    }
}

// end brut

// begin lct

const int B = 400;
bool vis[N];

list<int> G[N];
using iter = list<int>::iterator;
map<pi, pair<iter, iter>> Gmap;

void dfs_lct(int u, int k) {
	vis[u] = true;
	col[u] = k;
	for (const auto& v : G[u]) {
		if (vis[v]) continue;
		dfs_lct(v, k);
	}
}

void solve_1e15() {
	rep(i,0,n) LCT[i] = new snode();
	rep(i,0,n) {
		for (auto j : G[i]) {
			if (j < i) continue;
			link(LCT[i], LCT[j]);
		}
	}

	vpi future_queries;
	int fst_query = 0; 
	int offset = 0;

	while (offset < q) {
		int limit = 0;
		int cnt_2 = 0;
		int cnt_4 = 0;
		while (limit + offset < q && cnt_2 < B && cnt_4 < B) {
			const auto &qry = queries[limit + offset];
			if (qry.type == 4) cnt_4++;
			else if (qry.type == 2) cnt_2++;
			limit++;
		}
		rep(i,0,limit) {
			if (i + offset >= q) break;
			const auto &qry = queries[i + offset];
			if (qry.type == 4) {
				future_queries.eb(qry.u, col[qry.u]);
			}
		}

		rep(i,0,limit) {
			if (i + offset >= q) break;
			const auto &qry = queries[i + offset];
			if (qry.type == 1) {
				int a = qry.u;
				int b = qry.v;
				if (a > b) swap(a, b);
				// G[a].insert(b);
				// G[b].insert(a);
				G[a].push_back(b);
				G[b].push_back(a);
				Gmap[mp(a, b)] = mp(prev(G[a].end()), prev(G[b].end()));
				link(LCT[a], LCT[b]);
			}
			else if (qry.type == 2) {
				int a = qry.u;
				int b = qry.v;
				if (a > b) swap(a, b);
				// G[a].erase(b);
				// G[b].erase(a);
				auto [it1, it2] = Gmap[mp(a, b)];
				G[a].erase(it1);
				G[b].erase(it2);
				cut(LCT[a], LCT[b]);
			}
			else if (qry.type == 3) {
				int u = qry.u;
				int k = qry.k;
				rep(j,fst_query,sz(future_queries)) {
					auto &[v, res] = future_queries[j];
					if (connected(LCT[u], LCT[v])) {
						res = k;
					}
				}
			}
			else {
				fst_query++;
			}
		}

		for (const auto &[_, res] : future_queries) {
			cout << res << '\n';
		}

		future_queries.clear();
		fst_query = 0;

		fill(vis, vis + n, false);

		// set<int> added_nodes;
		vi added_nodes;
		
		// od końca dfs na grafie
		per(i,0,limit) {
			if (i + offset >= q) continue;
			const auto &qry = queries[i + offset];
			if (qry.type == 1) {
				int a = qry.u;
				int b = qry.v;
				if (a > b) swap(a, b);
				// G[a].erase(b);
				// G[b].erase(a);
				auto [it1, it2] = Gmap[mp(a, b)];
				G[a].erase(it1);
				G[b].erase(it2);
				cut(LCT[a], LCT[b]);
			}
			else if (qry.type == 2) {
				int a = qry.u;
				int b = qry.v;
				if (a > b) swap(a, b);
				// G[a].insert(b);
				// G[b].insert(a);
				G[a].push_back(b);
				G[b].push_back(a);
				Gmap[mp(a, b)] = mp(prev(G[a].end()), prev(G[b].end()));
				link(LCT[a], LCT[b]);
				added_nodes.pb(a);
				added_nodes.pb(b);
			}
			else if (qry.type == 3) {
				int u = qry.u;
				int k = qry.k;
				if (!vis[u]) {
					dfs_lct(u, k);
				}
				for (auto x : added_nodes) {
					if (vis[x]) continue;
					if (connected(LCT[x], LCT[u])) {
						dfs_lct(x, k);
					}
				}
			}
		}

		added_nodes.clear();

		rep(i,0,limit) {
			if (i + offset >= q) break;
			const auto &qry = queries[i + offset];
			if (qry.type == 1) {
				int a = qry.u;
				int b = qry.v;
				if (a > b) swap(a, b);
				// G[a].insert(b);
				// G[b].insert(a);
				G[a].push_back(b);
				G[b].push_back(a);
				Gmap[mp(a, b)] = mp(prev(G[a].end()), prev(G[b].end()));
				link(LCT[a], LCT[b]);
			}
			else if (qry.type == 2) {
				int a = qry.u;
				int b = qry.v;
				if (a > b) swap(a, b);
				// G[a].erase(b);
				// G[b].erase(a);
				auto [it1, it2] = Gmap[mp(a, b)];
				G[a].erase(it1);
				G[b].erase(it2);
				cut(LCT[a], LCT[b]);
			}
		}

		offset += limit;
	}

	// oof
}

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

    cin >> n >> m >> q;

    g.resize(n);
    col.resize(n);
    rep(i,0,m) {
        int a, b, d;
        cin >> a >> b >> d;
        a--; b--;
        g[a].insert({b, d});
        g[b].insert({a, d});
		if (a > b) swap(a, b);
		// G[a].insert(b);
		// G[b].insert(a);
		G[a].push_back(b);
		G[b].push_back(a);
		Gmap[mp(a, b)] = mp(prev(G[a].end()), prev(G[b].end()));
        ae(a, b, d); // static solve
    }

    bool any_edge_changes = false;
	bool all_z_1e15 = true;
	constexpr ll MAXZ = 1e15;

    queries.resize(q);
    rep(i,0,q) {
        queries[i].get();
        if (queries[i].type == 1 || queries[i].type == 2) {
            any_edge_changes = true;
        }
		if (queries[i].type == 3 && queries[i].d < MAXZ) {
			all_z_1e15 = false;
		}
    }

    if (!any_edge_changes && m == n - 1) {
        debug("solve static");
        solve_static();
        return 0;
    }

	if (all_z_1e15) {
		debug("solve 1e15");
		solve_1e15();
		return 0;
	}

    debug("solve brut");
    solve_brut();    

    return 0;
}