#include <stdio.h>
#include <vector>
#include <algorithm>

using namespace std;

struct muchie
{
    int a, b, cost;
};

vector<int> v[15001], c[15001];
int n, m, k, t[15001], niv[15001], cost[15001], r[15001], used[15001];
muchie e[30001];

bool cmp(muchie one, muchie two)
{
    return one.cost < two.cost;
}
int f(int x);
void reuniune(int x, int y);
void dfs(int nod);

int main()
{
    freopen("radiatie.in","r",stdin);
    freopen("radiatie.out","w",stdout);

    int i, unu, doi, sol;

    scanf("%d%d%d", &n, &m, &k);

    for(i = 1; i <= m; ++i)
    {
        scanf("%d%d%d", &e[i].a, &e[i].b, &e[i].cost);
    }

    sort(e + 1, e + m + 1, cmp);
    for(i = 1; i <= n; ++i)
    {
        r[i] = i;
    }

    for(i = 1; i <= m; ++i)
    {
        if(f(e[i].a) != f(e[i].b))
        {
            v[e[i].a].push_back(e[i].b);
            v[e[i].b].push_back(e[i].a);
            c[e[i].a].push_back(e[i].cost);
            c[e[i].b].push_back(e[i].cost);
            reuniune(r[e[i].a], r[e[i].b]);
        }
    }


    dfs(1);
    for(i = 1; i <= k; ++i)
    {
        sol = 0;
        scanf("%d%d", &unu, &doi);
        while(niv[doi] > niv[unu])
        {
            if(sol < cost[doi])
                sol = cost[doi];
            doi = t[doi];
        }
        while(niv[unu] > niv[doi])
        {
            if(sol < cost[unu])
                sol = cost[unu];
            unu = t[unu];
        }
        while(unu != doi)
        {
            if(sol < cost[doi])
                sol = cost[doi];
            if(sol < cost[unu])
                sol = cost[unu];
            unu = t[unu];
            doi = t[doi];
        }
        printf("%d\n", sol);
    }

    return 0;
}

int f(int x)
{
    if(r[x] != r[r[x]])
        r[x] = f(r[x]);
    return r[x];
}

void reuniune(int x, int y)
{
    if(x < y)
        r[y] = x;
    else
        r[x] = y;
}

void dfs(int nod)
{
    int i;

    used[nod] = 1;

    for(i = 0; i < v[nod].size(); ++i)
    {
        if(!used[v[nod][i]])
        {
            t[v[nod][i]] = nod;
            niv[v[nod][i]] = niv[nod] + 1;
            cost[v[nod][i]] = c[nod][i];
            dfs(v[nod][i]);
        }
    }
}