#include <iostream>
#include <fstream>
#include <vector>
#include <cmath>
#include <algorithm>
using namespace std;
ifstream fin("radiatie.in");
ofstream fout("radiatie.out");
int n, m ,k;
struct elem
{
    int urm_nod, cost;
};
vector <elem> graf[15009];
struct elemMuch
{
    int nod, urm_nod, cost;
    bool operator <(const elemMuch &other)const
    {
        return cost<other.cost;
    }
};
vector <elemMuch> muchii;
int logaritm;
int tata[15009], adancime[15009], stramos[15][15009], dist[15][15009];
int nivel[15009];
int radacina(int nod)
{
    if(tata[nod]==nod)
    {
        return nod;
    }
    return tata[nod] = radacina(tata[nod]);
}
void adaug(int x, int y)
{
    x=radacina(x);
    y=radacina(y);
    if(x==y)
    {
        return;
    }
    if(adancime[x]>=adancime[y])
    {
        tata[y]=x;
    }
    else
    {
        tata[x]=y;
    }
    if(adancime[x]==adancime[y])
    {
        adancime[x]++;
    }
}
void paduri_initializare()
{
    for(int i=1;i<=n;i++)
    {
        tata[i]=i;
        adancime[i]=1;
    }
}
void apm()
{
    paduri_initializare();
    for(int i=0;i<muchii.size();i++)
    {
        //cout<<muchii[i].nod<<'\n';
        if(radacina(muchii[i].nod)!=radacina(muchii[i].urm_nod))
        {
            elem nou;
            nou.urm_nod = muchii[i].nod;
            nou.cost = muchii[i].cost;
            graf[muchii[i].urm_nod].push_back(nou);

            nou.urm_nod = muchii[i].urm_nod;
            nou.cost = muchii[i].cost;
            graf[muchii[i].nod].push_back(nou);

            adaug(muchii[i].nod,muchii[i].urm_nod);
        }
    }
}
void dfs(int nod, int niv)
{
    nivel[nod] = niv;
    for(int i=0;i<graf[nod].size();i++)
    {
        if(stramos[0][graf[nod][i].urm_nod]==0)
        {
            stramos[0][graf[nod][i].urm_nod]=nod;
            dist[0][graf[nod][i].urm_nod]=graf[nod][i].cost;
            dfs(graf[nod][i].urm_nod, niv+1);
        }
    }
}
void form_stramosi(int nod)
{
    stramos[0][1]=1;
    dist[0][1]=0;
    dfs(1,1);
    for(int log=1;log<=logaritm;log++)
    {
        for(int i=1;i<=n;i++)
        {
            stramos[log][i] = stramos[log-1][stramos[log-1][i]];
            dist[log][i] = max(dist[log-1][i],
                    dist[log-1][stramos[log-1][i]]);
        }
    }
}
int egalizare(int& a, int& b)
{
    int dif = nivel[b] - nivel[a];
    int logaritm = log2(n);
    int stram=b, dist_max_curent=-1;
    for(int i=logaritm;i>=0;i--)
    {
        int putere = (1<<i);
        if(putere<=dif)
        {
            dif-=putere;
            dist_max_curent= max(dist_max_curent,dist[i][stram]);
            stram = stramos[i][stram];
        }
    }
    b=stram;
    return dist_max_curent;
}

int lca(int a, int b)
{
    if(nivel[a]>nivel[b])
    {
        int aux = a;
        a = b;
        b = aux;
    }
    int dist_max = 0;

    if(nivel[a]!=nivel[b])
    {
        //cout<<nivel[a]<<' '<<nivel[b]<<' ';
        dist_max = egalizare(a,b);
        //cout<<dist_max<<'\n'; // nu se modif distmax - devine 0
    }                              // dist_max cred ca arata altceva
    int stram_a = a, stram_b = b;  //lca busit
    if(stram_a==stram_b)
    {
        return dist_max;
    }
    int logaritm = log2(n);
    for(int i=logaritm;i>=0;i--)
    {
        if(stramos[i][stram_a]!=stramos[i][stram_b])
        {
            dist_max = max(dist_max, dist[i][stram_a]);
            dist_max = max(dist_max, dist[i][stram_b]);
            stram_a = stramos[i][stram_a];
            stram_b = stramos[i][stram_b];
        }
    }
    dist_max = max(dist_max, dist[0][stram_a]);
    return max(dist_max, dist[0][stram_b]);
}

int main()
{
    fin>>n>>m>>k;
    logaritm = log2(n);
    for(int i=1;i<=m;i++)
    {
        int x , y , c;
        fin>>x>>y>>c;

        elemMuch muchie;
        muchie.nod = x;
        muchie.urm_nod = y;
        muchie.cost = c;
        muchii.push_back(muchie);
    }

    sort(muchii.begin(),muchii.end());

    apm();

    form_stramosi(1);


    for(int test=1;test<=k;test++)
    {
        int x, y;
        fin>>x>>y;
        fout<<lca(x,y)<<'\n';
    }
    return 0;
}