#include<fstream>
#include<vector>
using namespace std;

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

#define SIZE 15001

struct muchie{
       int x, y, c;
};

muchie G[SIZE];
int maxm;
int n, m, k, poz;
int ok;
int t[SIZE], h[SIZE];
bool s[SIZE];
vector< vector< pair<int, int> > > M;
int sol[SIZE];

void Read();
void Kruskall();
void Union(int x, int y );
int Find( int x );
void DF( int a, int b, int dist );

int main()
{
    Read();
    
    fin.close();
    fout.close();
    
    return 0;
}

bool Sorteaza( muchie a, muchie b )
{
     return a.c < b.c;
}

void Read()
{
     fin >> n >> m >> k;
     M.resize(n+1);
     int a, b, c;
     t[n] = n;
     h[n] = 0;
     for( int i = 1; i <= m; ++i )
     {
          if( i < n )
          {
              t[i] = i;
              h[i] = 0;
          }
          fin >> a >> b >> c;
          G[i].x = a;
          G[i].y = b;
          G[i].c = c;
     }
     
     Kruskall();
     int dist;
     for( int i = 1; i <= k; ++i )
     {
          ok = 1;
          fin >> a >> b;
          dist = -1;
          poz = 0;
          for( int j = 1; j <= n; ++j )
               s[j] = false;
          DF( a, b, dist );    
     }
     
}

void Kruskall()
{
     sort( G+1, G+n+1, Sorteaza );
     
     for( int i = 1; i <= m; ++i )
     {
          int v1 = Find( G[i].x );
          int v2 = Find( G[i].y );
          if( v1 != v2 )
          {
              poz++;
              M[ G[i].x ].push_back( make_pair( G[i].y, G[i].c ) );
              M[ G[i].y ].push_back( make_pair( G[i].x, G[i].c ) );
              
              Union( v1, v2 );
          }
          if( poz == n-1 )
              break;
     }
}

int Find( int x )
{
    if( t[x] != x )
        t[x] = Find( t[x] );
    return t[x];
}

void Union( int x, int y )
{
     if( h[x] > h[y] ) 
         t[y] = x;
     else
     {
         t[x] = y;
         if( h[x] == h[y] ) 
             h[y] += 1;
     }
}

void DF( int a, int b, int dist )
{
     if( a == b )
     {
         ok = 0;
         int maxm = -1;
         
         for( int p = 1; p <= poz; ++p )
         {
              //fout << sol[p] << ' ';
              if( maxm < sol[p] )
                  maxm = sol[p];
         }
         //fout << '\n';
         
         fout << maxm << '\n';
         poz = 0;
         return;
     }
     
     s[a] = true;
     
     for( int i = 0; i < M[a].size(); ++i )
          if( !s[ M[a][i].first ] )
          {
              if( ok == 0 ) return;
              poz++;
              s[ M[a][i].first ] = true;
              sol[ poz ] = M[a][i].second;
          
              DF( M[a][i].first, b, M[a][i].second );
              sol[ poz ] = -1;
          }
}