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

using namespace std;

ifstream fin("radiatie.in");
ofstream fout("radiatie.out");
const int NMAX = 30005;

struct muchie
{
    int u, v, c;
};

muchie x[NMAX];
int n, m, k, t[15005], h[15005];//t[x] contine tatl lui x si h[x] contine inaltimea pana la nodul x
int mare[15005], in_coada[15005];
vector< pair<int, int> > list_vec[15005];

struct comp
{
    bool operator() (int x, int y)
    {
        mare[x] > mare[y];
    }
};
int varf(int x)
{
    while(t[x] != x)
        x = t[x];//ii aflam tatal lui
    return x;
}

void unire(int x, int y) // unim cele doua varfuri ale arborilor
{
    if(h[x] > h[y])
        t[y] = x; //tatal lui y devine x
    else
    {
        if(h[x] < h[y])
            t[x] = y; //tatal lui x devine y
        else //egale
        {
            t[y] = x;
            ++h[x];
        }
    }
}//unim doi arbori

bool cmp(muchie a, muchie b)
{
    return a.c<b.c;
}

void drum_minim(int start, int stop)
{
    priority_queue<int, vector<int>, comp> pq;
    int curent, vecin, cost, i, maxi;

    for(i = 1; i <= n; ++i)
    {
        mare[i] = -1;
        in_coada[i] = 0;
    }

    mare[start] = 0;
    pq.push(start);
    in_coada[start] = 1;

    while(!pq.empty())
    {
        curent = pq.top();
        pq.pop();
        in_coada[curent] = 0;
        for(auto i : list_vec[curent])
        {
            vecin = i.first;
            cost = i.second;
            maxi = max(mare[curent], cost);

            if(mare[vecin] == -1 || mare[vecin] > maxi)
            {
                mare[vecin] = maxi;
                if(!in_coada[vecin])
                {
                    pq.push(vecin);
                    in_coada[vecin] = 1;
                }
            }
        }
    }

    fout<<mare[stop]<<'\n';
}

int main()
{
    int i, u, v;
    fin>>n>>m>>k;
    for(i = 1; i <= n; ++i)
        t[i] = i, h[i] = 1;//initial fiecare nod are distanta de la el la varf de 1 si tatal el insusi

    for(i = 1; i <= m; i++)
    {
        fin>>x[i].u>>x[i].v>>x[i].c;
        x[i+m].v = x[i].u;
        x[i+m].u = x[i].v;
        x[i+m].c = x[i].c;
    }

    sort(x + 1, x + 2*m + 1, cmp); //sortez muchiile in functie de cost
    int rx, ry, ms;
    for(ms = 0, i = 1; ms < n-1 && i <= 2*m; ++i)//care se intampla prima, 1 punem toate cele n-1 muchii necesare arborelui, 2 terminam cele m muchii(in caz ca graful initial nu e conex)
    {
        rx = varf(x[i].u);
        ry = varf(x[i].v);
        if(rx != ry)
        {
            unire(rx, ry); // unim cele doua noduri
            list_vec[x[i].u].push_back({x[i].v, x[i].c});
            list_vec[x[i].v].push_back({x[i].u, x[i].c});
            ++ms;//ms este numarul de muchii pe care le are arborele pe parcurs
        }
    }

    for(i = 1; i <= k; ++i)
    {
        fin>>u>>v;
        drum_minim(u, v);
    }

    return 0;
}