#include <cstdio>
#include <vector>
#include <algorithm>
#define DMAX 1005
using namespace std;
FILE * fin = fopen ("radiatie.in", "r");
FILE * fout = fopen ("radiatie.out", "w");

struct muchie {int x, y, cost;};
struct vecin {int varf, cost;};

void read();
void kruskal();
bool cmp(muchie a, muchie b)
{return a.cost<b.cost;};
void creazaGprim();
void DFS(int, int, int, int);
int query(int, int);
void rez();

int n, m, k;
int conex[DMAX];

muchie muchii[DMAX];
int solutie[DMAX], lgsol;

vector <vecin> Gprim[DMAX];

int level[DMAX], father[DMAX], costuri[DMAX];

int main()
{
    read();
    kruskal();
    creazaGprim();
    DFS(1, 0, 1, 0);
    rez();
    
    fclose(fin);
    fclose(fout);
    return 0;
}

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

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;
}

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);
}

void creazaGprim()
{
    int i;
    int parinte, fiu, cost;
    vecin vecin;
    
    for (i=1; i<=n-1; i++)
    {
        parinte = muchii[solutie[i]].x;
        fiu = muchii[solutie[i]].y;
        cost = muchii[solutie[i]].cost;
        
        vecin.varf = fiu;
        vecin.cost = cost;
        Gprim[parinte].push_back(vecin);
        
        vecin.varf = parinte;
        vecin.cost = cost;
        Gprim[fiu].push_back(vecin);
    }
}

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; i++)
        if (conex[muchii[i].x]!=conex[muchii[i].y])
        {
            minim = conex[muchii[i].x];
            maxim = conex[muchii[i].y];
            if (maxim<minim)
            {
                minim = conex[muchii[i].y];
                maxim = conex[muchii[i].x];
            }
            solutie[++lgsol]=i;
            for (j=1; j<=n; j++)
                if (conex[j]==maxim)
                    conex[j]=minim;
        }
}

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);
    }
}