#pragma GCC optimize ("O3")
#include <bits/stdc++.h>
using namespace std;
#define int long long 
#define rep(i, a, b) for (int i = (a); i <= (b); i++)
#define per(i, a, b) for (int i = (b); i >= (a); i--)
#define SZ(x) ((int)x.size())
#define all(x) x.begin(), x.end()
#define pb push_back
#define mp make_pair
#define mt make_tuple
#define st first
#define nd second
using ll = long long;
using vi = vector<int>;
using pii = pair<int, int>;
using pll = pair<ll, ll>;
auto &operator<<(auto &o, pair<auto, auto> p) {
    return o << "(" << p.st << ", " << p.nd << ")";
}
auto operator<<(auto &o, auto x)->decltype(end(x), o) {
    o << "{"; int i=0; for(auto e: x) o << ", " + 2*!i++ << e;
    return o << "}";
}
#define deb(x...) cerr << "[" #x "]: ", [](auto...$) { ((cerr<<$<<"; "),...) << endl; }(x)

const int nax = 2e5 + 5;
vector<pii> adj[nax];
int n, m, q;
 
int timer = 0;
int pre[nax];
int post[nax];
const int LOG = 20;
int up[nax][LOG];
int prefDist[nax];
 
void dfs(int v, int p, int cost){
    up[v][0] = p;
    for(int i=1;i<LOG;i++){
        int kt = up[v][i - 1];
        up[v][i] = up[kt][i - 1];
    }
    pre[v] = ++timer;
    prefDist[v] = prefDist[p] + cost;
    for(pii go : adj[v]){
        if(go.st != p) dfs(go.st, v, go.nd);
    }
    post[v] = ++timer;
}
 
bool anc(int x, int y){
    return (pre[x] <= pre[y] && post[x] >= post[y]);
}
 
int lca(int x, int y){
    if(anc(x, y)) return x;
    if(anc(y, x)) return y;
    for(int i=LOG-1;i>=0;i--){
        if(!anc(up[x][i], y)) x = up[x][i];
    }
    return up[x][0];
}
 
int dist(int x, int y){
    int d = lca(x, y);
    return prefDist[x] + prefDist[y] - prefDist[d] * 2;
}
 
bool blocked[nax];
int par[nax];
int sz[nax];
 
void recalc_sz(int v, int p){
    sz[v] = 1;
    for(pii go : adj[v]){
        int kt = go.st;
        if(!blocked[kt] && kt != p){
            recalc_sz(kt, v);
            sz[v] += sz[kt];
        }
    }
}
 
int get_centroid(int v, int p, int total){
    for(pii go : adj[v]){
        int kt = go.st;
        if(blocked[kt] || kt == p) continue;
        if(sz[kt] > total / 2) return get_centroid(kt, v, total);
    }
    return v;
}
 
void calc_centroid(int v, int p){
    recalc_sz(v, p);
    int w = get_centroid(v, v, sz[v]);
    blocked[w] = true;
    par[w] = p;
    for(pii go : adj[w]){
        int kt = go.st;
        if(!blocked[kt]){
            calc_centroid(kt, w);
        }
    }
}
 
vector<tuple<int, int, int> > colors[nax]; // promien, kolor, czas
 
void pu(int who, int col, int ray, int tm){
    while(colors[who].size()){
        auto [r, c, t] = colors[who].back();
        if(r <= ray){
            colors[who].pop_back();
        }
        else break;
    }
    colors[who].pb(make_tuple(ray, col, tm));
}

vector<tuple<int, int, int>> kraw;
vector<tuple<int, int, int, int>> zapy;
bool latwy = true;


void solve(){
    dfs(1, 1, 0);
    calc_centroid(1, -1);
    for(int i=1;i<=q;i++){
        auto [tp, vv, di, col] = zapy[i - 1];
        if(tp == 3){
            //int v, d, c; cin >> v >> d >> c;
            int v = vv;
            int d = di;
            int c = col;
            int cur = v;
            while(1){
                int odl = dist(v, cur);
                if(odl <= d){
                    pu(cur, c, d - odl, i);
                }
                cur = par[cur];
                if(cur == -1) break;
            }
        }
        else{
            //int v; cin >> v;
            int v = vv;
            int cur = v;
            int color = 0;
            int latest = 0;
            while(1){
                if(colors[cur].size()){
                    int want = dist(cur, v);
                    int lo = 0;
                    int hi = (int)colors[cur].size() - 1;
                    auto [r, _, __] = colors[cur][0];
                    if(r >= want){
                        while(lo + 1 < hi){
                            int mid = (lo + hi) / 2;
                            auto [r, _, __] = colors[cur][mid];
                            if(r >= want) lo = mid;
                            else hi = mid;
                        }
                        int bt = lo;
                        for(int mid=lo;mid<=hi;mid++){
                            auto [r, _, __] = colors[cur][mid];
                            if(r >= want) bt = mid;
                        }
                        auto [ray, col, tm] = colors[cur][bt];
                        if(tm > latest){
                            color = col;
                            latest = tm;
                        }
                    }
                }
                cur = par[cur];
                if(cur == -1) break;
            }
            cout << color << "\n";
        }
    }
}

int kolorek[nax];
map<pii, int> edgeLen;
set<pii> edges[nax];
bool vis[nax];

void add_edge(int x, int y, int d){
    if(x > y) swap(x, y);
    edgeLen[{x, y}] = d;
    edges[x].insert({y, d});
    edges[y].insert({x, d});
}

void del_edge(int x, int y){
    if(x > y) swap(x, y);
    int d = edgeLen[{x, y}];
    edgeLen.erase({x, y});
    edges[x].erase({y, d});
    edges[y].erase({x, d});
}

void smaruj(int v, int z, int k){
    kolorek[v] = k;
    vis[v] = true;
    for(auto [y, d] : edges[v]){
        if(!vis[y] && d <= z) smaruj(y, z - d, k);
    }
}

void read_input(){
    cin >> n >> m >> q;
    rep(i, 1, m){
        int x, y, d; cin >> x >> y >> d;
        kraw.pb(mt(x, y, d));
    }
    latwy = true;
    rep(i, 1, q){
        int tp; cin >> tp;
        if(tp <= 2) latwy = false;
        if(tp == 1){
            int x, y, d; cin >> x >> y >> d;
            zapy.pb(mt(tp, x, y, d));
        }
        else if(tp == 2){
            int x, y; cin >> x >> y;
            zapy.pb(mt(tp, x, y, -1));
        }
        else if(tp == 3){
            int v, dist, col;
            cin >> v >> dist >> col;
            zapy.pb(mt(tp, v, dist, col));
        }
        else if(tp == 4){
            int x; cin >> x;
            zapy.pb(mt(tp, x, -1, -1));
        }
    }
    if(latwy){
        for(auto [x, y, d] : kraw){
            adj[x].pb(mp(y, d));
            adj[y].pb(mp(x, d));
        }
        solve();
        return;
    }
   
    // else brucik :)))))))
    rep(i, 1, m){
        auto [x, y, d] = kraw[i - 1];
        add_edge(x, y, d);
    }
    for(auto [tp, x, y, z] : zapy){
        if(tp == 1){
            add_edge(x, y, z);
        }
        else if(tp == 2){
            del_edge(x, y);
        }
        else if(tp == 3){
            rep(i, 1, n) vis[i] = false;
            smaruj(x, y, z);
        }
        else{
            cout << kolorek[x] << "\n";
        }
    }
}

signed main() {
    ios::sync_with_stdio(0);
    cin.tie(0);
    int tt = 1;
    //cin >> tt;
    rep(te, 1, tt) read_input();
    return 0;
}