#include <bits/stdc++.h>

using namespace std;

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

using ll = long long;

const int DIM = 15005;
const int LG = 16;

struct edge {
  int u, v, cost;
};

vector<edge> edges;

struct cmp {
  bool operator () ( const edge &a, const edge &b ) {
    return a.cost < b.cost;
  }
};

int fth[DIM];

int root( int u ) {
  if ( fth[u] == u ) return u;
  return fth[u] = root(fth[u]);
}
inline void join( int u, int v ) {
  fth[root(u)] = root(v);
}

vector<pair<int, int>> mst[DIM];

int anc[1 + LG][DIM], maxe[1 + LG][DIM], P[DIM], Q[DIM], lvl[DIM];
bool viz[DIM];

void dfs( int u ) {
  viz[u] = true;
  for ( auto v : mst[u] ) {
	if ( !viz[v.first] ) {
	  lvl[v.first] = lvl[u] + 1;
	  dfs(v.first);
	  P[v.first] = u;
	  Q[v.first] = v.second;
	}
  }
}

int getPathMax( int u, int v ) {
  if ( lvl[u] < lvl[v] ) {
    swap(u, v);
  }
  int res = 0;
  for ( int lg = LG; lg >= 0; --lg ) {
    if ( lvl[v] + (1 << lg) <= lvl[u] ) {
	  res = max( res, maxe[lg][u] );
	  u = anc[lg][u];
	}
  }
  if ( u == v ) return res;
  for ( int lg = LG; lg >= 0; --lg ) {
    if ( anc[lg][u] != anc[lg][v] ) {
      res = max({ res, maxe[lg][u], maxe[lg][v] });
	  u = anc[lg][u];
      v = anc[lg][v];
	}
  }
  return max({ res, maxe[0][u], maxe[0][v] });
}

int main() {
  int n, m, u, v, c, q;

  fin >> n >> m >> q;
  for ( int i = 0; i < m; ++i ) {
	fin >> u >> v >> c;
	edges.push_back( {u, v, c} );
  }
  for ( int i = 1; i <= n; ++i ) fth[i] = i;
  sort( edges.begin(), edges.end(), cmp() );
  for ( int i = 0; i < m; ++i ) {
	if ( root( edges[i].u ) != root( edges[i].v ) ) {
	  join( edges[i].u, edges[i].v );
	  mst[edges[i].u].push_back( {edges[i].v, edges[i].cost} );
	  mst[edges[i].v].push_back( {edges[i].u, edges[i].cost} );
	}
  }
  dfs(1);
  for ( int i = 1; i <= n; ++i ) {
    anc[0][i] = P[i];
    maxe[0][i] = Q[i];
  }
  for ( int lg = 1; lg <= LG; ++lg ) {
    for ( int i = 1; i <= n; ++i ) {
      anc[lg][i] = anc[lg - 1][anc[lg - 1][i]];
	  maxe[lg][i] = max( maxe[lg - 1][i], maxe[lg - 1][anc[lg - 1][i]] );
    }
  }
  while ( q-- ) {
    fin >> u >> v;
    fout << getPathMax(u, v) << "\n";
  }
  fin.close();
  fout.close();
  return 0;
}