#include <bits/stdc++.h>
using namespace std;
using pii = pair<int, int>;
using edge = tuple<int, int, int>;
const int NMAX = 15e3+2;
const int LMAX = 15;
int n,m,q,niv[NMAX],up[LMAX][NMAX],mx[LMAX][NMAX];
vector<edge> edges;
vector<pii> v[NMAX];

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

struct DSU {
    int n;
    vector<int> t, sz;
    DSU(int _n){
        n = _n;
        t.resize(n+1);
        sz.resize(n+1, 1);
        for(int i = 1; i <= n; i++){
            t[i] = i;
        }
    }
    int root(int nod){
        if(t[nod] == nod){
            return nod;
        }
        return t[nod] = root(t[nod]);
    }
    void join(int x, int y){
        x = root(x);
        y = root(y);
        if(sz[x] < sz[y]){
            swap(x, y);
        }
        t[y] = x;
        sz[x] += sz[y];
    }
    bool areJoined(int x, int y){
        return root(x) == root(y);
    }
};

void dfs(int nod, int tata = -1){
    for(auto [fiu, cost]: v[nod]){
        if(fiu == tata){
            continue;
        }
        niv[fiu] = 1+niv[nod];
        up[0][fiu] = nod;
        mx[0][fiu] = cost;
        for(int i = 1; i < LMAX; i++){
            up[i][fiu] = up[i-1][up[i-1][fiu]];
            mx[i][fiu] = max(mx[i-1][fiu], mx[i-1][up[i-1][fiu]]);
        }
        dfs(fiu, nod);
    }
}

void maxSelf(int &a, int b){
    a = max(a, b);
}

int query(int x, int y){
    if(niv[y] < niv[x]){
        swap(x, y);
    }
    int ans = 0;
    int diff = niv[y]-niv[x];
    for(int i = LMAX-1; i >= 0; i--){
        if((diff>>i)&1){
            maxSelf(ans, mx[i][y]);
            y = up[i][y];
        }
    }
    if(x == y){
        return ans;
    }
    for(int i = LMAX-1; i >= 0; i--){
        if(up[i][x] != up[i][y]){
            maxSelf(ans, mx[i][x]);
            maxSelf(ans, mx[i][y]);
            x = up[i][x];
            y = up[i][y];
        }
    }
    maxSelf(ans, mx[0][x]);
    maxSelf(ans, mx[0][y]);
    return ans;
}

int main()
{
    fin >> n >> m >> q;
    for(int i = 1; i <= m; i++){
        int x, y, c;
        fin >> x >> y >> c;
        edges.push_back({c, x, y});
    }
    sort(edges.begin(), edges.end());
    DSU ds(n);
    for(auto [cost, x, y]: edges){
        if(!ds.areJoined(x, y)){
            v[x].push_back({y, cost});
            v[y].push_back({x, cost});
            ds.join(x, y);
        }
    }
    dfs(1);
    while(q--){
        int x, y;
        fin >> x >> y;
        fout << query(x, y) << "\n";
    }
    return 0;
}