#pragma GCC optimize("O3")
#include <bits/stdc++.h>
using namespace std;

#define FOR(i, n) for (int i = 0; i < n; i++)
#define f first
#define s second
#define pb push_back
#define all(s) s.begin(), s.end()
#define sz(s) (int)s.size()

using vi = vector<int>;
using ll = long long;
using ull = unsigned long long;
using pll = pair<ll, ll>;
using pull = pair<ull, ull>;
using vll = vector<ll>;
using ii = pair<int, int>;

const ll BIG_INF = 1e18;
const int N = 2e5 + 5;
const int LOG = 19;

ll dists[LOG][N];
int centro_anc[N];
int centro_level[N];
vector<vector<pair<ll, ii>>> centro_stacks(N);

void solve_centro(int n, vector<vector<ii>>& g, vector<vector<ll>>& queries)
{
    vi blocked(n + 1);
    int CENTRO = -1;
    int SZ = 0;

    function<void(int, int, int, ll)> dfs_dists = [&](int v, int level, int p, ll d)
    {
        dists[level][v] = d;
        for (auto [u, w] : g[v])
        {
            if (u == p or blocked[u])
            {
                continue;
            }
            dfs_dists(u, level, v, d + w);
        }
    };

    function<int(int, int)> dfs_SZ = [&](int v, int p)
    {
        int roz = 1;
        bool czy_centro = true;
        for (auto [u, w] : g[v])
        {
            if (u == p or blocked[u])
            {
                continue;
            }
            int child_size = dfs_SZ(u, v);
            czy_centro &= child_size * 2 < SZ;
            roz += child_size;
        }
        if (czy_centro and (roz * 2 >= SZ))
        {
            CENTRO = v;
        }
        return roz;
    };

    function<void(int, int, int)> decompose = [&](int start, int level, int p)
    {
        SZ = dfs_SZ(start, -1);
        dfs_SZ(start, -1);
        
        int centro = CENTRO;
        centro_anc[centro] = p;
        centro_level[centro] = level;
        centro_stacks[centro].pb({BIG_INF, {-1, 0}});
        dfs_dists(centro, level, -1, 0);
        blocked[centro] = true;

        for (auto [neigh, _] : g[centro])
        {
            if (blocked[neigh])
            {
                continue;
            }
            decompose(neigh, level + 1, centro);
        }
    };

    decompose(1, 0, -1);
    
    auto update = [&](int start, ll z, int col, int time)
    {
        int centro = start;
        while (centro != -1)
        {
            ll dist = dists[centro_level[centro]][start];
            while(centro_stacks[centro].back().f <= z - dist)
            {
                centro_stacks[centro].pop_back();
            }

            if (z - dist >= 0)
            {
                centro_stacks[centro].pb({z - dist, {time, col}});
            }
            centro = centro_anc[centro];
        }
    };

    auto ask = [&](int start)
    {
        int res = 0;
        int when_res = -1;

        int centro = start;
        while (centro != -1)
        {
            ll dist = dists[centro_level[centro]][start];
            
            pair<ll, ii> value = {dist, {-1, -1}};
            auto it = lower_bound(centro_stacks[centro].rbegin(), centro_stacks[centro].rend(), value);
            assert(it != centro_stacks[centro].rend());

            if (it->s.f > when_res)
            {
                res = it->s.s;
                when_res = it->s.f;
            }

            centro = centro_anc[centro];
        }
        return res;
    };

    FOR (time, sz(queries))
    {
        int rodz = queries[time][0];

        if (rodz == 1)
        {
            assert(false);
        }
        else if (rodz == 2)
        {
            assert(false);
        }
        else if (rodz == 3)
        {
            long long v = queries[time][1], z = queries[time][2], k = queries[time][3];
            update(v, z, k, time);
        }
        else
        {
            int v = queries[time][1];
            cout << ask(v) << '\n';
        }
    }    
}

void solve()
{
    int n, m, q;
    cin >> n >> m >> q;

    vector<pair<ii, int>> edges(m);
    vector<vector<ll>> queries(q);

    FOR (i, m)
    {
        cin >> edges[i].f.f >> edges[i].f.s >> edges[i].s;
    }

    bool centro = (m == n - 1);
    FOR (i, q)
    {
        int rodz;
        cin >> rodz;
        centro &= rodz >= 3;

        queries[i].resize((rodz == 2 ? 3 : rodz == 4 ? 2 : 4));
        queries[i][0] = rodz;

        for (int j = 1; j < sz(queries[i]); j++)
        {
            cin >> queries[i][j];
        }
    }

    vector<vector<ii>> g(n + 1);
    FOR (i, m)
    {
        int a = edges[i].f.f, b = edges[i].f.s, c = edges[i].s;
        g[a].pb({b, c});
        g[b].pb({a, c});
    }

    if (centro)
    {
        solve_centro(n, g, queries);
        return;
    }

    vi cols(n + 1);
    
    auto usun = [&](int a, int b)
    {
        FOR (i, sz(g[a]))
        {
            if (g[a][i].f == b)
            {
                g[a].erase(g[a].begin() + i);
                break;
            }
        }
    };

    function<void(int, int, ll, int k)> dfs = [&](int start, int p, ll c, int k)
    {
        cols[start] = k;
        for (auto [u, w] : g[start])
        {
            if (u == p)
                continue;
            if (w <= c)
                dfs(u, start, c - w, k);
        }
    };

    FOR (_, q)
    {
        int rodz = queries[_][0];

        if (rodz == 1)
        {
            int a = queries[_][1], b = queries[_][2], c = queries[_][3];
            g[a].pb({b, c});
            g[b].pb({a, c});
        }
        else if (rodz == 2)
        {
            int a = queries[_][1], b = queries[_][2];

            usun(a, b);
            usun(b, a);
        }
        else if (rodz == 3)
        {
            long long v = queries[_][1], z = queries[_][2], k = queries[_][3];
            dfs(v, -1, z, k);
        }
        else
        {
            int v = queries[_][1];
            cout << cols[v] << "\n";
        }
    }
}

int main()
{
    ios::sync_with_stdio(0);
    cin.tie(0);

    int tests = 1;
    // cin >> tests;

    for (int test = 1; test <= tests; test++)
    {
        solve();
    }

    return 0;
}