#pragma GCC optimize("Ofast")
//#pragma GCC target ("avx2")
//#pragma GCC optimization ("O3")
#pragma GCC optimization ("unroll-loops")
//#pragma GCC target("sse,sse2,sse3,ssse3,sse4,popcnt,abm,mmx,avx,tune=native")
#include<bits/stdc++.h>
//#include <ext/pb_ds/assoc_container.hpp>
//#include <ext/pb_ds/tree_policy.hpp>
//using namespace __gnu_pbds;
using namespace std;
//typedef tree<pair<int,int>,null_type,less<pair<int,int>>,rb_tree_tag,tree_order_statistics_node_update>ordered_set;
#define ll long long
#define ull unsigned long long int
#define pb push_back
#define mp make_pair
#define vi vector<int>
#define pii pair<int,int>
#define pss pair<short,short>
#define pld pair<long double,long double >
#define ld long double
#define piii  pair<pii,int>
#define vii vector<pair<int,int> >
#define st first
#define nd second
#define pll pair<ll,ll>
#define speed ios::sync_with_stdio(0);cin.tie(0);cout.tie(0);
#define M_PI 3.14159265358979323846
#define int long long
//const int mod=1000000007;
//const int mod=1009;
const int mod=998244353;
//const int inf=1000000009;
const long long INF=1000000000000000009;
const long long duza_liczba=1000000000000000;
const long long big=1000000000000000;
const long double eps=0.000000000000000000001;
const int rozm=2e5+5;
struct zapytanie{
    int nr,a,b,c;
};
int N,M,Q;
vector<zapytanie> W;
namespace kolorowanie_spojnych{
    struct polaczenie{
        int a,b,czas;
    };
    class SegTree{
        public:
        pii najlepszy_kolor;
        vector<vector<polaczenie>> Wektorek,Z;
        vii Kolor;
        vi Czas;
        vi R,S;
        int rozmiar;
        SegTree(int n){
            rozmiar=1;
            while(rozmiar<n)
                rozmiar*=2;
            rozmiar*=2;
            rozmiar--;
            Wektorek.resize(rozmiar+1);
            Z.resize(rozmiar+1);
            R.resize(rozmiar+1);
            S.resize(rozmiar+1);
            Kolor.resize(rozmiar+1);
            Czas.resize(rozmiar+1);
        }
        void ustaw(){
            for(int i=1;i<=rozmiar;i++)
            {
                R[i]=i;
                S[i]=1;
            }
        }
        int giga_czasik;
        int Find(int x){
            if(R[x]==x)
                return x;
            giga_czasik=max(giga_czasik,Czas[x]);
            return Find(R[x]);
        }
        void znajdz_kolor(int x,int czas){
            if(Kolor[x].nd>=czas)
                najlepszy_kolor=Kolor[x];
            //cout<<x<<" "<<czas<<" "<<Kolor[x].nd<<" "<<Kolor[x].st<<endl;
            if(R[x]==x)
                return;
            czas=max(czas,Czas[x]);
            znajdz_kolor(R[x],czas);
        }
        void Union(int a,int b,int c,int u){
            giga_czasik=0;
            int x=Find(a),y=Find(b);
            if(x==y)
                return;
            if(S[x]<S[y])
                swap(x,y);
            //cout<<"unionujemy "<<a<<" "<<b<<" "<<x<<" "<<y<<" "<<c<<"\n";
            R[y]=x;
            Czas[y]=max(c,giga_czasik);
            S[x]+=S[y];
            Z[u].pb({y,x,c});
        }
        private:
        void decompose(int a,int b,int lo,int hi,int u,pii c,int czas){
            if(b<=a)
                return;
            if(a==lo&&b==hi)
            {
                Wektorek[u].pb({c.st,c.nd,czas});
                return;
            }
            int mid=(lo+hi)/2;
            decompose(a,min(b,mid),lo,mid,2*u,c,czas);
            decompose(max(a,mid),b,mid,hi,2*u+1,c,czas);
        }
        public:
        void dekompozycja(int a,int b,pii c,int czas){
            //cout<<" hopu siupu "<<a<<" "<<b<<" "<<c.st<<" "<<c.nd<<" "<<czas<<"\n";
            decompose(a,b+1,1,rozmiar/2+2,1,c,czas);
        }
        void dfs(int n,int lo,int hi){
            if(n>rozmiar)
                return;
            int mid=(lo+hi)/2;
            for(auto el : Wektorek[n]){
                Union(el.a,el.b,el.czas,n);
            }
            dfs(2*n,lo,mid);
            dfs(2*n+1,mid,hi);
            while(!Z[n].empty()){
                pii u=mp(Z[n].back().a,Z[n].back().b);
                pii kolor=Kolor[u.nd];
                najlepszy_kolor=mp(0,0);
                znajdz_kolor(u.st,0);
                R[u.st]=u.st;
                S[u.nd]-=S[u.st];
                Kolor[u.st]=najlepszy_kolor;
                //cout<<"rozlaczamy "<<u.nd<<" "<<u.st<<" "<<najlepszy_kolor.st<<" "<<najlepszy_kolor.nd<<"\n";
                Z[n].pop_back();
            }
            if(2*n>rozmiar){
                int numerek=n-rozmiar/2;
                if(numerek>=W.size()+1)
                    return;
                auto el=W[numerek-1];
                if(el.nr==3){
                    int x=el.a;
                    int rep=Find(x);
                    //cout<<"kurwa "<<el.a<<" "<<el.c<<" "<<rep<<" "<<lo<<endl;
                    Kolor[rep]=mp(el.c,lo);
                }
                else if(el.nr==4){
                    najlepszy_kolor=mp(0,0);
                    znajdz_kolor(el.a,0);
                    cout<<najlepszy_kolor.st<<"\n";
                }
            }
        }
        void odpal(){
            dfs(1,1,rozmiar/2+2);
        }
    
    };

