#include <fstream>
#include <vector>
#include <algorithm>
#include <tuple>

using namespace std;

ifstream cin("radiatie.in");
ofstream cout("radiatie.out");

struct muchie
{
    int node1, node2, cost;

    bool operator<(const muchie& temp) const
    {
        return cost < temp.cost;
    }
};

struct ceva
{
    int node, cost;
};

int n, m, q;

vector<vector<ceva>> adj;
vector<int> parent;
vector<int> rang;
int root(int x)
{
    int repX;
    for (repX = x; repX != parent[repX]; repX = parent[repX]);
    return repX;
}

void unire(int x, int y)
{
    int repX = root(x);
    int repY = root(y);

    if (repX == repY) return;

    if (rang[repX] > rang[repY]) parent[repY] = repX;
    else if (rang[repY] > rang[repX]) parent[repX] = repY;
    else
    {
        rang[repX]++;
        parent[repY] = repX;
    }
}

vector<int> depth;
int rmq[15][15001];
int ancest[15][15001];
void dfs(int node, int parent)
{
    for (auto pula : adj[node])
    {
        int vecin = pula.node;
        int cost = pula.cost;
        if (vecin == parent) continue;

        depth[vecin] = depth[node] + 1;
        rmq[0][vecin] = cost;
        ancest[0][vecin] = node;

        for (int e = 1; e <= 14; e++)
        {
            if (ancest[e - 1][ancest[e - 1][vecin]] == 0)
                break;

            ancest[e][vecin] = ancest[e - 1][ancest[e - 1][vecin]];
            rmq[e][vecin] = max(rmq[e - 1][vecin], rmq[e - 1][ancest[e - 1][vecin]]);
        }
        dfs(vecin, node);
    }
}

pair<int, int> kth(int u, int k) {
    pair<int, int> res(u, 0);
    for (int p = 0; (1 << p) <= k; ++p) {
        if ((k >> p) & 1) {
            res.second = max(res.second, rmq[p][res.first]);
            res.first = ancest[p][res.first];
        }
    }
    return res;
}

int query(int u, int v) {
    if (depth[u] > depth[v]) {
        swap(u, v);
    }
    int ans = 0;
    if (depth[u] != depth[v]) {
        tie(v, ans) = kth(v, depth[v] - depth[u]);
    }
    if (u == v) {
        return ans;
    }
    for (int p = 15; p >= 0; --p) {
        if (ancest[p][u] != ancest[p][v]) {
            ans = max({ ans, rmq[p][u], rmq[p][v] });
            u = ancest[p][u];
            v = ancest[p][v];
        }
    }
    return max({ ans, rmq[0][u], rmq[0][v] });
}

int main()
{
    cin >> n >> m >> q;
    vector<muchie> muc;
    muc.resize(m + 1);
    for (int i = 1; i <= m; i++)
    {
        int x, y, cost;
        cin >> x >> y >> cost;
        muc[i] = { x, y, cost };
    }

    sort(muc.begin() + 1, muc.begin() + m + 1);
    parent.resize(m + 1), rang.resize(m + 1);
    for (int i = 1; i <= m; i++)
    {
        parent[i] = i;
        rang[i] = 1;
    }


    adj.resize(n + 1);
    for (int i = 1; i <= m; i++)
    {
        int node1 = muc[i].node1;
        int node2 = muc[i].node2;
        int cost = muc[i].cost;

        if (root(node1) != root(node2))
        {
            adj[node1].push_back({ node2, cost });
            adj[node2].push_back({ node1, cost });
            unire(node1, node2);
        }
    }

    depth.resize(n + 1);
    dfs(1, -1);

    for (int i = 1; i <= q; i++)
    {
        int x, y;
        cin >> x >> y;
        cout << query(x, y) << '\n';
    }
}