#include <iostream>
#include <fstream>
#include <vector>
#include <algorithm>
#include <cstring>

using namespace std;

ifstream fin("radiatie.in");
ofstream fout("radiatie.out");

const int Nmax = 15000, Mmax = 30000, lg = 15;

struct Edge{
    int x, y, c;
}v[Mmax + 5];
vector <pair <int, int>> g[Nmax + 5];
int n, m, k, tt[Nmax + 5], level[Nmax + 5], a[lg][Nmax + 5], c[lg][Nmax + 5], lg2[Nmax + 5];

void Read(){
    fin >> n >> m >> k;
    for (int i = 1; i <= m; i++){
        int a, b, c;
        fin >> a >> b >> c;
        v[i].x = a;
        v[i].y = b;
        v[i].c = c;
    }
}

int Compare(Edge a, Edge b){
    return a.c < b.c;
}

int Root(int nod){
    while (tt[nod])
        nod = tt[nod];
    return nod;
}

void APM(){
    sort(v + 1, v + m + 1, Compare);
    for (int i = 1; i <= m; i++){
        int r1 = Root(v[i].x), r2 = Root(v[i].y);
        if (r1 != r2){
            if (level[r1] > level[r2])
                swap(r1, r2);
            tt[r1] = r2;
            level[r2] = max(level[r2], level[r1] + 1);
            g[v[i].x].push_back({v[i].y, v[i].c});
            g[v[i].y].push_back({v[i].x, v[i].c});
        }
    }
}

void DFS(int nod, int tata){
    level[nod] = level[tata] + 1;
    for (auto i : g[nod])
        if (!level[i.first]){
            a[0][i.first] = nod;
            c[0][i.first] = i.second;
            DFS(i.first, nod);
        }
}

void Precalc(){
    for (int i = 2; i <= n; i++)
        lg2[i] = lg2[i / 2] + 1;
    for (int i = 1; i <= lg2[n]; i++)
        for (int j = 1; j <= n; j++){
            a[i][j] = a[i - 1][a[i - 1][j]];
            c[i][j] = max(c[i - 1][j], c[i - 1][a[i - 1][j]]);
        }
}

int Max(int x, int y){
    int sol = 0;
    if (level[x] > level[y])
        swap(x, y);
    while (level[y] > level[x]){
        int dif = level[y] - level[x];
        sol = max(sol, c[lg2[dif]][y]);
        y = a[lg2[dif]][y];
    }
    if (x == y)
        return sol;
    for (int i = lg2[level[x]]; i >= 0; i--)
        if (a[i][x] != a[i][y]){
            sol = max(sol, c[i][x]);
            x = a[i][x];
            sol = max(sol, c[i][y]);
            y = a[i][y];
        }
    sol = max(sol, c[0][x]);
    sol = max(sol, c[0][y]);
    return sol;
}

int main(){
    Read();
    APM();
    memset(level, 0, sizeof level);
    DFS(1, 0);
    Precalc();
    for (int i = 1; i <= k; i++){
        int x, y;
        fin >> x >> y;
        fout << Max(x, y) << '\n';
    }
    return 0;
}