#include <bits/stdc++.h>

using namespace std;

const int N_MAX = 15001, M_MAX = 30001, K_MAX = 15001;
int N, M, K;

struct Edge
{
    int v1, v2, c;

    inline bool operator< (const Edge& rhs) const
    {
        return c < rhs.c;
    }
};

struct Query
{
    int v1, v2, ans;
};

Edge G[M_MAX];
Query queries[K_MAX];

struct DisjointSetUnion
{
    int T[N_MAX];
    int Size[N_MAX];
    int N;

    inline void MakeSet(int v)
    {
        T[v] = v;
        Size[v] = 1;
    }

    int FindSet(int v)
    {
        if(T[v] != v)
            T[v] = FindSet(T[v]);
        return T[v];
    }

    bool AreDisjointed(int a, int b)
    {
        return FindSet(a) != FindSet(b);
    }

    bool CanUnionSet(int a, int b)
    {
        a = FindSet(a);
        b = FindSet(b);

        if(a == b)
            return false;

        if(Size[a] < Size[b])
            swap(a, b);

        T[b] = a;
        Size[a] += Size[b];

        return true;
    }

    void Build(int N)
    {
        this->N = N;

        for(int i = 1; i <= N; i++)
            MakeSet(i);
    }
} dsu;

void SetInput(string name)
{
    ios_base::sync_with_stdio(false);
    cin.tie(nullptr);

    (void)!freopen((name + ".in").c_str(), "r", stdin);
    (void)!freopen((name + ".out").c_str(), "w", stdout);
}

void ReadInput()
{
    cin >> N >> M >> K;
    for(int i = 0; i < M; i++)
        cin >> G[i].v1 >> G[i].v2 >> G[i].c;

    for(int i = 0; i < K; i++)
    {
        cin >> queries[i].v1 >> queries[i].v2;
        queries[i].ans = -1;
    }
}

void Solve()
{
    sort(G, G + M);

    /// Kruskal

    for(int i = 0; i < M; i++)
        if(dsu.CanUnionSet(G[i].v1, G[i].v2))
            for(int j = 0; j < K; j++)
                if(queries[j].ans == -1 && dsu.FindSet(queries[j].v1) == dsu.FindSet(queries[j].v2))
                    queries[j].ans = G[i].c;

    for(int i = 0; i < K; i++)
        cout << queries[i].ans << '\n';
}

int main()
{
    SetInput("radiatie");

    ReadInput();
    dsu.Build(N);
    Solve();

    return 0;
}