#include <iostream>
#include <fstream>
#include <vector>
#include <algorithm>
#define nmax 15005

using namespace std;

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

struct muchie {
    int x, y, cost;
} M[2*nmax];

int n, m, k;
int C[nmax][nmax];
vector <int> V[nmax];

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

int R[nmax], NR[nmax];

bool cmp(muchie a, muchie b) {
    return a.cost < b.cost;
}

int root(int nod) {
    if (R[nod] == nod)
        return nod;
    return root(R[nod]);
}

void kruskal() {
    int i;
    for (i = 1; i <= n; i++)
        NR[i] = 1, R[i] = i;
    int nrm = 0;
    sort(M+1,M+m+1,cmp);
    for (i = 1; i <= m; i++) {
        int p1 = root(M[i].x);
        int p2 = root(M[i].y);
        if (p1 == p2)
            continue;
        if (NR[p1] >= NR[p2]) {
            NR[p1] += NR[p2];
            R[p2] = p1;
        } else {
            NR[p2] += NR[p1];
            R[p1] = p2;
        }
        nrm++;
        V[M[i].x].push_back(M[i].y);
        V[M[i].y].push_back(M[i].x);
        if (nrm == n-1)
            break;
    }
}

bool viz[nmax];
int P[nmax], E[2*nmax], Exp[2*nmax], Min[17][2*nmax];

void euler(int nod) {
    E[++E[0]] = nod;
    viz[nod] = true;
    P[nod] = E[0];
    for (int i = 0; i < V[nod].size(); i++)
        if (!viz[V[nod][i]]) {
            euler(V[nod][i]);
            E[++E[0]] = nod;
        }
}

void preprocess() {
    int i, j;
    Exp[1] = 0;
    for (i = 2; i <= E[0]; i++)
        Exp[i] = Exp[i/2] + 1;
    for (i = 1; i < E[0]; i++)
        Min[0][i] = C[E[i]][E[i+1]];
    for (i = 1; i <= Exp[E[0]-1]; i++)
        for (j = 1; j <= (E[0]-1) - (1<<i) + 1; j++) {
            int st = j;
            int dr = st + (1<<i) - 1;
            int mid = dr - (1<<(i-1)) + 1;
            Min[i][j] = max(Min[i-1][st], Min[i-1][mid]);
    }
}

void solve() {
    euler(1);
    preprocess();
    for (int i = 1; i <= k; i++) {
        int x, y;
        fin >> x >> y;
        x = P[x], y = P[y];
        if (x > y) swap(x, y);
        int l = y - x + 1;
        int k = Exp[l];
        int rez = Min[k][x];
        x = y - (1<<k) + 1;
        rez = max(rez, Min[k][x]);
        fout << rez << "\n";
    }
}

int main() {
    
    citire();
    kruskal();
    solve();
    
    fin.close();
    fout.close();
    
    return 0;
}