#include<fstream>
#include<vector>
#include<algorithm>
#include<iostream>

using namespace std;

ifstream f("radiatie.in");
ofstream g("radiatie.out");

struct Lat
{
    int a, b, c;
};

Lat V[30005];
int n, m, k, rad;
vector <pair<int, int> > G[15005];
int TT[20][15005], CC[20][15005], Log[20000], RG[15005], Level[15005], use[15005];

void citire()
{
    int i;

    f>>n>>m>>k;
    for(i=1; i<=m; i++)
        f>>V[i].a>>V[i].b>>V[i].c;

}

bool comp(Lat m, Lat n)
{
    return (m.c < n.c);
}

int stramos(int nod)
{
    while(TT[0][nod]){
        nod = TT[0][nod];
    }
    return nod;
}

int ance(int nod, int k, int & m)
{
    int red;
    while(k){
        red = Log[k];
        m = max(m, CC[red][nod]);
        nod = TT[red][nod];
        k -= 1<<red;
    }
    return nod;
}

void unite(int x, int y)
{
    if(RG[x] > RG[y])
        TT[0][y] = x;

    if(RG[y] > RG[x])
        TT[0][x] = y;

    if(RG[x] == RG[y]){
        TT[0][x] = y;
        RG[y]++;
    }
}

void DFSL(int nod, int tata) // calculeaza levele si orienteaza
{
    int i, vecin, cost;
    TT[0][nod] = tata;
    for(i=0; i<G[nod].size(); i++){
        vecin = G[nod][i].first;
        cost = G[nod][i].second;
        if(vecin != tata){
            Level[vecin] = Level[nod] + 1;
            CC[0][vecin] = cost;
            DFSL(vecin, nod);
        }
    }
}

void precalc()
{
    int i, j, x, y;

    sort(V + 1, V + m + 1, comp);

    for(i=2; i<=n; i++)
        Log[i] = Log[i/2] + 1;

    for(i=1; i<=m; i++){
        x = stramos(V[i].a);
        y = stramos(V[i].b);
        if(x != y){
            unite(x, y);
            G[V[i].a].push_back(make_pair(V[i].b, V[i].c));
            G[V[i].b].push_back(make_pair(V[i].a, V[i].c));
        }
    }

    for(i=1; i<=n; i++)
        if(TT[0][i] == 0)
            rad = i;

    DFSL(rad, 0);

    for(i=1; i<=Log[n]; i++)
        for(j=1; j<=n; j++){
            TT[i][j] = TT[i-1][TT[i-1][j]];
            CC[i][j] = max(CC[i-1][j], CC[i-1][TT[i-1][j]]);
        }
}

void LCA(int x, int y)
{
    int diff, maxi = 0, i;

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

    diff = Level[x] - Level[y];
    x = ance(x, diff, maxi);

    for(i = Log[Level[x]]; i >= 0; i--)
        if(TT[i][x] != TT[i][y]){
            maxi = max(maxi, max(CC[i][x], CC[i][y]));
            x = TT[i][x];
            y = TT[i][y];
        }
    if(x != y)
        maxi = max(maxi, max(CC[0][x], CC[0][y]));

    g<<maxi<<"\n";
}

int main()
{
    int x, y;
    citire();
    precalc();
    for(int i=1; i<=k; i++){
        f>>x>>y;
        LCA(x, y);
    }
    return 0;
}