#include <cstdio>
#include <algorithm.>
#include <vector>
#define IN "radiatie.in"
#define OUT "radiatie.out"
#define NMAX 30000

using namespace std;

FILE *fin = fopen(IN, "r");
FILE *fout = fopen(OUT, "w");

vector <Vecin> Gprim[NMAX];

int n, m, k, lgsol;

struct Muchie
{
    int x, y, cost;
};
Muchie muchii[NMAX];

int sol[NMAX], level[NMAX], father[NMAX], costuri[NMAX], conex[NMAX];

struct Vecin
{
    int vf, cost;
};


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

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

bool compara(struct  Muchie a, struct Muchie b)
{
    return a.cost < b.cost;
}
void Kruskal()
{
    int minim, maxim;

    sort(muchii+1, muchii+m, compara);

    for (int i=1; i<=n; i++)
        conex[i]=i;

    for (int 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)
            {
                maxim=conex[muchii[i].x];
                minim=conex[muchii[i].y];
            }

            sol[++lgsol]=i;
            for (int j=1; j<=n; j++)
                if (conex[j]==maxim)
                    conex[j]=minim;
        }
    }
}

void creare_Gprim()
{
    int Parinte, Fiu, cost; //nod parinte, nod fiu
    Vecin vecin;
    for (int i=1; i<=n-1; i++)
    {//solutie[i]=indicele muchiei

        Parinte=muchii[sol[i]].x;
        Fiu=muchii[sol[i]].y;
        cost=muchii[sol[i]].cost;

        vecin.vf=Fiu;
        vecin.cost=cost;
        Gprim[Parinte].push_back(vecin);

        vecin.vf=Parinte;
        vecin.cost=cost;
        Gprim[Fiu].push_back(vecin);
    }
}

void DFS(int nod, int parinte, int nivel, int cost)
{
    father[nod]=parinte;
    level[nod]=nivel;
    costuri[nod]=cost;

    for (int 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 rez=0;

    if (level[y] < level[x])
        swap(x, y);

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

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

int main()
{
    int x, y;

    citire();
    Kruskal();
    creare_Gprim();
    DFS(1, 0, 1, 0);

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