#include <fstream>
#include <algorithm>
#define in "radiatie.in"
#define out "radiatie.out"
#define Max_Size 15009

std :: ifstream f(in);
std :: ofstream g(out);

int N, M, K;
int T[Max_Size], Cost[Max_Size], Niv[Max_Size];

struct nod
{
    int _fnod;
    int _snod;
    int _cost;
}   A[Max_Size];

inline void Read_Data()
{
    f >> N >> M >> K;
    for(int i = 1; i <= M; ++i)     f >> A[i]._fnod >> A[i]._snod >> A[i]._cost;
}

struct cmp
{
    bool operator () (const nod &a, const nod &b)
    {
        return a._cost < b._cost;
    }
};

inline int Find(int x)
{
    int Root;
    for(Root = x; Root != T[Root]; Root = T[Root]);

    return Root;
}

inline void Nivel(int x)
{
    if(T[x] == x)   return;

    Nivel(T[x]);
    Niv[x]  = Niv[T[x]] + 1;
}

int main()
{
    Read_Data();
    std :: sort(A + 1, A + M + 1, cmp());

    for(int i = 1; i <= N; ++i) T[i] = i;

    int nr = 0;

    for(int i = 1; i <= M && nr < N; ++i)
    {
        int X = Find(A[i]._fnod);
        int Y = Find(A[i]._snod);

        if(X != Y)
        {
            ++nr;
            T[X] = Y;
            Cost[X] = A[i]._cost;
        }
    }

    for(int i = 1; i <= N; ++i)
        if(!Niv[i]) Nivel(i);

    int X, Y;
    for(int i = 1; i <= K; ++i)
    {
        f >> X >> Y;
        int Maxim = 0;

        while(Niv[X] > Niv[Y])
        {
            Maxim = std :: max(Cost[X], Maxim);
            X = T[X];
        }
        while(Niv[X] < Niv[Y])
        {
            Maxim = std :: max(Cost[Y], Maxim);
            Y = T[Y];
        }
        while(X != Y)
        {
            Maxim = std :: max(Maxim , std :: max(Cost[X], Cost[Y]));
            X = T[X];
            Y = T[Y];
        }

        g << Maxim << '\n';
    }

    g.close();
    return 0;
}