#include <stdio.h>
#define NM 15001
#define MM 30001
#define Max(a, b) ((a) > (b) ? (a) : (b))

int n, m, T;
int i, j, k;
int h[NM], t[NM], lev[NM], c[NM];
int a, b, cmax;
struct edge {
    int x, y, c;
} e[MM], aux;

void Qsort(int st, int dr);
void Kruskal();
int Find(int nod);
void Union(int i, int j);
int Level(int nod);

int main()
{
    freopen("radiatie.in", "r", stdin);
    freopen("radiatie.out", "w", stdout);
    scanf("%d %d %d", &n, &m, &T);
    for ( i = 1; i <= m; i++ )
        scanf("%d %d %d", &e[i].x, &e[i].y, &e[i].c);
    Kruskal();
    
    for ( int g = 1; g <= T; g++ )
    {
        scanf("%d %d", &a, &b);
        cmax = 0;
        while ( lev[a] > lev[b] ) cmax = Max(cmax, c[a]), a = t[a];
        while ( lev[b] > lev[a] ) cmax = Max(cmax, c[b]), b = t[b];
        while ( a != b ) cmax = Max(cmax, Max(c[a], c[b])), a = t[a], b = t[b];
        printf("%d\n", cmax);
    }    
           
    return 0;
}

void Qsort(int st, int dr)
{
    int i = st-1;
    int j = dr+1;
    do
    {
        do { i++; } while ( e[i].c < e[st].c );
        do { j--; } while ( e[st].c < e[j].c );
        if ( i <= j )
            aux = e[i], e[i] = e[j], e[j] = aux;
    } while ( i <= j );
    if ( i < dr ) Qsort(i, dr);
    if ( st < j ) Qsort(st, j);
}

void Kruskal()
{
    Qsort(1, m);
    for ( i = 1; i <= n; i++ )
        t[i] = i, h[i] = 1, c[i] = 0;
    int nrm = n;
    for ( k = 1; k <= m; k++ )
    {
        if ( nrm == 1 ) break;
        int r1 = Find(e[k].x);
        int r2 = Find(e[k].y);
        if ( r1 != r2 )
        {
            Union(r1, r2);
            nrm--;
        }
    }
    for ( i = 1; i <= n; i++ )
        Level(i);
}

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

void Union(int i, int j)
{
    if ( h[i] > h[j] ) t[j] = i, c[j] = e[k].c;
    else
    {
        t[i] = j, c[i] = e[k].c;
        if ( h[i] == h[j] ) h[j]++;
    }
}

int Level(int nod)
{
    if ( lev[nod] != 0 ) return lev[nod];
    if ( t[nod] == nod ) return 1;
    return (lev[nod] = Level(t[nod]) + 1);
}