#include <fstream>
#include <cstdio>
#include <vector>
#include <algorithm>
#define NMAX 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;
    int cost;
};
Muchie muchii[NMAX];
int solutie[NMAX], lgsol;
int cnx[NMAX];
int level[NMAX], father[NMAX], costuri[NMAX];
vector <Vecin> Gprim[NMAX];
int n, m, k;

void citire();
void Kruskal();
bool cmp (struct Muchie, struct Muchie);
void createGprim();
void DFS (int nod, int parinte, int nivel, int cost);
int query (int x, int y);

int main()
{
    int i, x, y;
    citire();
    Kruskal();
    createGprim();
    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));
    }
    fclose (fin);
    fclose (fout);
    return 0;
}

void citire()
{
    fscanf (fin, "%d %d %d\n", &n, &m, &k);
    int i;
    for (i=1; i<=m; ++i)
    {
        fscanf(fin, "%d %d %d\n", &muchii[i].x, &muchii[i].y, &muchii[i].cost);
    }

    return;
}

void Kruskal()
{
    int i, j, minim, maxim;
    sort (muchii+1, muchii+1+m, cmp);
    for (i=1; i<=n; ++i)
        cnx[i]=i;
    for (i=1; i<=m && lgsol<n-1; ++i)
        if (cnx[muchii[i].x]!=cnx[muchii[i].y])
        {
            minim=cnx[muchii[i].x];
            maxim=cnx[muchii[i].y];
            if (maxim<minim)
            {
                maxim=cnx[muchii[i].x];
                minim=cnx[muchii[i].y];
            }
            solutie[++lgsol]=i;
            for (j=1; j<=n; ++j)
                if (cnx[j]==maxim)
                    cnx[j]=minim;
        }
    return;
}

bool cmp (struct Muchie a, struct Muchie b)
{
    return a.cost<b.cost;
}
//*
void createGprim()
{
    int i;
    int nodParinte, nodFiu, cost;
    Vecin vecin;
    for (i=1; i<n; ++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;

        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]==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, costuri[y]);
        rezultat = max (rezultat, costuri[x]);
        y=father [y];
        x=father [x];
    }
    return rezultat;
}