#define rch(k) node[node[k].ch[1]]
const int MAXN=1e5+5,MAXM=5e5+5,MAXL=80;
struct Node{
	int s,ch[2];
}node[MAXN*MAXL];
int root[MAXN<<1],n,seg_n,node_cnt;
void update(int &k,int p,int pos,int lef=1,int rig=seg_n){
	node[k=++node_cnt]=node[p];
	node[k].s++;
	if(lef==rig)return;
	int mid=lef+rig>>1;
	if(pos<=mid)
	update(node[k].ch[0],node[p].ch[0],pos,lef,mid);
	else
	update(node[k].ch[1],node[p].ch[1],pos,mid+1,rig);
}
int query(int k1,int k2,int rk,int lef=1,int rig=seg_n){
	int mid=lef+rig>>1;
	if(lef==rig)return mid;
	if(rk<=rch(k1).s-rch(k2).s)
	return query(node[k1].ch[1],node[k2].ch[1],rk,mid+1,rig);
	else
	return query(node[k1].ch[0],node[k2].ch[0],rk-rch(k1).s+rch(k2).s,lef,mid);
}
struct Edge{
	int u,v,w;
	bool operator < (const Edge &b)const{
		return w<b.w;
	}
}edge[MAXM];
int a[MAXN],b[MAXN],p[MAXN<<1],ch[MAXN<<1][2],dfn[MAXN<<1][2],dfs_t;
namespace LCA{
	const int MAXN=2e5+5;
	int d[MAXN],anc[MAXN][MAXL],w[MAXN],log2[MAXN];
	void get_log(int n){
		int log=0;
		while((1<<log)<n){
			for(int i=1<<log,j=min(1<<(log+1),n);i<j;i++)
			log2[i]=log;
			log++;
		}
	}
	void init(int n){
		get_log(n);
		for(int j=1;(1<<j)<n;j++){
			_rep(i,1,n){
				if(!anc[i][j-1])
				continue;
				anc[i][j]=anc[anc[i][j-1]][j-1];
			}
		}
	}
	int query(int p,int k){
		for(int i=log2[d[p]];i>=0;i--){
			if(anc[p][i]&&w[anc[p][i]]<=k)
			p=anc[p][i];
		}
		return p;
	}
};
int Find(int x){return x==p[x]?x:p[x]=Find(p[x]);}
void dfs(int u,int fa,int dep){
	if(!u)return;
	dfn[u][0]=++dfs_t;LCA::d[u]=dep;
	if(u<=n)
	update(root[dfs_t],root[dfs_t-1],a[u]);
	else
	root[dfs_t]=root[dfs_t-1];
	dfs(ch[u][0],u,dep+1);
	dfs(ch[u][1],u,dep+1);
	dfn[u][1]=dfs_t;
}
int main()
{
	n=read_int();
	int m=read_int(),q=read_int();
	_rep(i,1,n)a[i]=b[i]=read_int();
	sort(b+1,b+n+1);
	seg_n=unique(b+1,b+n+1)-b;
	_rep(i,1,n)a[i]=lower_bound(b+1,b+seg_n,a[i])-b;
	_for(i,0,m){
		edge[i].u=read_int();
		edge[i].v=read_int();
		edge[i].w=read_int();
	}
	sort(edge,edge+m);
	int cur=n+1;
	_for(i,1,2*n)p[i]=i;
	_for(i,0,m){
		int x=Find(edge[i].u),y=Find(edge[i].v);
		if(x!=y){
			p[x]=p[y]=cur;
			ch[cur][0]=x,ch[cur][1]=y;
			LCA::anc[x][0]=LCA::anc[y][0]=cur,LCA::w[cur]=edge[i].w;
			cur++;
		}
	}
	_for(i,1,cur){
		if(!root[Find(i)])
		dfs(Find(i),0,0);
	}
	LCA::init(cur-1);
	while(q--){
		int v=read_int(),x=read_int(),k=read_int();
		int rt=LCA::query(v,x);
		if(node[root[dfn[rt][1]]].s-node[root[dfn[rt][0]-1]].s<k)
		enter(-1);
		else
		enter(b[query(root[dfn[rt][1]],root[dfn[rt][0]-1],k)]);
	}
	return 0;
}

