#include <bits/stdc++.h>

using namespace std;

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

const int NMAX = 15005;
const int LMAX = 10;
const int inf = 1e9;
int n,m,Q;
int dist[NMAX],viz[NMAX], from[NMAX], grad[NMAX], father[NMAX];
vector < pair < int, int > > v[NMAX], nv[NMAX];
priority_queue < pair < int, int > > q;

int k,euler[2 * NMAX], lvl[NMAX], pos[NMAX];
int rmq[LMAX][2 * NMAX], lg[2 * NMAX];

void dfs(int node, int level){
    euler[++k] = node;
    lvl[node] = level;
    pos[node] = k;
    for(auto it : nv[node])
        if(!lvl[it.first]){
            father[it.first] = node;
            dfs(it.first, level + 1);
            euler[++k] = node;
        }
}

void buildRMQ(){
    int i,j;
    for(i = 1 ; i <= k ; i++)
        rmq[0][i] = euler[i];

    for(i = 2 ; i <= k ; i++)
        lg[i] = lg[i / 2] + 1;

    for(i = 1 ; i <= lg[k] ; i++)
        for(j = 1 ; j <= k - (1 << i) ; j++){
            rmq[i][j] = rmq[i - 1][j];
            if(lvl[rmq[i - 1][j + (1 << (i - 1))]] < lvl[rmq[i - 1][j]])
                rmq[i][j] = rmq[i - 1][j + (1 << (i - 1))];
        }
}

int lca(int x, int y){
    x = pos[x];
    y = pos[y];
    if(x > y)
        swap(x,y);
    int dif = y - x + 1, l = lg[dif];
    if(lvl[rmq[l][x]] < lvl[rmq[l][y - (1 << l) + 1]])
        return rmq[l][x];
    return rmq[l][y - (1 << l) + 1];
}

int main(){
    int i,j,x,y,z,node;
    f >> n >> m >> Q;
    for(i = 1 ; i <= m ; i++){
        f >> x >> y >> z;
        v[x].push_back({y, z});
        v[y].push_back({x, z});
    }

    for(i = 1 ; i <= n ; i++)
        dist[i] = inf;

    q.push({0,1});
    from[1] = -1;
    while(!q.empty()){
        node = q.top().second;
        q.pop();

        if(viz[node])
            continue;
        viz[node] = 1;

        if(from[node] != -1){
            nv[node].push_back({from[node], dist[node]});
            nv[from[node]].push_back({node, dist[node]});
        }

        for(auto it: v[node]){
            if(viz[it.first]) continue;
            if(dist[it.first] > it.second){
                dist[it.first] = it.second;
                from[it.first] = node;
                q.push({-it.second, it.first});
            }
        }

    }

    dfs(1,1);
    buildRMQ();

    while(Q--){
        f >> x >> y;
        int l = lca(x,y), ans = 0;
        while(x != l){
            ans = max(ans, dist[x]);
            x = father[x];
        }
        while(y != l){
            ans = max(ans, dist[y]);
            y = father[y];
        }
        g << ans << "\n";
    }

    return 0;
}