//radiatie -- 30pct (time limit) -- lower video
#include <bits/stdc++.h>
using namespace std;

ifstream fin("radiatie.in");
ofstream fout("radiatie.out");

int i, j, n, m, p, T[450000], Rang[450000], g, c1[35001], c2[35001], nr[35002];
int minn[35001];
 
typedef struct poz{
    int cost;
    int nod1, nod2;  
 }student;
 
 
typedef struct poz1{
    int first, second;  
 }student1;
 
 
 vector<pair<int , int>>adj[40004];
student v[40004];
student1 K[40004];

int Radacina(int k){
    if(T[k] == k)
        return k;
    else
    {
        int r = Radacina(T[k]);
        T[k] = r;
        return r;
    }
}


void Unire(int k, int p)
{
    int rk = Radacina(k), rp = Radacina(p);
    if(rk != rp)
    {
        if(Rang[rk] > Rang[rp])
            T[rp] = rk;
        else
        {
            T[rk] = rp;
            if(Rang[rk] == Rang[rp])
                Rang[rp] ++;
        }
    }
    
}


void dfs(int r){
    nr[r]=1;
    
    if(r==K[i].second) return;
    
    for(auto vecin:adj[r]){
        
        if(nr[vecin.first]==0){
            if(vecin.second>minn[r]){
                minn[vecin.first]=vecin.second;
            }else{
                minn[vecin.first]=minn[r];
            }
            
            dfs(vecin.first);
        }
    }
    
}

void reset(int r){
    nr[r]=0;
    for(auto vecin:adj[r]){
        if(nr[vecin.first]==1){
            minn[vecin.first]=-99999;
            nr[vecin.first]=0;
            reset(vecin.first);
        }
    }
}


bool compare(student a, student b){
    if(a.cost<b.cost){
        return 1;
    }else{
        return 0;
    }
}




int main()
{
    
    fin>>n>>m>>p;
    
    for(i=1;i<=m;i++)
    {
        fin>>v[i].nod1>>v[i].nod2>>v[i].cost;
    }
    
    for(i=1;i<=p;i++)
    {
        fin>>K[i].first>>K[i].second;
    }
    
    for(i=1;i<=n;i++){
        T[i]=i;
        Rang[i]=i;
    }

    
    sort(v+1 , v+m+1 , compare);

    //creare arbore
    
        for(j=1;j<=m;j++)
        {
            if(Radacina(v[j].nod1)!=Radacina(v[j].nod2)){
                Unire(v[j].nod1 , v[j].nod2);
                adj[v[j].nod1].push_back( {v[j].nod2 , v[j].cost} );
                adj[v[j].nod2].push_back( {v[j].nod1, v[j].cost} );
            }

        }
    
    
    //lowest common ancestor
    
        for(i=1;i<=p;i++){
            
            //minn[K[i].first]=9999;
            dfs(K[i].first);
            
            fout<<minn[K[i].second]<<endl;
            
            //reset
            reset(K[i].first);
        }
    
    

  
    
    
}