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

using namespace std;

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

struct Muchie
{
    int x, y, cost;
};

struct Vecin
{
    int vf, cost;
};

Muchie M[NMAX];
vector <Vecin> Gprim[NMAX];
int sol[NMAX];
int n, m, k, nr;
int cnx[NMAX], level[NMAX], father[NMAX], costuri[NMAX];


void citire ();
void kruskal();
void creareGprim ();
void dfs(int nod, int parinte, int nivel, int cost);
bool cmp (struct  Muchie a, struct Muchie b);
int query(int x, int y);

int main()
{
    int i, x, y;
    citire();
    kruskal();
    creareGprim();
    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", &M[i].x, &M[i].y, &M[i].cost);
    }
}

void kruskal()
{
    sort (M+1, M+1+m, cmp);
    int i, j, minim, maxim;
    for(i=1; i<=n; ++i)
        cnx[i]=i;
    for(i=1; i<m && nr<n; ++i)
    {
        if(cnx[M[i].x]!=cnx[M[i].y])
        {
            minim=cnx[M[i].x];
            maxim=cnx[M[i].y];
            if(maxim<minim)
            {
                minim=cnx[M[i].y];
                maxim=cnx[M[i].x];
            }
            sol[++nr]=i;
            for(j=1; j<=n; ++j)
                if(cnx[j]==maxim)
                cnx[j]=minim;
        }
    }
}

bool cmp (struct  Muchie a, struct Muchie b)
{
    return a.cost<b.cost;
}

void creareGprim ()
{
    int i;
    int nodParinte, nodFiu, cost;
    Vecin vecin;
    for (i=1; i < n; i++)
    {
        //sol[i]=indicele muchiei
        nodParinte = M[sol[i]].x;
        nodFiu = M[sol[i]].y;
        cost = M[sol[i]].cost;

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

        vecin.vf=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].vf])
        {
            dfs(Gprim[nod][i].vf, nod, nivel+1, Gprim[nod][i].cost);
        }
}

int query(int x, int y)
{
    int rezultat=0;
    if(level [x] > level [y])
        swap(x, y); //schimb x cu 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;
}