    map<pii,int> Alive;
    void solve(){
        int n=N,m=M;
        for(int i=0;i<m;i++){
            auto el=W[i];
            Alive[mp(el.a,el.b)]=1;
            Alive[mp(el.b,el.a)]=1;
        }
        SegTree segtree(W.size()+1);
        segtree.ustaw();
        for(int i=m;i<W.size();i++){
            auto el=W[i];
            if(el.nr==1){
                Alive[mp(el.a,el.b)]=i+1;
                Alive[mp(el.b,el.a)]=i+1;
            }
            else if(el.nr==2){
                int start=Alive[mp(el.a,el.b)];
                segtree.dekompozycja(start,i+1,mp(el.a,el.b),start);
                Alive[mp(el.a,el.b)]=0;
                Alive[mp(el.b,el.a)]=0;
            }
        }
        for(auto el:Alive){
            int a=el.st.st,b=el.st.nd;
            if(a<b){
                if(el.nd)
                    segtree.dekompozycja(el.nd,W.size(),mp(a,b),el.nd);
            }
        }
        segtree.odpal();
    }
}
namespace drzewo{
    const int inf=1e18+9;
    const int STALA=18;
    int A[rozm][STALA];
    bool blocked[rozm];
    int rwdc[rozm];
    int sub[rozm];
    vi PC[rozm];
    vector<pii> P[rozm];
    int dist[rozm];
    int ojciec[rozm];
    int gle[rozm];
    int dfs(int u,int fa){
        sub[u]=1;
        for (auto it:P[u]) if (it.st!=fa && !blocked[it.st]) sub[u]+=dfs(it.st,u);
        return sub[u];
    }
    
    int find_centroid(int u,int fa,int ile){
        for (auto it:P[u]) if (it.st!=fa && !blocked[it.st] && sub[it.st]>ile/2)return find_centroid(it.st,u,ile);
        return u;
    }
    void centroid(int u,int fa){
        int roz=dfs(u,fa);
        int next_centroid=find_centroid(u,fa,roz);
        rwdc[next_centroid]=fa;
        blocked[next_centroid]=true;
        for (auto it:P[next_centroid]){
            if (blocked[it.st])continue;
            centroid(it.st,next_centroid); 
        }
    }
    
    void dfs1(int u,int fa){
        ojciec[u]=fa;
        for (auto it:P[u]) if (it.st!=fa)gle[it.st]=gle[u]+1,dist[it.st]=dist[u]+it.nd,dfs1(it.st,u);
    }
    
    void make(int n){
        for (int i=1;i<=n;i++)A[i][0]=ojciec[i];
        for (int i=1;i<STALA;i++) for (int j=1;j<=n;j++) A[j][i]=A[A[j][i-1]][i-1];
    }
    
