#include <bits/stdc++.h>

using namespace std;

const int N = 15001, E = 17, INF = 1e9;

struct str{
    int nod;
    long long cost;

    bool operator < (const str& aux) const{
        return cost > aux.cost;
    }
};
vector<pair<int, int>> adj[N];
vector<pair<int, int>> mc[N];
int n, m, q, x, y, cost;
int ult[N], ult_cost[N], d[N];
bool uz[N];
vector<pair<int, int>> apm[N];
int anc[E][N], mn[E][N], lg[N], lvl[N];

void prim(){
    priority_queue<str> pq;
    for (int i = 1; i <= n; ++i){
        if(!uz[i]){
            pq.emplace(i, 0);
            d[i] = 0;

            while(!pq.empty()){
                auto [nod, cost] = pq.top();
                pq.pop();

                if(uz[nod])
                    continue;
                uz[nod] = 1;
                // apm[nod].emplace_back(ult[nod], ult_cost[nod]);
                anc[0][nod] = ult[nod];
                mn[0][nod] = ult_cost[nod];
                lvl[nod] = lvl[ult[nod]] + 1;

                for(auto& f:adj[nod]){
                    if(uz[f.first])
                        continue;
                    if(d[f.first] > f.second){
                        d[f.first] = f.second;
                        ult[f.first] = nod;
                        ult_cost[f.first] = f.second;
                        pq.emplace(f.first, d[f.first]);
                    }
                }
            }
        }
    }
}

void get_anc_mn(int &x, int ord, int &maximum){

    for (int bit = 0; (1 << bit) <= ord; ++bit) {
        if(ord & (1<<bit)){
            maximum = max(maximum, mn[bit][x]);
            x = anc[bit][x];
        }
    }
}

void lca(int x, int y, int &maximum){
    int ord = lg[lvl[x]];

    while(ord >= 0){
        if(anc[ord][x] != anc[ord][y]){
            maximum = max(maximum, max(mn[ord][x], mn[ord][y]));

            x = anc[ord][x];
            y = anc[ord][y];
        }
        --ord;
    }
    maximum = max(maximum, max(mn[0][x], mn[0][y]));
}


int main()
{
    freopen("radiatie.in", "r", stdin);
    freopen("radiatie.out", "w", stdout);
    ios::sync_with_stdio(false);
    cin.tie(0);

    for (int i = 1; i < N;++i)
        d[i] = INF;
    for (int i = 2; i < N;++i)
        lg[i] = lg[i / 2] + 1;
    for (int e = 0; e < E;++e){
        for (int i = 0; i < N;++i){
            mn[e][i] = INF;
        }
    }
    lvl[0] = -1;

    cin >> n >> m >> q;
    for (int i = 1; i <= m;++i){
        cin >> x >> y >> cost;
        adj[x].emplace_back(y, cost);
        adj[y].emplace_back(x, cost);
    }

    prim();

    // for (int i = 1; i <= n;++i){
    //     cout << i << anc[0][i]<<' '<<mn[0][i]<<'\n';
    // }

    for (int e = 1; e < E;++e){
        for (int i = 1; i <= n;++i){
            anc[e][i] = anc[e - 1][anc[e - 1][i]];
            mn[e][i] = max(mn[e - 1][i], mn[e - 1][anc[e - 1][i]]);
        }
    }

    while(q--){
        cin>>x>>y;

        int maximum = -1;
        
        if(lvl[x] < lvl[y]){
            get_anc_mn(y, lvl[y]-lvl[x], maximum);
        }
        else if(lvl[y] < lvl[x]){
            get_anc_mn(x, lvl[x]-lvl[y], maximum);
        }

        if(x==y){
            cout<<maximum<<'\n';
        }
        else{   
            lca(x, y, maximum);
            cout<<maximum<<'\n';
        }
    }

    return 0;
}