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

#define rint register int
#define pb push_back

const char IN [ ] = "radiatie.in" ;
const char OUT [ ] = "radiatie.out" ;
const int MAX = 10014 ;

using namespace std;

ifstream fin ( IN ) ;
ofstream fout ( OUT ) ;

int tata [ MAX ] , nivel [ MAX ] , rang [ MAX ] , cost [ MAX ] ;

struct graf {
    int x , y , cost ;
};
graf q[ MAX ] ;

vector < int > gr [ MAX ] ;

int stramos ( int x )
{
    int R ;
    for ( R = x ; tata [ R ] != R ; R = tata [ R ] ) ;
    return R ;
}

void uneste ( int x , int y )
{
    if ( rang [ x ] > rang [ y ] )
    {
        rang [ x ] += rang [ y ] ;
        tata [ y ] = x ;
    }
    else
    {
        rang [ y ] += rang [ x ];
        tata [ x ] = y ;
    }
}
bool cmp ( graf a , graf b )
{
    return a.cost < b.cost ;
}
void dfs ( int nod , int lvl )
{
    nivel [ nod ] = lvl ;
    for ( auto x : gr[ nod ] )
        dfs ( x , lvl + 1 ) ;
}
int main( )
{
    int n , m , k ;
    fin >> n >> m >> k ;
    for ( rint i = 1 ; i <= n ; ++ i )
    {
        tata [ i ] = i ;
        rang [ i ] = 1 ;
    }
    for ( rint i = 1 ; i <= m ; ++ i )
        fin >> q [ i ].x >> q[ i ].y >> q[ i ].cost ;
    sort ( q + 1 , q + m + 1 , cmp ) ;
    for ( rint i = 1 ; i <= m ; ++ i )
    {
        int tata_x = stramos ( q [ i ].x ) ;
        int tata_y = stramos ( q [ i ].y ) ;
        if ( tata_x != tata_y )
        {
            uneste ( tata_x , tata_y ) ;
            gr [ tata_y ].pb ( tata_x ) ;
            cost [ tata_x ] = q [ i ].cost ;
        }
    }
    for ( rint i = 1 ; i <= n ; ++ i )
    {
        if ( i == tata [ i ] )
        {
            dfs ( i , 0 ) ;
            break ;
        }
    }
    while ( k -- )
    {
        int x , y ;
        fin >> x >> y ;
        int sol = 0 ;
        while ( nivel [ x ] > nivel [ y ] )
        {
            sol = max ( sol , cost [ x ] ) ;
            x = tata [ x ] ;
        }
        while ( nivel [ y ] > nivel [ x ] )
        {
            sol = max ( sol , cost [ y ] ) ;
            y = tata [ y ] ;
        }
        while ( x != y )
        {
            sol = max ( sol , max ( cost [ x ] , cost [ y ] ) ) ;
            x = tata [ x ] ;
            y = tata [ y ] ;
        }
        fout << sol << '\n' ;
    }
    return 0;
}