const int MAXN=2e5+5,MAXM=4e5+5,MAXL=20;
struct Edge{
	int to,next;
}edge[MAXM<<1];
int head[MAXN],edge_cnt;
void Insert(int u,int v){
	edge[++edge_cnt]=Edge{v,head[u]};
	head[u]=edge_cnt;
}
struct Tree{
	vector<int> g[MAXN];
	int p[MAXN],anc[MAXN][MAXL],dfn[MAXN],dfe[MAXN],dfv[MAXN],type,dfs_t;
	int Find(int x){return x==p[x]?x:p[x]=Find(p[x]);}
	void dfs(int u,int fa){
		dfn[u]=++dfs_t;dfv[dfs_t]=u;anc[u][0]=fa;
		_for(i,1,MAXL){
			if(!anc[anc[u][i-1]][i-1])break;
			anc[u][i]=anc[anc[u][i-1]][i-1];
		}
		_for(i,0,g[u].size())
		dfs(g[u][i],u);
		dfe[u]=dfs_t;
	}
	void build(int n,bool flag){
		type=flag;
		_rep(i,1,n)p[i]=i;
		if(!type){
			_rep(u,1,n){
				for(int i=head[u];i;i=edge[i].next){
					int v=Find(edge[i].to);
					if(v>=u)continue;
					p[v]=u;
					g[u].push_back(v);
				}
			}
			dfs(n,0);
		}
		else{
			for(int u=n;u;u--){
				for(int i=head[u];i;i=edge[i].next){
					int v=Find(edge[i].to);
					if(v<=u)continue;
					p[v]=u;
					g[u].push_back(v);
				}
			}
			dfs(1,0);
		}
	}
	int query(int u,int k){
		if(!type){
			for(int i=MAXL-1;i>=0;i--){
				if(anc[u][i]&&anc[u][i]<=k)
				u=anc[u][i];
			}
		}
		else{
			for(int i=MAXL-1;i>=0;i--){
				if(anc[u][i]&&anc[u][i]>=k)
				u=anc[u][i];
			}
		}
		return u;
	}
}t1,t2;
struct Node{
	int sz,ch[2];
}node[MAXN*MAXL];
int root[MAXN],node_cnt;
void update(int &k,int p,int lef,int rig,int pos){
	node[k=++node_cnt]=node[p];
	node[k].sz++;
	if(lef==rig)return;
	int mid=lef+rig>>1;
	if(pos<=mid)
	update(node[k].ch[0],node[p].ch[0],lef,mid,pos);
	else
	update(node[k].ch[1],node[p].ch[1],mid+1,rig,pos);
}
int query(int k1,int k2,int ql,int qr,int vl,int vr){
	if(vl>qr||vr<ql)return 0;
	if(ql<=vl&&vr<=qr)return node[k2].sz-node[k1].sz;
	int vm=vl+vr>>1;
	return query(node[k1].ch[0],node[k2].ch[0],ql,qr,vl,vm)+query(node[k1].ch[1],node[k2].ch[1],ql,qr,vm+1,vr);
}
int main()
{
	int n=read_int(),m=read_int(),q=read_int();
	while(m--){
		int u=read_int()+1,v=read_int()+1;
		Insert(u,v);Insert(v,u);
	}
	t1.build(n,true);
	t2.build(n,false);
	_rep(i,1,n)
	update(root[i],root[i-1],1,n,t2.dfn[t1.dfv[i]]);
	while(q--){
		int be=read_int()+1,en=read_int()+1,l=read_int()+1,r=read_int()+1;
		be=t1.query(be,l),en=t2.query(en,r);
		if(query(root[t1.dfn[be]-1],root[t1.dfe[be]],t2.dfn[en],t2.dfe[en],1,n))
		enter(1);
		else
		enter(0);
	}
	return 0;
}