#include <iostream>
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <vector>
#include <algorithm>
 
using namespace std;
 
const int M = 30100 ;
const int N = 15010 ;
const int LOGN = 15 ;
 
struct muchie {
    int x , y , cost ;
};
 
muchie muc [ M ];
int tat [ N ];
 
int noNodes , noEdges , noQuery ;
 
bool cmp ( muchie a , muchie b ){
    return a.cost < b.cost ;
}
 
int FindTat( int x ){
    static int tx , temp ;
 
    tx = x ;
    while  ( tat [ tx ] >= 0 ){
        tx = tat [ tx ];
    }
 
    while ( tat [ x ] >= 0 ){
        temp = tat [ x ];
        tat [ x ] = tx ;
        x = temp ;
    }
 
    return tx;
}
 
int MergeTat( int x , int y ){
    static int tx ,ty ;
 
    tx = FindTat( x );
    ty = FindTat( y );
 
    if ( tx == ty ){
        return 0 ;
    }
 
    if ( tat [ tx ] < tat [ ty ] ){
        tat[ tx ] += tat [ ty ];
        tat [ ty ] = tx ;
    }else{
        tat[ ty ] += tat[ tx ];
        tat[ tx ] = ty ;
    }
    return 1 ;
 
}
 
int valAncestor [ N ][ LOGN ];
int lvl [ N ] ;
int nodeAncestor [ N ][ LOGN ];
 
vector < pair < int , int > > edges[ N ];
 
void UpdateAncestor ( int x  ){
    static int i ;
 
    for ( i = 1 ; (1<<i) < lvl [ x ] ; i++){
        nodeAncestor [ x ][ i ] = nodeAncestor [ nodeAncestor [ x ][ i - 1 ] ][ i -1 ];
 
        valAncestor [ x ][ i ] = max( valAncestor [ x ] [ i - 1 ] , valAncestor[ nodeAncestor [ x ][ i - 1 ] ][ i -1 ] );
    }
 
}
 
 
void dfs( int node ){
    vector < pair < int , int > >::iterator it ;
    int vec ;
 
    for ( it = edges [ node ].begin() ; it != edges [ node ] .end() ; it++ ){
        vec = it->first;
        if ( lvl [ vec ]  ){
            continue ;
        }
 
        valAncestor [ vec ][ 0 ] = it -> second ;
        lvl [ vec ] = lvl [ node ] + 1;
        nodeAncestor [ vec ][ 0 ] = node ;
 
        UpdateAncestor ( vec  );
 
        dfs ( vec ); 
    } 
}
 
int vmax;

int solveQuery( int x , int y ){
    static int temp , i ;
 
    vmax = 0 ;
    if ( lvl [ x ] < lvl [ y ] ){
        temp = x ;
        x = y ;
        y = temp ;
    }
 
 
    for ( i = LOGN ; i >= 0 ; i -- ){
        if ( lvl [ x ] - (1<<i) >= lvl [ y ] ){
            vmax = max ( vmax , valAncestor [ x ] [ i ] );
            x = nodeAncestor [ x ][ i ];
        }
    }
 
    if ( x == y ){
        return vmax;
    }
 
    for ( i = LOGN ; i >= 0 ; i -- ){
        if ( lvl[ x ] < (1<<i) ){
            continue ;
        }
        if ( nodeAncestor [ x ][ i ] != nodeAncestor [ y ][ i ] ){
            vmax = max ( vmax , valAncestor [ x ][ i ] );
            vmax = max ( vmax , valAncestor [ y ][ i ] );
            x = nodeAncestor [ x ][ i ] ;
            y = nodeAncestor [ y ][ i ] ;
        }
    }
    if ( x == y ){
        return vmax;
    }
 
    vmax = max ( vmax , valAncestor [ x ] [ 0 ]);
    vmax = max ( vmax , valAncestor [ y ] [ 0 ]);
    return vmax ;
 
}
 
int main(){
    int i ;
 
    freopen("radiatie.in","r",stdin);
    freopen("radiatie.out","w",stdout);
 
    scanf("%d%d%d",&noNodes , &noEdges , &noQuery );
 
    for ( i = 0 ; i < noEdges ; i++ ){
        scanf("%d%d%d",&muc [ i ].x ,&muc [ i ].y ,&muc [ i ].cost );
    }
 
    sort ( muc , muc + noEdges , cmp );
 
    memset ( tat , -1 , sizeof tat );
    for ( i = 0 ; i < noEdges ; i++ ){
        if ( MergeTat( muc[ i ].x , muc[ i ].y ) ){
            edges [ muc [ i ].x ].push_back ( make_pair(muc [ i ].y , muc [ i ].cost ) );
            edges [ muc [ i ].y ].push_back ( make_pair(muc [ i ].x , muc [ i ].cost ) );
        }
    }
 
    lvl [ 1 ] = 1 ;
    dfs ( 1 );
 
    int x ,y ;
    for ( i = 0 ; i < noQuery ; i++ ){
        scanf("%d%d",&x,&y);
 
        printf("%d\n",solveQuery ( x , y ) );
 
    }
 
    return 0;
}