#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;
       long long cost;
} p[2*dim];

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

typedef struct nod {
        int vf;
        ll cost;
        bool ok;
        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);
ll BF(int,int);

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

void ReadData()
{
     int x,y;
     ll 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%lld",&y,&x,&c);
         p[i].a = x;
         p[i].b = y;
         p[i].cost = c;
         Add(x,y,c);
         Add(y,x,c);
     }
     
     Qsort(1,m);
     Kruskal();
     
     for ( int i = 1; i <= k; i++ )
     {
         scanf("%d%d",&x,&y);
         printf("%d\n",BF(x,y));
     }
}

bool Maxim(ll a, ll b)
{
     return a > b ? a : b;
}

ll BF(int nod, int dest)
{
    int q[dim];
    for ( int i = 1; i <= n; i++ ) d[i] = 0, sel[i] = 0, q[i] = 0;
    
    d[nod] = 0;
    
    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 ( g->ok == 1 && !sel[i] )
            {
                 if ( d[g->vf] < Maxim(d[i],g->cost) ) d[g->vf] = Maxim(d[i],g->cost);
                 q[++u] = g->vf;     
            }
        }
        p++;
    }
    
    return d[dest];
}

void Add(int i, int j, int c)
{
     PNOD q = new nod;
     q->vf = i;
     q->ok = 0;
     q->cost = c;
     q->next = graph[j];
     graph[j] = q;
}

void Qsort(int st, int dr)
{
     int i = st - 1;
     int j = dr + 1;
     ll 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 )
         {
              GG(p[i].a,p[i].b);
              k++;
              Union(r1,r2);
              if ( k == n-1 ) break;
         }
     }
     
     for ( int i = 1; i <= n; i++ ) sel[i] = niv[t[i]=i] = 0;
}

void GG(int i, int j)
{
     for ( PNOD q = graph[i]; q; q=q->next )
         if ( q->vf == j )
         {
              q->ok = 1;
              break;
         } 
     
     for ( PNOD q = graph[j]; q; q=q->next )
         if ( q->vf == i )
         {
              q->ok = 1;
              break;
         }
}