#include <fstream>
#include <vector>
#include <algorithm>
#define mp make_pair

using namespace std;

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

const int Log = 15;
const int Nmax = 15005;
const int Mmax = 30005;

vector<pair<int, int>> APM[Nmax];

struct graf
{
    int x;
    int y;
    int c;
}v[Mmax];

bool cmp (graf A, graf B)
{
    return A.c < B.c;
}

int Find (int x, vector<int>&dad)
{
    if (dad[x] == x) return x;
    return dad[x] = Find (dad[x], dad);
}

void Union (int x, int y, vector<int>&dad)
{
    dad[x] = y;
}

void DFS (int p, vector<int>&nivel, vector<bool>&viz, vector<vector<int>>&rmq, vector<vector<int>>&dp)
{
    viz[p] = 1;

    for (auto i = 0; i < APM[p].size(); i++)
    {
        int w = APM[p][i].first;

        if (!viz[w])
        {
            rmq[0][w] = APM[p][i].second;
            dp[0][w] = p;
            nivel[w] = nivel[p] + 1;
            DFS(w, nivel, viz, rmq, dp);
        }
    }
}

int lca (int x, int y, vector<int>&nivel, vector<int>&logaritm, vector<vector<int>>&dp)
{
    if (nivel[x] < nivel[y])
        swap (x, y);

    int log1 = logaritm[nivel[x]];
    if ((1<<log1) == nivel[x])
        log1--;

    int log2 = logaritm[nivel[y]];
    if ((1<<log2) == nivel[y])
        log2--;

    for (int i = log1; i >= 0; i--)
        if (nivel[x] - (1<<i) >= nivel[y])
            x = dp[i][x];

    if (x == y)
        return x;

    for (int i = log2; i >= 0; i--)
        if (dp[i][x] && dp[i][x] != dp[i][y])
        {
            x = dp[i][x];
            y = dp[i][y];
        }

    return dp[0][x];
}

int lant (int L, int x, vector<int>&nivel, vector<vector<int>>&rmq, vector<vector<int>>&dp)
{
    int maxim = 0;
    int dist = nivel[x] - nivel[L];

    for (int i = Log; i >= 0; i--)
    {
        if (dist >= (1<<i))
        {
            maxim = max (maxim, rmq[i][x]);
            x = dp[i][x];
            dist = dist - (1<<i);
        }
    }

    return maxim;
}

int main()
{
    int n, m, k, nr = 0;
    vector<int> dad(Nmax), nivel(Nmax), logaritm(Nmax);
    vector<vector<int>> dp(Log, vector<int>(Nmax));
    vector<vector<int>> rmq(Log, vector<int>(Nmax));
    vector<bool> viz(Nmax);

    in >> n >> m >> k;

    dad[1] = 1;
    for (int i = 2; i <= n; i++)
    {
        dad[i] = i;
        logaritm[i] = logaritm[i / 2] + 1;
    }

    for (int i = 1; i <= m; i++)
        in >> v[i].x >> v[i].y >> v[i].c;

    sort (v + 1, v + m + 1, cmp);

    for (int i = 1; i <= m; i++)
    {
        if (nr == n - 1)
            break;

        int xx = Find(v[i].x, dad);
        int yy = Find(v[i].y, dad);

        if (xx != yy)
        {
            nr++;
            Union (xx, yy, dad);

            APM[v[i].x].push_back(mp(v[i].y, v[i].c));
            APM[v[i].y].push_back(mp(v[i].x, v[i].c));
        }
    }

    nivel[1] = 1;
    DFS(1, nivel, viz, rmq, dp);

    for (int i = 1; (1<<i) <= n; i++)
        for (int j = 1; j <= n; j++)
            dp[i][j] = dp[i - 1][dp[i - 1][j]];

    for (int i = 1; (1 << i) <= n; i++)
        for (int j = 1; j <= n; j++)
        {
            if (nivel[j] < (1 << i)) continue;
            rmq[i][j] = max(rmq[i - 1][j], rmq[i - 1][dp[i - 1][j]]);
        }

    for (int i = 1; i <= k; i++)
    {
        int x, y;
        in >> x >> y;

        int L = lca (x, y, nivel, logaritm, dp);

        out << max (lant(L, x, nivel, rmq, dp), lant(L, y, nivel, rmq, dp)) << '\n';
    }

    return 0;
}