// 70
#include <stdio.h>
#include <fstream>
#include <limits>
#include <vector>
using namespace std;

#define infinit numeric_limits<long long>::max()
#define in "radiatie.in"
#define out "radiatie.out"
#define dim 15001
#define inf 1000000001
#define ll long long

struct muchie {
       int a, b;
       int cost;
} p[2*dim];

int t[dim], niv[dim], d[dim];
int n, m, k;

/*typedef struct nod {
        int vf;
        int cost;
        nod* next;
}*PNOD;

PNOD graph[dim];*/

vector< vector<int> > C;
vector< vector<int> > V;
bool sel[dim];

void ReadData();
void Kruskal();
int Find(int);
void Union(int,int);
void Qsort(int,int);
void Add(int,int,int);
void DF(int,int);
int LCA(int x,int y);

int main()
{
    ReadData();
    
    return 0;
}

void ReadData()
{
     int x,y;
     int c;
     freopen(in,"r",stdin);
     freopen(out,"w",stdout);
     
     scanf("%d%d%d",&n,&m,&k);
     
     V.resize(n+1);
     C.resize(n+1);
     
     for ( int i = 1; i <= m; i++ )
     {   
         scanf("%d%d%d",&y,&x,&c);
         p[i].a = x;
         p[i].b = y;
         p[i].cost = c;
     }
     
     Qsort(1,m);
     Kruskal();
     DF(1,0);
     
     for ( int i = 1; i <= k; i++ )
     {
         scanf("%d%d",&x,&y);
         printf("%d\n",LCA(x,y));
     }
}

void DF(int nod,int nivel)
{
     sel[nod] = 1;
     niv[nod] = nivel;
     
   //  for ( PNOD q = graph[nod]; q; q=q->next )
     for ( int i = 0; i < V[nod].size(); i++ )
         if ( !sel[V[nod][i]] )
         {
              t[V[nod][i]] = nod;
              d[V[nod][i]] = C[nod][i];
              DF(V[nod][i],nivel+1);
         }
     
}

int LCA(int x,int y)
{
    int i = x;
    int j = y;
    int maxim=0;
    
    while ( i != j )
    {
          if ( niv[i] > niv[j] )
          {
               if ( maxim < d[i] ) maxim = d[i];
               i = t[i];
          }
          else
          {
              if ( maxim < d[j] ) maxim = d[j];
              j = t[j]; 
          }
    }
    
    return maxim;
}
/*
void Add(int i, int j, int c)
{
     PNOD q = new nod;
     q->vf = i;
     q->cost = c;
     q->next = graph[j];
     graph[j] = q;
}
*/
void Qsort(int st, int dr)
{
     int i = st - 1;
     int j = dr + 1;
     int pivot = p[st].cost;
     
     while ( i <= j )
     {
           do { i++; } while ( p[i].cost < pivot );
           do { j--; } while ( p[j].cost > pivot );
           if ( i <= j )
           {
                muchie aux = p[i];
                p[i] = p[j];
                p[j] = aux;
           }
     }
     
     if ( st < j ) Qsort(st,j);
     if ( i < dr ) Qsort(i,dr);
}

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

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

void Kruskal()
{
     for ( int i = 1; i <= n; i++ ) niv[t[i]=i] = 0;  
     
     int k = 0;
     
     for ( int i = 1; i <= m; i++ )
     {
         int r1 = Find(p[i].a);
         int r2 = Find(p[i].b);
         
         if ( r1 != r2 )
         {
              //Add(p[i].a,p[i].b,p[i].cost);
              //Add(p[i].b,p[i].a,p[i].cost);
              V[p[i].a].push_back(p[i].b);
              V[p[i].b].push_back(p[i].a);
              C[p[i].a].push_back(p[i].cost);
              C[p[i].b].push_back(p[i].cost);
              k++;
              Union(r1,r2);
              if ( k == n-1 ) break;
         }
     }
     
     for ( int i = 1; i <= n; i++ ) niv[t[i]=i] = 0;
}