#include <iostream>
#include <fstream>
#include <vector>
#include <algorithm>
#define nmax 15005
#define logmax 15
using namespace std;
ifstream f;
ofstream g;
struct edge{
    int x;
    int y;
    int cost;
};
struct ancestor{
    int stramos;
    int m_max;
};
ancestor dp[logmax][nmax];
vector<edge> V;
vector<pair<int,int>> G[nmax];
int n,m,k,a,b,c,rep[nmax],rang[nmax],euler[2*nmax],lvl[2*nmax],ap[nmax],curr,log[2*nmax],tata[nmax],costtata[nmax],nivel[nmax];
int rmq[logmax][2*nmax];
bool viz[nmax];
void read()
{
    f.open("radiatie.in",ios::in);
    f>>n>>m>>k;
    for(int i=1;i<=m;i++)
    {
        f>>a>>b>>c;
        V.push_back({a,b,c});
    }
}
int r(int x)
{
    if(x==rep[x])
        return x;
    else return r(rep[x]);
}
void unire(int x,int y)
{
    if(rang[x]==rang[y])
    {
        rang[x]++;
        rep[y]=x;
    }
    if(rang[x]>rang[y])
    {
        rep[y]=x;
    }
    if(rang[y]>rang[x])
    {
        rep[x]=y;
    }
}
bool cmp(edge A,edge B)
{
    return A.cost<B.cost;
}
void init()
{
    for(int i=1;i<=n;i++)
        rep[i]=i,rang[i]=1;
}
void kruskal()
{
    sort(V.begin(),V.end(),cmp);
    init();
    for(auto a:V)
    {
        int rx=r(a.x);
        int ry=r(a.y);
        if(rx!=ry)
        {
            unire(rx,ry);
            G[a.x].push_back(make_pair(a.y,a.cost));
            G[a.y].push_back(make_pair(a.x,a.cost));
        }
    }
}
void dfs(int x,int lv)
{
   viz[x]=true;
   nivel[x]=lv;
   euler[++curr]=x;
   lvl[curr]=lv;
   ap[x]=curr;
   for(auto a:G[x])
   {
       if(!viz[a.first])
       {
           tata[a.first]=x;
           costtata[a.first]=a.second;
           dfs(a.first,lv+1);
           euler[++curr]=x;
           lvl[curr]=lv;
       }
   }
}
void compute_rmq()
{
    log[2]=1;
    for(int i=3;i<=curr;i++)
    {
        log[i]=log[i>>1]+1;
    }
    for(int j=1;j<=curr;j++)
        rmq[0][j]=j;
   for(int i=1;i<=log[curr];i++)
   {
       for(int j=1;j+(1<<i)-1<=curr;j++)
       {
           int index_minim;
           if(lvl[rmq[i-1][j]]<lvl[rmq[i-1][j+(1<<(i-1))]])
               index_minim=rmq[i-1][j];
           else index_minim=rmq[i-1][j+(1<<(i-1))];
           rmq[i][j]=index_minim;
       }
   }
}
int lca(int x,int y)
{
    int st=ap[x];
    int dr=ap[y];
    if(st>dr)
        swap(st,dr);
    int ans;
    if(lvl[rmq[log[dr-st+1]][st]]<lvl[rmq[log[dr-st+1]][dr-(1<<log[dr-st+1])+1]])
        ans=rmq[log[dr-st+1]][st];
    else ans=rmq[log[dr-st+1]][dr-(1<<log[dr-st+1])+1];
    return euler[ans];
}
void compute_dp()
{
    for(int j=1;j<=n;j++)
    {
        dp[0][j].stramos=tata[j];
        dp[0][j].m_max=costtata[j];
    }
    for(int i=1;i<=log[n];i++)
    {
        for(int j=1;j<=n;j++)
        {
            dp[i][j].stramos=dp[i-1][dp[i-1][j].stramos].stramos;
            if(dp[i][j].stramos)
              dp[i][j].m_max=max(dp[i-1][j].m_max,dp[i-1][dp[i-1][j].stramos].m_max);
        }
    }
}
void solve()
{
    g.open("radiatie.out",ios::out);
    for(int i=1;i<=k;i++)
    {
        f>>a>>b;
        int lc=lca(a,b);
        if(lc==a)///avem un path a->b in jos
        {
            int ord=nivel[b]-nivel[a],cmax=0,p=b;
            for(int j=0;j<=log[ord];j++)
            {
                if(ord&(1<<j))///daca bitul j este setat
                {
                    if(cmax<dp[j][p].m_max)
                        cmax=dp[j][p].m_max;
                    p=dp[j][p].stramos;
                }
            }
            g<<cmax<<'\n';
        }
        else if(lc==b)///avem un path b->a in jos
        {

            int ord=nivel[a]-nivel[b],cmax=0,p=a;
            for(int j=0;j<=log[ord];j++)
            {
                if(ord&(1<<j))///daca bitul j este setat
                {
                    if(cmax<dp[j][p].m_max)
                        cmax=dp[j][p].m_max;
                    p=dp[j][p].stramos;
                }
            }
            g<<cmax<<'\n';
        }
        else{///lca ul este diferit de ambele noduri
            int ord=nivel[a]-nivel[lc],cmax=0,p=a;
            for(int j=0;j<=log[ord];j++)
            {
                if(ord&(1<<j))///daca bitul j este setat
                {
                    if(cmax<dp[j][p].m_max)
                        cmax=dp[j][p].m_max;
                    p=dp[j][p].stramos;
                }
            }
            ord=nivel[b]-nivel[lc];
            int cmax2=0;
            p=b;
            for(int j=0;j<=log[ord];j++)
            {
                if(ord&(1<<j))///daca bitul j este setat
                {
                    if(cmax2<dp[j][p].m_max)
                        cmax2=dp[j][p].m_max;
                    p=dp[j][p].stramos;
                }
            }
            g<<max(cmax,cmax2)<<'\n';
        }
    }
    f.close();
    g.close();
}
int main()
{
    read();
    kruskal();
    dfs(1,0);
    compute_rmq();
    compute_dp();
    solve();
    return 0;
}