#include<cstdio>
#include<algorithm>
#include<cmath>
#include<iostream>
#include<set>
#include<vector>
#include<queue>
#include<stack>
#include<cstring>
#include<cstdlib>
#include<map>
#include<ctime>
#define rep(i,a,b) for(register int i=a;i<=b;++i)
#define rev(i,a,b) for(register int i=a;i>=b;--i)
#define gra(i,u) for(register int i=head[u];i;i=edge[i].nxt)
#define Clear(a) memset(a,0,sizeof(a))
#define yes puts("YES")
#define no puts("NO")
using namespace std;
typedef long long ll;
const int INF(1e9+10);
const ll LLINF(1e18+10);
inline int read()
{
	int s=0,w=1;
	char ch=getchar();
	while(ch<'0'||ch>'9'){if(ch=='-')w=-1;ch=getchar();}
	while(ch>='0'&&ch<='9')s=s*10+(ch-'0'),ch=getchar();
	return s*w;
}
template<typename T>
inline T Min(T x,T y){return x<y?x:y;}
template<typename T>
inline T Max(T x,T y){return x>y?x:y;}
template<typename T>
inline void Swap(T&x,T&y){T t=x;x=y;y=t;return;}
template<typename T>
inline T Abs(T x){return x<0?-x:x;}

const int MAXN(4e5+10);

int n,m,q;

struct E{int u,v,w;};E edge[MAXN];

bool vis[MAXN];

struct Union_Find_Set
{
	int par[MAXN],rankk[MAXN];
	
	inline void init_()
	{
		rep(i,1,n) par[i]=i,rankk[i]=0;
		return;
	}
	
	inline int find(int x){return par[x]==x?x:par[x]=find(par[x]);}
	
	inline void unite(int x,int y)
	{
		x=find(x),y=find(y);
		if(x==y) return;
		if(rankk[x]<rankk[y]) par[x]=y;
		else
		{
			par[y]=x;
			if(rankk[x]==rankk[y]) ++rankk[x];
		}
		return;
	}
	
	inline bool same(int x,int y){return find(x)==find(y);}
};

Union_Find_Set dsu;

struct Link_Cut_Tree
{
	int fa[MAXN],ch[MAXN][2],val[MAXN],pos[MAXN],maxx[MAXN];//pos 最大值的位置 
	bool tag[MAXN];
	
	inline void push_up(int u)
	{
		int ls=ch[u][0],rs=ch[u][1];
		if(maxx[ls]>maxx[rs]) pos[u]=pos[ls];else pos[u]=pos[rs];
		if(val[u]>Max(maxx[ls],maxx[rs])) pos[u]=u;
		maxx[u]=Max(Max(maxx[ls],maxx[rs]),val[u]);
		return;
	}
	
	inline void lazy_tag(int u)
	{
		Swap(ch[u][0],ch[u][1]);
		tag[u]^=1;
		return;
	}
	
	inline void push_down(int u)
	{
		if(tag[u])
		{
			if(ch[u][0]) lazy_tag(ch[u][0]);
			if(ch[u][1]) lazy_tag(ch[u][1]);
			tag[u]=false;
		}
		return;
	}
	
	inline bool isroot(int u){return u!=ch[fa[u]][0]&&u!=ch[fa[u]][1];}
	
	inline bool Get(int u){return u==ch[fa[u]][1];}
	
	inline void update(int x)
	{
		if(!isroot(x)) update(fa[x]);
		push_down(x);
		return;
	}
	
	inline void rotate(int x)
	{
		int y=fa[x],z=fa[y],chk=Get(x);
		if(!isroot(y)) ch[z][Get(y)]=x;
		ch[y][chk]=ch[x][!chk],fa[ch[x][!chk]]=y;
		ch[x][!chk]=y,fa[y]=x,fa[x]=z;
		push_up(y);
		push_up(x);
		return;
	}
	
