#include <iostream>
#include <fstream>
#include <vector>
#include <algorithm>
#include <cmath>
#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, q = 0;
vector < pair<int, 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;
    }
}

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(make_pair(M[i].y, M[i].cost));
        V[M[i].y].push_back(make_pair(M[i].x, M[i].cost));
        if (nrm == n-1)
            break;
    }
}

int e;
bool viz[nmax];
int P[nmax], Exp[2*nmax], Poz[17][2*nmax], Nivel[nmax], Min[17][2*nmax], E[2*nmax], Max[17][nmax], tata[17][nmax];

void euler(int nod, int niv) {
    viz[nod] = true;
    E[++E[0]] = nod;
    Nivel[nod] = niv;
    P[nod] = E[0];
    for (int i = 0; i < V[nod].size(); i++)
        if (!viz[V[nod][i].first]) {
            tata[0][V[nod][i].first] = nod;
            Max[0][V[nod][i].first] = V[nod][i].second;
            euler(V[nod][i].first, niv+1);
            E[++E[0]] = nod;
        }
}

void preprocess() {
    for (int i = 1; i <= E[0]; i++)
        Min[0][i] = Nivel[E[i]],
        Poz[0][i] = i;
    Exp[1] = 0;
    for (int i = 2; i <= E[0]; i++)
        Exp[i] = Exp[i/2] + 1;
    for (int i = 1; i <= Exp[E[0]]; i++)
        for (int j = 1; j <= E[0] - (1<<i) + 1; j++) {
            int dr = j + (1<<i) - 1;
            int mid = dr - (1<<(i-1)) + 1;
            Min[i][j] = Min[i-1][j];
            Poz[i][j] = Poz[i-1][j];
            if (Min[i][j] > Min[i-1][mid]) {
                Min[i][j] = Min[i-1][mid];
                Poz[i][j] = Poz[i-1][mid];
            }
        }
    for (int i = 1; i <= Exp[n]; i++)
        for (int j = 1; j <= (n - (1<<i) + 1); j++) {
            int gran = tata[i-1][j];
            tata[i][j] = tata[i-1][gran];
            Max[i][j] = max(Max[i-1][j], Max[i-1][gran]);
        }
}

int mMax(int p, int nod, int rez) {
    if (p == 0)
        return rez;
    int i = Exp[p];
    return mMax(p-(1<<i), tata[i][nod], max(rez, Max[i][nod]));
}

void solve() {
    euler(1, 1);
    preprocess();
    for (int i = 1; i <= k; i++) {
        int x, y;
        fin >> x >> y;

        int xi = P[x];
        int yi = P[y];

        if (xi > yi) swap(xi, yi);

        int l = yi - xi + 1;
        int k = Exp[l];

        int rez = Min[k][xi];
        int lca = E[Poz[k][xi]];

        int PozL = Poz[k][xi];

        xi = yi - (1<<k) + 1;

        if (Min[k][xi] < rez)
            lca = E[Poz[k][xi]];

        rez = 0;

        l = Nivel[x] - Nivel[lca];
        rez = max(rez, mMax(l, x, 0));
        l = Nivel[y] - Nivel[lca];
        rez = max(rez, mMax(l, y, 0));

        fout << rez << "\n";

    }
}

int main() {

    citire();
    kruskal();
    solve();

    fin.close();
    fout.close();

    return 0;
}