#include <bits/stdc++.h>
using namespace std;

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

const int maxn = 15002;
const int maxlog = 16;
int n, m, q, f[maxn];
int str[maxlog][maxn], dst[maxlog][maxn], rmq[maxlog<<2][maxn<<2];
int E[maxn<<2], L[maxn<<2], P[maxn], nivel[maxn], k, lg[maxn<<2];
struct st{
    int x, y, c;
};
vector<st>A;
vector<st>B;
vector<pair<int,int> >G[maxn];

inline bool cmp(st a, st b)
{
    return a.c<b.c;
}

int find_f(int nod)
{
    if(nod==f[nod])
    {
        return nod;
    }
    return f[nod]=find_f(f[nod]);
}

void APM()
{
    int muchii=0;
    for(int i=1; i<=n; i++)
    {
        f[i]=i;
    }
    sort(A.begin(),A.end(),cmp);
    for(int i=0; muchii<n-1; i++)
    {
        if(find_f(A[i].x)!=find_f(A[i].y))
        {
            muchii++;
            B.push_back(A[i]);
            f[find_f(A[i].y)]=find_f(f[A[i].x]);
        }
    }
    for(auto it:B)
    {
        G[it.x].push_back({it.y,it.c});
        G[it.y].push_back({it.x,it.c});
    }
}

void dfs(int nod, int ni, int tata)
{
    k++;
    E[k]=nod;
    L[k]=ni;
    P[nod]=k;
    nivel[nod]=ni;
    for(auto it:G[nod])
    {
        if(it.first!=tata)
        {
            dfs(it.first, ni+1, nod);
            k++;
            E[k]=nod;
            L[k]=ni;
        }
        else
        {
            str[0][nod]=it.first;
            dst[0][nod]=it.second;
        }
    }
}

void RMQ()
{
    rmq[0][1]=1;
    for(int i=2; i<=k; i++)
    {
        rmq[0][i]=i;
        lg[i]=lg[i/2]+1;
    }
    for(int i=1; (1<<i)<k; i++)
    {
        for(int j=1; j<=k-(1<<i); j++)
        {
            rmq[i][j]=rmq[i-1][j];
            int next=1<<(i-1);
            if(L[rmq[i][j]]>L[rmq[i-1][j+next]])
            {
                rmq[i][j]=rmq[i-1][j+next];
            }
        }
    }
    for(int i=1; i<=15; i++)
    {
        for(int j=1; j<=n; j++)
        {
            str[i][j]=str[i-1][str[i-1][j]];
            dst[i][j]=max(dst[i-1][j],dst[i-1][str[i-1][j]]);
        }
    }
}

int LCA(int x, int y)
{
    int dif, niv, extra, a=P[x], b=P[y];
    if(a>b)
        swap(a,b);

    //fout<<a<<' '<<b<<'\n';
    dif=b-a+1;
    niv=lg[dif];
    extra=dif-(1<<niv);
    if(L[rmq[niv][a]]>L[rmq[niv][a+extra]])
    {
        return E[rmq[niv][a+extra]];
    }
    return E[rmq[niv][a]];
}

int solve(int nod, int tata)
{
    int res=0, logh=lg[nivel[nod]-nivel[tata]]+1, dif=nivel[nod]-nivel[tata], x=nod;
    while(logh--)
    {
        if(dif&(1<<logh))
        {
            res=max(res,dst[logh][x]);
            x=str[logh][x];
        }
    }
    return res;
}

int main()
{
    int q1, q2;
    st a;
    fin>>n>>m>>q;
    for(int i=1; i<=m; i++)
    {
        fin>>a.x>>a.y>>a.c;
        A.push_back(a);
    }
    APM();
    for(int i=1; i<=n; i++)
    {
        if(!str[0][i])
        {
            dfs(i,1,0);
        }
    }
    RMQ();
    while(q--)
    {
        fin>>q1>>q2;
        int lc=LCA(q1,q2);
        //fout<<lc<<'\n';
        //fout<<solve(q1, lc)<<' '<<solve(q2, lc)<<' ';
        fout<<max(solve(q1,lc),solve(q2,lc))<<'\n';
    }
    return 0;
}