#include <iostream>
#include <cstdio>
#include <vector>
#include <algorithm>
#define IN "radiatie.in","r"
#define OUT "radiatie.out","w"
#define dmax 5000

using namespace std;

FILE*fin=fopen(IN);
FILE*fout=fopen(OUT);

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

struct Vecin
{
    int varf, cost;
};
vector <Vecin> Gprim[dmax];

void read();
void kruskal();
bool compara(Muchie, Muchie);
void dfs(int,int,int,int);
void createGprim();
int query(int,int);

int main()
{
    int i, x, y;
    read();
    kruskal();
    createGprim();
    dfs(1,0,1,0);
    for (i=1; i<=k; i++)
    {
        fscanf(fin,"%d %d",&x,&y);
        fprintf(fout,"%d\n",query(x,y));
    }
    fclose(fout);
    return 0;
}
void read()
{
    int i;
    fscanf(fin,"%d %d %d",&n,&m,&k);
    for (i=1; i<=m; i++)
    {
        fscanf(fin,"%d %d %d",&muchii[i].x,&muchii[i].y,&muchii[i].cost);
    }
}
void kruskal()
{
    int i, minim, maxim, j;
    sort(muchii+1,muchii+m+1,compara);
    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 compara(Muchie a, Muchie b)
{
    return a.cost<b.cost;
}
void createGprim()
{
    int i;
    int nodParinte, nodFiu, cost;
    Vecin vecin;
    for (i=1; i<=lgsol; i++)
    {
        ///solutie[i]=indicele muchiei
        nodParinte=muchii[solutie[i]].x;
        nodFiu=muchii[solutie[i]].y;
        cost=muchii[solutie[i]].cost;

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

        vecin.varf=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].varf])
        {
            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;
}