#include <bits/stdc++.h>
#define Nmax 30005
#define pb push_back
#define f first
#define s second
using namespace std;

ifstream f("radiatie.in");
ofstream g("radiatie.out");

int N, M, K, Q;
struct edge{
    int x, y, c;
};
edge v[Nmax];
bool cmp(edge a, edge b) {
   return a.c < b.c;
}
int h[Nmax], r[Nmax];
int root(int x) {
    while (r[x]) x = r[x];
    return x;
}

vector<pair<int, int> > G[Nmax]; vector<int> ans[Nmax];
bool vis[Nmax];
int E[3 * Nmax], lev[3 * Nmax], rmq[3 * Nmax][20][2], val[Nmax], lg[3 * Nmax];

void update(int node, int father) {
   E[++K] = node;
   ans[node].pb(K);
   lev[K] = lev[ans[father][0]] + 1;
}
void DFS(int node, int father) {
    update(node, father);
    vis[node] = 1;
    for (auto it: G[node])
     if (!vis[it.f])
        val[it.f] = it.s, DFS(it.f, node), update(node, father);
}
int compute(int le, int ri, bool dim) {
    int mid = lg[ri - le + 1];
    int a = rmq[le][mid][0], b = rmq[ri - (1 << mid) + 1][mid][0];
    if (dim == 0) {
        if (lev[a] < lev[b]) return E[a];
        return E[b];
    }
    int c = rmq[le][mid][1], d = rmq[ri - (1 << mid) + 1][mid][1];
    return max(c, d);
}
void RMQ() {
    for (int i = 2; i <= K; ++i)
        lg[i] = lg[i / 2] + 1;
    for (int i = 1; i <= K; ++i)
        rmq[i][0][0] = i, rmq[i][0][1] = val[E[i]];

    for (int j = 1; (1 << j) <= K; ++j)
    for (int i = 1; i + (1 << j) - 1 <= K; ++i) {
        int a = rmq[i][j - 1][0], b = rmq[i + (1 << (j - 1))][j - 1][0];
        if (lev[a] < lev[b]) rmq[i][j][0] = a;
        else rmq[i][j][0] = b;
        a = rmq[i][j - 1][1], b = rmq[i + (1 << (j - 1))][j - 1][1];
        rmq[i][j][1] = max(a, b);
    }
}
int pos(int x, int value) {
    int le = 0,ri,sol;
    sol = ri = ans[value].size() - 1;
    while (le <= ri) {
        int mid = (le + ri) / 2;
        if (ans[value][mid] <= x) sol = mid, le = mid + 1;
        else ri = mid - 1;
    }
      return ans[value][sol] + 1;
}
int main()
{
    f >> N >> M >> Q;
    for (int i = 1; i <= M; ++i)
        f >> v[i].x >> v[i].y >> v[i].c;
    sort(v + 1, v + M + 1, cmp);

    for (int i = 1; i <= M; ++i)
    if (root(v[i].x) != root(v[i].y)) {
        G[v[i].x].pb({v[i].y, v[i].c}), G[v[i].y].pb({v[i].x, v[i].c});
        int x = root(v[i].x), y = root(v[i].y);
        if (h[x] >= h[y]) r[y] = x;
        else r[x] = y;
        if (h[x] == h[y]) ++h[x];
    }

    ans[0].pb(0);
    DFS(1, 0); RMQ();

    for (int q = 1; q <= Q; ++q) {
        int x, y, p;
        f >> x >> y;
        int lca = compute(ans[x][0], ans[y][0], 0);
        int px = ans[x][0], py = ans[y][0];
        if (x == lca) ++px;
        if (y == lca) ++py;
        g << max(compute(pos(px, lca), px, 1), compute(pos(py, lca), py, 1)) << '\n';
    }
    return 0;
}