	inline void splay(int x)
	{
		update(x);
		for(register int f=0;f=fa[x],!isroot(x);rotate(x))
			if(!isroot(f)) rotate(Get(f)==Get(x)?f:x);
		return;
	}
	
	inline void access(int x)
	{
		for(register int p=0;x;p=x,x=fa[x])
		{
			splay(x);
			ch[x][1]=p;
			push_up(x);
		}
		return;
	}
	
	inline void makeroot(int x)
	{
		access(x);
		splay(x);
		lazy_tag(x);
		return;
	}
	
	inline int findroot(int x)
	{
		access(x);
		splay(x);
		push_down(x);
		while(ch[x][0]) x=ch[x][0],push_down(x);
		return x;
	}
	
	inline bool same(int x,int y){return findroot(x)==findroot(y);}
	
	inline void link(int x,int y)
	{
//		printf("link %d %d\n",x,y);
		if(!same(x,y)) makeroot(x),fa[x]=y;
		return;
	}
	
	inline void cut(int x,int y)
	{
		makeroot(x);
		access(y);
		splay(y);
		if(ch[y][0]==x&&!ch[x][1]) ch[y][0]=fa[x]=0;
		push_up(y);
		return;
	}
	
	inline void split(int x,int y)
	{
		makeroot(x);
		access(y);
		splay(y);
		return;
	}
};

Link_Cut_Tree lct;

bool flag[MAXN];

inline void kruskal()
{
	int times(0);
	rep(i,1,m)
	{
		E e=edge[i];
		if(vis[i]) continue;
		if(!dsu.same(e.u,e.v))
		{
			dsu.unite(e.u,e.v);
			++times;
			flag[i]=true;
		}
		if(times==n-1) break;
	}
	return;
}

struct node{int opt,x,y;};
node que[MAXN];

inline bool cmp(E x,E y){return x.w<y.w;}

typedef pair<int,int>P;

map<P,int>mp;

int ans[MAXN];

int main()
{
//	freopen("read.txt","r",stdin);
	n=read(),m=read(),q=read();
	dsu.init_();
	rep(i,1,m)
	{
		int u=read(),v=read(),w=read();
		if(u>v) Swap(u,v);
		edge[i].u=u,edge[i].v=v,edge[i].w=w;
	}
	sort(edge+1,edge+1+m,cmp);
	rep(i,1,m) mp[make_pair(edge[i].u,edge[i].v)]=i;
	rep(i,1,q)
	{
		int opt=read(),x=read(),y=read();
		if(x>y) Swap(x,y);
		que[i].opt=opt,que[i].x=x,que[i].y=y;
		vis[mp[make_pair(x,y)]]=true;
	} 
	sort(edge+1,edge+1+m,cmp);
	kruskal();
	rep(i,1,m) if(flag[i])
	{
		lct.val[i+n]=edge[i].w;
		lct.link(edge[i].u,i+n);
		lct.link(i+n,edge[i].v);
	} 
	rev(i,q,1)
	{
		int opt=que[i].opt,x=que[i].x,y=que[i].y;
		if(opt==1)
		{
			lct.split(x,y);
			ans[i]=lct.maxx[y];
		}
		else
		{
			lct.split(x,y);
			int id=lct.pos[y]-n;
			if(edge[id].w>edge[mp[make_pair(x,y)]].w)
			{
				int idd=mp[make_pair(x,y)];
				lct.cut(edge[id].u,id+n);

				lct.cut(edge[id].v,id+n);

				lct.val[idd+n]=edge[idd].w;
				lct.link(edge[idd].u,idd+n);
				lct.link(edge[idd].v,idd+n);
			}
		}
	} 
	rep(i,1,q) if(que[i].opt==1) printf("%d\n",ans[i]);
	return 0;
}
/*
Date : 2022/8/26
Author : UperFicial
Start coding at : 13:43
finish debugging at : 
*/