#include <iostream>
#include <fstream>
#include <queue>
#include <algorithm>

using namespace std;

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

const int N = 5e4;
int str[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], rad[N];

void bfs ( int node ) {
    
    queue <int> q;
    q.push(node);
    
    for ( int i = 0; i < N; i++ )
        viz[i] = dist[i] = 0;

    viz[node] = 1;
    
    while ( q.size() > 0 ) {
        
        node = q.front();
        
        for ( int i = 0; i < g[node].size(); i++ ) {
            if ( viz[g[node][i].first] == 0 || dist[g[node][i].first] > max ( dist[node], g[node][i].second ) ) {
                dist[g[node][i].first] = max ( dist[node], g[node][i].second );
                viz[g[node][i].first] = 1;
                
                q.push ( g[node][i].first );
                
            }
        }
        
        q.pop();
    }
}

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

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[x] );
        x = str[x];
    }
    
    while ( x != y ) {
        ans = max ( ans, max ( rad[x], rad[y]) );
        x = str[x];
        y = str[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 + n, 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)] = sup[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 );
    
    int x, y;
    for ( int i = 0; i < q; i++ ) {
        
        fin >> x >> y;
        
        fout << lca ( x, y ) << "\n";
        
    }
    
    return 0;
}