#include <fstream>
#include <cstdio>
#include <vector>
#include <algorithm>
#define NMAX 30001
using namespace std;

FILE * fin = fopen("radiatie.in","r");
FILE * fout = fopen("radiatie.out", "w");

int n, m, k;
struct Muchie{
    int x,y,cost;
};
Muchie G[NMAX];
int conex[NMAX], sol[NMAX], cost_apm, costuri[NMAX];
int nrm;
int level[NMAX], father[NMAX];

struct vecin{
    int vf;
    int cost;

};
vector<vecin> Gprim[NMAX];

void init();
void kruskall();
bool crit(Muchie, Muchie);
void createGprim();
void DFS(int nod, int parinte, int nivel, int cost);
int query(int x, int y);

int main(){

    init();
    kruskall();
    createGprim();
    DFS(1, 0, 1, 0);

    int i, x, y;
    for(i = 1; i<= k; ++i){
        fscanf(fin, "%d %d\n", &x, &y);
        fprintf(fout, "%d\n", query(x,y));
    }

    return 0;
}

void init(){
    fscanf(fin,"%d %d %d\n", &n, &m, &k);
    int i;

    for(i = 1; i<= m ; ++i){
        fscanf(fin,"%d %d %d\n", &G[i].x, &G[i].y, &G[i].cost );

    }
}

void kruskall(){
  int i, minim, maxim, j;

  sort(G+1, G+n+1,crit);
  for(i = 1; i<=n; ++i) conex[i] = i;

  for( i = 1; nrm <= n-1; ++i){
        if(conex[ G[i].x ] != conex[ G[i].y ]){
            if( conex[ G[i].x ] < conex[ G[i].y ] ){
                 minim = conex[ G[i].x ];
                 maxim = conex[ G[i].y ];
            } else {
                 minim = conex[ G[i].y ];
                 maxim = conex[ G[i].x ];
            }
            sol[++nrm] = i;
            for(j  = 1; j<=n; ++j)
                    if(conex[j] == maxim) conex[j] = minim;
        }
  }

}

bool crit(Muchie M1, Muchie M2){
    return M1.cost < M2.cost;
}

void createGprim(){
    int i;
    int nodParinte, nodFiu, cost;
    vecin vecin;
    for(i = 1; i <= n-1; ++i){
        //sol[i] = indice muchie
        nodParinte = G[ sol[i] ].x;
        nodFiu = G[ sol[i] ].y;
        cost = G[ sol[i] ].cost;

        vecin.vf = nodFiu;
        vecin.cost = cost;
        Gprim[nodParinte].push_back(vecin);

        vecin.vf = nodParinte;
        vecin.cost = cost;
        Gprim[nodFiu].push_back(vecin);
    }
}

void DFS(int nod, int parinte, int nivel, int cost){
    int i;

    father[ nod ] = parinte;
    level[ nod ] = nivel;
    costuri[nod] = cost;
    for(i = 0; i < Gprim[nod].size(); ++i){
        if(level[ Gprim[nod][i].vf ] == 0 )
                DFS( Gprim[nod][i].vf, nod, nivel+1, Gprim[nod][i].cost);
    }
}

int query(int x, int y){
    int rezultat = 0;
    if(level[y] < level[x]) swap(x,y);

    while(level[y] != level[x]){
        rezultat = max(rezultat, costuri[y]);
        y = father[y];
    }
    while(x != y){
        rezultat = max(rezultat, max(costuri[x],costuri[y]));
        x = father[x];
        y = father[y];
    }
    return rezultat;

}