#include <bits/stdc++.h>

using namespace std;

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

const int NMAX = 3e4;
const int LOGMAX = 15;

int n, m, k, ind_e;
tuple<int, int, int> edges[NMAX + 1];
vector<int> g[NMAX + 1];
int parent[NMAX + 1];
int depth[NMAX + 1];
int euler[2 * NMAX + 1];
int rmq[LOGMAX + 1][2 * NMAX + 1];
int pos_e[NMAX + 1];
int value[NMAX + 1];

void init(int n) {
    for(int i = 1; i <= n; i++) {
        parent[i] = i;
    }
}

int get_root(int x) {
    return parent[x] = (parent[x] == x ? x : get_root(parent[x]));
}

void join(int a, int b, int c) {
    a = get_root(a);
    b = get_root(b);
    if(a == b) {
        return;
    }

    n++;
    parent[n] = n;
    value[n] = c;

    parent[a] = parent[b] = n;
    g[n].push_back(a);
    g[n].push_back(b);
}

void DFS(int node, int dad = 0) {
    depth[node] = depth[dad] + 1;
    euler[++ind_e] = node;
    pos_e[node] = ind_e;

    for(int next_node : g[node]) {
        if(next_node != dad) {
            DFS(next_node, node);
            euler[++ind_e] = node;
        }
    }
}

void precompute() {
    for(int i = 1; i <= ind_e; i++) {
        rmq[0][i] = euler[i];
    }
    for(int k = 1; (1 << k) <= ind_e; k++) {
        for(int i = 1; i + (1 << k) - 1 <= ind_e; i++) {
            int n1 = rmq[k - 1][i];
            int n2 = rmq[k - 1][i + (1 << (k - 1))];
            rmq[k][i] = (depth[n1] < depth[n2] ? n1 : n2);
        }
    }
}

int get_lca(int x, int y) {
    x = pos_e[x];
    y = pos_e[y];
    if(x > y) {
        swap(x, y);
    }

    int k = 31 - __builtin_clz(y - x + 1);
    int n1 = rmq[k][x];
    int n2 = rmq[k][y - (1 << k) + 1];
    return (depth[n1] < depth[n2] ? n1 : n2);
}

int main() {
    fin >> n >> m >> k;
    for(int i = 1; i <= m; i++) {
        int a, b, c;
        fin >> a >> b >> c;
        edges[i] = {c, a, b};
    }

    sort(edges + 1, edges + m + 1);
    init(n);
    for(int i = 1; i <= m; i++) {
        auto [c, a, b] = edges[i];
        join(a, b, c);
    }

    for(int i = 1; i <= n; i++) {
        if(parent[i] == i) {
            DFS(i);
        }
    }
    precompute();

    while(k--) {
        int a, b;
        fin >> a >> b;
        fout << value[get_lca(a, b)] << '\n';
    }
    return 0;
}