#include <bits/stdc++.h>
#define NMAX 15001

using namespace std;

ifstream fin("radiatie.in") ;
ofstream fout("radiatie.out") ;

vector<pair<pair<int,int>,int> >edge ;
vector<pair<int,int> > graf[NMAX] ;
int parinte[NMAX] , r[NMAX] , cost[NMAX] , nivel[NMAX] , tata[NMAX] ;
int n , m , k , maxm ;
bool viz[NMAX] ;

bool compar ( pair<pair<int,int>,int> p1 , pair<pair<int,int>,int> p2 )
{
    return p1.second < p2.second ;
}

void citire()
{
    int i , z , y , x ;
    fin >> n >> m >> k ;
    for ( i = 1 ; i <= m ; i++ )
    {
        fin >> x >> y >> z ;
        edge.push_back(make_pair(make_pair(x,y),z)) ;
    }
    sort(edge.begin(),edge.end(),compar) ;
    memset(r,0,4*n+4) ;
}

int root(int x)
{
    while ( x != parinte[x] )
        x = parinte[x] ;
    return x ;
}

void unite(int x , int y,int val)
{
    if ( r[x] < r[y] )
    {
        cost[x] = val ;
        parinte[x] = y ;
    }
    else if ( r[x] > r[y] )
    {
        parinte[y] = x ;
        cost[y] = val ;
    }
    else if ( r[x] == r[y] )
    {
        parinte[y] = x ;
        r[x]++ ;
    }
}

void solve()
{
    int i , r1 ,r2 ;
    for ( i = 1 ; i <= n ; i++ )
        parinte[i] = i ;
    for ( i = 0 ; i < m ; i++ )
    {
        r1 = root(edge[i].first.first) ;
        r2 = root(edge[i].first.second) ;
        if ( r1 != r2 )
        {
            unite(r1,r2,edge[i].second) ;
            graf[edge[i].first.first].push_back(make_pair(edge[i].first.second,edge[i].second)) ;
            graf[edge[i].first.second].push_back(make_pair(edge[i].first.first,edge[i].second)) ;
        }
    }
}

void DFS(int nod)
{
    viz[nod] = true ;
    for ( int i = 0 ; i < graf[nod].size() ; i++ )
    {
        if ( viz[graf[nod][i].first] == false )
        {
            nivel[graf[nod][i].first] = nivel[nod]+1 ;
            tata[graf[nod][i].first] = nod ;
            DFS(graf[nod][i].first) ;
        }
    }
}


int main()
{
    int i, x , y, maxc ;
    citire() ;
    solve() ;
    i = 1 ;
    while(parinte[i]!=i&&i<=n )
        i++ ;
    memset(viz,false,n+1) ;
    nivel[i] = 1 ;
    DFS(i) ;
    for ( i = 1 ; i <= k ; i++ )
    {
        fin >> x >> y ;
        maxc = 0 ;
        if ( nivel[y] > nivel[x] )
            swap(x,y) ;
        while(nivel[x]>nivel[y])
        {
            maxc = max(maxc,cost[x]) ;
            x = tata[x] ;
        }
        while(x!=y)
        {
            maxc = max(maxc,cost[x]) ;
            x = tata[x] ;
            maxc = max(maxc,cost[y]) ;
            y = tata[y] ;
        }
        fout << maxc << '\n' ;
    }
}