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

using namespace std;

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

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

int n, m, k, nr;
int dad[Nmax], nivel[Nmax], logaritm[Nmax];
bool viz[Nmax];

int dp[15][Nmax], rmq[15][Nmax];

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)
{
    if (dad[x] == x) return x;
    return dad[x] = Find (dad[x]);
}

void Union (int x, int y)
{
    dad[x] = y;
}

void DFS (int p)
{
    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);
        }
    }
}

int lca (int x, int y)
{
    int log1, log2;

    if (nivel[x] < nivel[y])
        swap (x, y);

    for (log1 = 1; (1<<log1) < nivel[x]; log1++);
    for (log2 = 1; (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)
{
    int maxim = 0;
    int dist = nivel[x] - nivel[L];

    for (int i = 15; 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()
{
    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);
        int yy = Find(v[i].y);

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

            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);

    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);

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

    return 0;
}