#include <bits/stdc++.h>

using namespace std;

ifstream f ("radiatie.in");
ofstream g ("radiatie.out");

const int NMAX = 15e3;
const int MUCMAX = 3e4;

struct marcel{
    
    int nod, cost;
    
};

vector<marcel> adj[NMAX+1];

struct ura{
    
    int cost, a, b;
    
};

ura muchii[MUCMAX+1];
int tata[NMAX+1];

int n, m, k;

bool cmp(ura a, ura b){
    
    return a.cost < b.cost;
    
}

int sef(int x){
    
    if(tata[x] == x)
        return x;
        
    return tata[x] = sef(tata[x]);
    
}

void uneste(int x, int y){
    
    tata[sef(x)] = sef(y);
    
}

bool marked[NMAX+1];
int nivel[NMAX+1];
int costt[NMAX+1];

void dfs(int nod, int niv, int last, int cost){
    
    marked[nod] = true;
    nivel[nod] = niv;
    tata[nod] = last;
    costt[nod] = cost;
    
    for(auto pair : adj[nod]){
        
        if(!marked[pair.nod])
            dfs(pair.nod, niv + 1, nod, pair.cost);
        
    }
    
}

int str[15][NMAX + 1];
int rmq[15][NMAX + 1];

void calcul(){
    
    for(int i=1; i<=n; i++){
        
        str[0][i] = tata[i];
        rmq[0][i] = costt[i];
    }
    
    for(int i = 1; (1 << i) <= n; i ++)
        for(int j = 1; j <= n; j ++){
            
            str[i][j] = str[i-1][str[i-1][j]];
            rmq[i][j] = max(rmq[i-1][j], rmq[i-1][str[i-1][j]]);
            
        }
        
    
}

int urc(int nod, int h){
    
    int hmax = log2(h);
    
    for(int i=hmax; i>=0; i--){
        
        if(h >= (1 << i)){
            
            h -= (1 << i);
            nod = str[i][nod];
            
        }
        
    }
    
    return nod;
    
}

int lca(int a, int b){
    
    int h = abs(nivel[a] - nivel[b]);
        
    
    if(nivel[a] > nivel[b])
        a = urc(a, h);
        
    else b = urc(b, h);
        
    if(a == b)
        return a;
        
    
    int hmax = log2(NMAX);
    
    for(int i = hmax; i >= 0; i --){
        
        if(str[i][a] != str[i][b]){
            
            a = urc(a, (1 << i));
            b = urc(b, (1 << i));
            
        }
        
    }
    
    return str[0][a];
    
    
}

int dp[NMAX+1];

map<pair<int, int>, int> cmap;

void calcul_dp(int nod){
    
    if(adj[nod].size() == 1 and nivel[adj[nod][0].nod] < nivel[nod]){ // e frunza gen -- va dau mintea mea
        
        int val = adj[nod][0].cost;
        
        dp[nod] = val;
        
        //cout << val << endl;
        
        return ;
        
    } 
        
    
    for(auto next : adj[nod]){
        
        if(nivel[next.nod] > nivel[nod]){
            
            dp[nod] = max(dp[nod], next.cost);
            
            if(dp[next.nod] == 0)
                calcul_dp(next.nod);
                
            dp[nod] = max(dp[nod], dp[next.nod]);
            
        }
        
    }
    
}

int val(int nod, int h){
    
    int hmax = log2(h);
    int mx = 0;
    
    for(int i=hmax; i>=0; i--){
        
        if(h >= (1 << i)){
            
            h -= (1 << i);
           
            mx = max(mx, rmq[i][nod]);
           
            nod = str[i][nod];
            
            
            
        }
        
    }
    
    return mx;
    
}

int main()
{
    
    f >> n >> m >> k;
    
    for(int i=1; i<=n; i++)
        tata[i] = i;
    
    for(int i=1; i<=m; i++){
        
        int a, b, cost;
        f >> a >> b >> cost;
        
        muchii[i] = {cost, a, b};
        
        // cmap[{a, b}] = cost;
        // cmap[{b, a}] = cost;
        
    }
    
    
    sort(muchii + 1, muchii + 1 + m, cmp);
    
    int cnt = 0;
    
    for(int i=1; i<=m; i++){
        
        ura val = muchii[i];
        
        if(sef(val.a) != sef(val.b)){
            
            
            uneste(val.a, val.b);
            
            adj[val.a].push_back({val.b, val.cost});
            adj[val.b].push_back({val.a, val.cost});
            
            cnt ++;
            
        }
        
    }
    
    dfs(1, 1, 0, 0);
    
    calcul();

    //cout << val(6, 0);
    
    for(int i=1; i<=k; i++){
        
        int x, y;
        f >> x >> y;
        
        int l = lca(x, y);
        
        g << max(val(x, -nivel[l] + nivel[x]), val(y, - nivel[l] + nivel[y])) << "\n";
        
    }
    
    
    // for(int i=1; i<=n; i++)
    //     cout << i << ' ' << nivel[i] << ' ' << tata[i] << endl;

    return 0;
}