#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 F[nmax], L[nmax], Max[18][2*nmax], Exp[2*nmax];

void euler(int nod) {
    viz[nod] = true;
    ++e;
    F[nod] = e;
    for (int i = 0; i < V[nod].size(); i++)
        if (!viz[V[nod][i].first]) {
            Max[0][++q] = V[nod][i].second;
            euler(V[nod][i].first);
            ++e;
            Max[0][++q] = V[nod][i].second;
        }
    L[nod] = e;
}

void preprocess() {
    int l = e - 1;
    for (int i = 1; (1<<i) <= l; i++)
        for (int j = 1; j <= l - (1<<i) + 1; j++) {
            int dr = j + (1<<i) - 1;
            int mid = dr - (1<<(i-1)) + 1;
            Max[i][j] = max(Max[i-1][j], Max[i-1][mid]);
        }
}

void solve() {
    euler(1);
    preprocess();
    Exp[1] = 0;
    for (int i = 2; i <= e; i++)
        Exp[i] = Exp[i/2] + 1;
    for (int i = 1; i <= k; i++) {
        int x, y, xf, yf, xl, yl;
        fin >> x >> y;
        xf = F[x], yf = F[y];
        xl = L[x], yl = L[y];
        
        int Ma = 1<<30;
        // xf yl
        if (abs(xf - yl) + 1 < Ma) {
            Ma = abs(xf - yl) + 1;
            x = min(xf, yl);
            y = max(xf, yl);
        }
        // xf yf
        if (abs(xf - yf) + 1 < Ma) {
            Ma = abs(xf - yf) + 1;
            x = min(xf, yf);
            y = max(xf, yf);
        }
        // xl yl
        if (abs(xl - yl) + 1 < Ma) {
            Ma = abs(xl - yl) + 1;
            x = min(xl, yl);
            y = max(xl, yl);
        }
        // xl yf
        if (abs(xl - yf) + 1 < Ma) {
            Ma = abs(xl - yf) + 1;
            x = min(xl, yf);
            y = max(xl, yf);
        }
        
        int l = y - x + 1;
        int k = Exp[l];
        int rez = Max[k][x];
        x = y - (1<<k) + 1;
        rez = max(rez, Max[k][x]);
        fout << rez << "\n";
    }
}

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