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

using namespace std;

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

const int N = 5e4, LOG = 20;
int str[LOG][N], rad[LOG][N], niv[N];

struct muchie {
    int a;
    int b;
    int cost;
} v[N];

vector <pair <int, int>> g[N];

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

int sup[N];

int suprem ( int x ) {
    if ( x == sup[x] )
        return x;
    else {
        sup[x] = suprem(sup[x]);
        return sup[x];
    }
}

int viz[N], dist[N];

void dfs ( int node, int par, int cost ) {
    
    niv[node] = niv[par] + 1;
    str[0][node] = par;
    rad[0][node] = cost;
    
    for ( int i = 0; i < g[node].size(); i++ )
        
        if ( g[node][i].first != par ) {
            dfs ( g[node][i].first, node, g[node][i].second );
        }
}

int lca ( int x, int y ) {
    
    int ans = 0;
    
    if ( niv[x] < niv[y] )
        swap ( x, y );
    
    while ( niv[x] > niv[y] ) {
        ans = max ( ans, rad[0][x] );
        x = str[0][x];
    }
    
    if ( x == y )
        return ans;
    
    for ( int i = LOG; i >= 0; i-- )
        if ( str[i][x] != 0 && str[i][y] != 0 && str[i][x] != str[i][y] ) {
            ans = max (ans, max( rad[i][x], rad[i][y]));
            x = str[i][x];
            y = str[i][y];
        }
    
    ans = max (ans, max( rad[0][x], rad[0][y]));
    
    return ans;
    
}

int main () {
    
    int n, m, q;
    
    fin >> n >> m >> q;
    
    for ( int i = 0; i < m; i++ )
        fin >> v[i].a >> v[i].b >> v[i].cost;
    
    sort ( v, v + m, cmp );
    
    for ( int i = 1; i <= n; i++ )
        sup[i] = i;
    
    for ( int i = 0; i < m; i++ ) {
        
        if ( suprem (v[i].a) != suprem(v[i].b) ) {
            
            sup[suprem(v[i].a)] = suprem(v[i].b);
            
            g[v[i].a].push_back ( {v[i].b, v[i].cost} );
            g[v[i].b].push_back ( {v[i].a, v[i].cost} );
        }
    }
    
    dfs ( 1, 0, 0 );
    
    for ( int i = 1; i < LOG; i++ )
        for ( int j = 1; j <= n; j++ ){
            str[i][j] = str[i - 1][str[i - 1][j]];
            rad[i][j] = max( rad[i - 1][j], rad[i - 1][str[i - 1][j]] );
        }
    
    int x, y;
    for ( int i = 0; i < q; i++ ) {
        
        fin >> x >> y;
        
        fout << lca ( x, y ) << "\n";
        
    }
    
    return 0;
}