#include <stdio.h>
#include <fstream>
#include <limits>
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], q[dim];
int v[dim][1];
int n, m, k;

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

PNOD graph[dim];
bool sel[dim];

void ReadData();
void GG(int,int);
void Kruskal();
int Find(int);
void Union(int,int);
void Qsort(int,int);
void Add(int,int,int);
void DF(int,int);
int Maxim(ll a, ll b);
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);
     
     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 )
         if ( !sel[q->vf] )
         {
              t[q->vf] = nod;
              v[q->vf][0] = q->cost;
              DF(q->vf,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 < v[i][0] )
               {
                    maxim = v[i][0];
               }
               i = t[i];
          }
          else
          {
              if ( maxim < v[j][0] )
               {
                    maxim = v[j][0];
               }
               j = t[j]; 
          }
    }
    
    return maxim;
}

/*int BF(int nod, int dest)
{
    memset(d,0,sizeof(d));
    memset(sel,0,sizeof(sel));
    
    int p,u;
    
    q[p=u=1] = nod;
    sel[nod] = 1;
    
    while ( p <= u )
    {
        int i = q[p];
        for ( PNOD g = graph[i]; g; g=g->next )
        {
            if ( !sel[g->vf] )
            {
                 if ( d[g->vf] < d[i] ) d[g->vf] = d[i];
                 if ( d[g->vf] < g->cost ) d[g->vf] = g->cost;
                 q[++u] = g->vf;     
                 sel[g->vf] = 1;
                 if ( g->vf == dest) break;
            }
        }
        p++;
    }
    
    return d[dest];
}*/

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);
              k++;
              Union(r1,r2);
              if ( k == n-1 ) break;
         }
     }
     
     for ( int i = 1; i <= n; i++ ) niv[t[i]=i] = 0;
}