#include <bits/stdc++.h>
using namespace std;
#define NMAX 100005

struct vert{
    int left, right, cost;
}g[1*NMAX];


int tatic[NMAX], len[NMAX];

int getRoot(int node){
    while (tatic[node]>0)
        node = tatic[node];
    return node;
}

void uniteTrees(int l, int r){
    int x = getRoot(l),
        y = getRoot(r);
    if (-tatic[x]>-tatic[y]) {
        tatic[x] += tatic[y];
        tatic[y]=x;
    }
    else {
        tatic[y]+=tatic[x];
        tatic[x]=y;
    }
}

bitset<100001> vf;
int dp[NMAX], niv[NMAX], t[NMAX];
vector<pair<int,int>> graf[NMAX];
void dfs(int nod, int tata){
    vf[nod] = 1;
    niv[nod] = niv[tata] + 1;
    for(auto fiu: graf[nod]){
        if(vf[fiu.first] == 0){
            dp[fiu.first] = fiu.second;
            t[fiu.first] = nod;
            dfs(fiu.first, nod);
        }
    }
}

int main(void){
    /// kruskal's algorithm
    ofstream cout("radiatie.out");
    ifstream cin("radiatie.in");
    int n, m = 0, q;
    cin >> n >> m >> q;
    for(int i = 1;i<=n;i++){
        tatic[i] = -1;
    }
    for(int i = 1;i<=m;i++){
        cin >> g[i].left >> g[i].right >> g[i].cost;
    }
    sort(g + 1, g + m + 1, [&](vert x, vert y) ->bool {
        return x.cost < y.cost;
    });
    int ii = 1, nr = 1;
    while(nr <= n - 1){
        ///cout << g[i].left << ' ' << g[i].right << ' ' << g[i].cost << '\n';
        /// avem mai multe cazuri , case 1 : unu dintre noduri este intr un arbore asadar il bagam si pe el doar daca nu face ciclu
        int xx = getRoot(g[ii].left),
            yy = getRoot(g[ii].right);
        if(xx != yy){
            nr++;
            /// nu sunt din acelasi union asa ca facem unul
            graf[g[ii].left].push_back({g[ii].right, g[ii].cost});
            graf[g[ii].right].push_back({g[ii].left, g[ii].cost});
            uniteTrees(g[ii].left, g[ii].right);
        }
        ii++;
    }
    //t[1]
    for( int i = 1;i<=n;i++){
        t[i] = -1;
    }
    dfs(1,0);
    while(q--){
        int st, dr;
        cin >> st >> dr;
        int ans = 0;
        if(niv[st] < niv[dr]){
            swap(st,dr);
        }
        while(niv[st] > niv[dr]){
            ans = max(ans,dp[st]);
            st = t[st];
        }
        while(st != dr){
         //   cout << st << '\n';
            ans = max(ans, max(dp[st], dp[dr]));
            st = t[st];
            dr = t[dr];
        }
        cout << ans  << '\n';

    }

    return 0;
}