    int lca(int a,int b){
        if (gle[a]>gle[b])swap(a,b);
        for (int i=STALA-1;i>=0;i--)if (gle[A[b][i]]>=gle[a])b=A[b][i];
        if (a==b)return a;
        for (int i=STALA-1;i>=0;i--)if (A[a][i]!=A[b][i])a=A[a][i],b=A[b][i];
        return ojciec[a];
    } 
    
    int distance(int a,int b){
        return dist[b]+dist[a]-dist[lca(a,b)]*2;
    } 
    map<int,int>comp;
    set<pair<pii,int>>pom[rozm];
    int cnt=1;
    void update(int u,int d,int c){
        int v=u; 
        while (v!=-1){
            if (distance(u,v)<=d){
            int zostalo=d-distance(u,v);
            while (!pom[v].empty()){
                pair<pii,int> x=*pom[v].begin();
                int rozwaz=x.st.st;
                if (zostalo>=rozwaz)pom[v].erase(x);
                else break;
            } 
            pom[v].insert({{zostalo,cnt},c});
            }
            v=rwdc[v];
        }
        cnt++;
    }
    
    int query(int u){
    int v=u;
    int time=-1;
    int ans=0;
    while (v!=-1){
        if (!pom[v].empty()){
        int xd=distance(u,v);
        pair<pii,int>rak2=*pom[v].rbegin();
        if (xd<=rak2.st.st){
            auto it=*(pom[v].lower_bound({{xd,-inf},-inf}));
            if (it.st.nd>time)ans=it.nd,time=it.st.nd;
        }
        }
        v=rwdc[v];
    }
    return ans;
    }
    
    void solve(){
        int n=N;
        for(int i=0;i<M;i++){
            int a=W[i].a,b=W[i].b,c=W[i].c;
            P[a].pb({b,c});
            P[b].pb({a,c});
        }
        centroid(1,-1);
        dfs1(1,1);
        make(n);
        for(int i=M;i<W.size();i++){
            auto el=W[i];
            if(el.nr==3)
                update(el.a,el.b,el.c);
            else
                cout<<query(el.a)<<"\n";
        }
    }
}
namespace brut{
    vector<set<pii>> P;
    map<pii,int> M;
    vi K;
    int max_distance,kolor;
    void dfs(int n,int p,int distance){
        if(distance>max_distance)
            return;
        K[n]=kolor;
        for(auto el:P[n]){
            if(el.st!=p){
                dfs(el.st,n,distance+el.nd);
            }
        }
    }
    void solve(){
        int n=N;
        P.resize(n+1);
        K.resize(n+1);
        for(auto el : W){
            if(el.nr==1){
                P[el.a].insert(mp(el.b,el.c));
                P[el.b].insert(mp(el.a,el.c));
                M[mp(el.a,el.b)]=el.c;
                M[mp(el.b,el.a)]=el.c;
            }
            else if(el.nr==2){
                int d=M[mp(el.a,el.b)];
                P[el.a].erase(mp(el.b,d));
                P[el.b].erase(mp(el.a,d));
            }
            else if(el.nr==3){
                max_distance=el.b,kolor=el.c;
                dfs(el.a,0,0);
            }
            else{
                cout<<K[el.a]<<"\n";
            }
        }
    }

}
void solve()
{
    int n,m,q;
    cin>>n>>m>>q;
    N=n,M=m,Q=q;
    for(int i=1;i<=m;i++){
        int a,b,d;
        cin>>a>>b>>d;
        W.pb({1,a,b,d});
    }
    bool pd=0,same_maksy=1;
    for(int i=1;i<=q;i++){
        int nr;
        cin>>nr;
        if(nr==1){
            pd=1;
            int a,b,d;
            cin>>a>>b>>d;
            W.pb({1,a,b,d});
        }
        else if(nr==2){
            pd=1;
            int a,b;
            cin>>a>>b;
            W.pb({2,a,b,0});
        }
        else if(nr==3){
            int v,d,k;
            cin>>v>>d>>k;
            if(d!=duza_liczba)
                same_maksy=0;
            W.pb({3,v,d,k});
        }
        else{
            int x;
            cin>>x;
            W.pb({4,x});
        }
    }
    if(!pd&&m==n-1){
        drzewo::solve();
    }
    else if(n*q<=1e7){
        brut::solve();
    }
    else if(same_maksy){
        kolorowanie_spojnych::solve();
    }
    else{
        brut::solve();
    }

}
    
int32_t main(){
    speed
    int t = 1;
    //cin >> t;
    while(t--){
        solve();
    }
    return 0;
}