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

#define IN "radiatia.in"
#define OUT "radiatia.out"
#define pb push_back

const int MAX = 30014 ;


using namespace std;

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

int tata [ MAX ] , cost [ MAX ] , adanc [ MAX ] ;

struct lab{
    int x , y , cost ;
};

lab v [ MAX ] ;
vector <int> gr [ MAX ] ;

int stramos ( int nod ) ;

void unire ( int nod1 , int nod2 ) ;

void dfs ( int nod , int nivel ) ;

bool cmp ( lab a , lab b ){
    return a.cost < b.cost ;
}

int main ( )
{
    int n , m ,tata_x , tata_y, x , y , k , sol ;
    fin >> n >> m >> k ;
    for ( register int i = 1 ; i <= n ; ++ i )
        tata [ i ] = i ;
    for ( register int i = 1 ; i <= m ; ++ i )
        fin >> v [ i ].x >> v [ i ].y >> v [ i ].cost ;
    sort ( v + 1 , v + m + 1 , cmp ) ;
    for ( register int i = 1 ; i <= m ; ++ i ){
        tata_x = stramos ( v [ i ].x ) ;
        tata_y = stramos ( v [ i ].y ) ;
        if ( tata_x != tata_y  ){
            unire ( tata_x , tata_y );
            gr [ tata_y ].pb ( tata_x ) ;
            cost [ tata_x ] = v [ i ].cost ;
        }
    }
    for ( register int i = 1 ; i <= n ; ++ i )
        if ( i == tata [ i ] ){
            dfs ( i , 0 ) ;
            break;
        }
    while ( k -- ){
        fin >> x >> y ;
        sol = 0 ;
        while ( adanc [ x ] > adanc [ y ] ){
            sol = max ( sol , cost [ x ] ) ;
            x = tata [ x ] ;
        }
        while ( adanc [ x ] < adanc [ y ] ){
            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;
}

int stramos ( int nod ){
    while ( nod != tata [ nod ] )
        nod = tata [ nod ] ;
    return nod ;
}

void unire ( int nod1 , int nod2 ){
        tata [ nod1 ] = nod2 ;
}

void dfs ( int nod , int nivel ){
    adanc [ nod ] = nivel ;
    for ( auto it : gr [ nod ] )
        dfs ( it , nivel + 1 ) ;
}