#include <fstream>
#include <cstdio>
#include <vector>
#include <algorithm>
#define NMAX 30005

using namespace std;

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

void citire();
void kruskal();
bool cmp(struct muchie, struct muchie);
void creat_gprim();
void dfs(int nod, int parinte, int nivel, int cost);
int query (int x, int y);

int n, m, k, lgsol;
struct muchie{int x, y, cost;};
muchie muchii[NMAX];
int solutie[NMAX];
int conex[NMAX];
int level[NMAX], father[NMAX], costuri[NMAX];

struct vecin{int varf, cost;};
vector <vecin> gprim[NMAX];

int main()
{
    int i, x, y;
    citire();
    kruskal();
    creat_gprim();
    dfs(1, 0, 1, 0);
    for(i=1; i<=k; i++)
        {
        fscanf(fin, "%d %d\n", &x, &y);
        fprintf(fout, "%d\n", query(x, y));
        }
    return 0;
}
void citire()
{
    int i;
    fscanf(fin, "%d %d %d\n", &n, &m, &k);
    for(i=1; i<=m; i++)
        {
        fscanf(fin, "%d %d %d\n", &muchii[i].x, &muchii[i].y, &muchii[i].cost);
        }
}
void kruskal()
{
    int i, j, minim, maxim;
    sort(muchii+1, muchii+1+m, cmp);
    for (i=1; i<=n; ++i)
        conex[i]=i;
    for (i=1; i<=m && lgsol<n-1; ++i)
        if(conex[muchii[i].x]!=conex[muchii[i].y])
            {
            minim=conex[muchii[i].x];
            maxim=conex[muchii[i].y];
            if(maxim<minim)
                {
                maxim=conex[muchii[i].x];
                minim=conex[muchii[i].y];
                }
            solutie[++lgsol]=i;
            for(j=1; j<=n; j++)
                if(conex[j]==maxim)
                    conex[j]=minim;
            }
}
bool cmp(struct muchie a, struct muchie b)
{
    return a.cost<b.cost;
}
void creat_gprim()
{
    int i, nodparinte, nodfiu, cost;
    vecin v;
    for(i=1; i<=n-1; i++)
        {
        nodparinte=muchii[solutie[i]].x;
        nodfiu=muchii[solutie[i]].y;
        cost=muchii[solutie[i]].cost;
        v.varf=nodfiu;
        v.cost=cost;
        gprim[nodparinte].push_back(v);
        v.varf=nodparinte;
        v.cost=cost;
        gprim[nodfiu].push_back(v);
        }
}
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].varf]==0)
            dfs(gprim[nod][i].varf, 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;
}