#include <bits/stdc++.h>
#define DMAX 15010
#define LMAX 20

using namespace std;

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

struct nume{
    int x,c;
};
struct nume2{
    int y,x,c;
};

vector <nume> V[DMAX];
vector <nume> arb[DMAX];
vector <nume> trans[DMAX];
priority_queue <nume2> heap;

int dp[DMAX];
bool uz[DMAX];

int M[2*DMAX][LMAX];
int ind[DMAX];
int euler[2*DMAX];
int h[DMAX];
int level[2*DMAX];
vector < vector <int> > dist;

int n,m,k,cate,hmax;

inline bool operator<(nume2 x,nume2 y){
    return x.c>y.c;
}
inline int maxim(int x,int y){
    if(x>y)
       return x;
    return y;
}

void citire();
void prim();
void dfs(int node);
void dfs2(int node,int rad,int h);
void constr();

int main(){
    int i,x,y,node,a,b,aux,kk;
    citire();
    prim();
    memset(uz,0,sizeof(uz));
    dfs(1);
    dist.resize(n+3);
    for(i=1;i<=n;i++)
        dist[i].resize(hmax-h[i]+3);
    constr();

    for(i=1;i<=n;i++)
        dfs2(i,i,1);
    while(k--)
        {fin>>a>>b;
         x=ind[a];
         y=ind[b];
         if(x<y)
            {aux=y;
             y=x;
             x=aux;
            }
         kk=log2(x-y+1);
         if(level[M[y][kk]] < level[M[x-(1<<kk)+1][kk]])
            node=euler[M[y][kk]];
            else
            node=euler[M[x-(1<<kk)+1][kk]];

         x=h[a]-h[node];
         y=h[b]-h[node];
         fout<<maxim(dist[a][x],dist[b][y])<<'\n';
        }

    return 0;
}
void citire(){
    int i,x,y,cost;
    fin>>n>>m>>k;
    for(i=1;i<=m;i++)
        {fin>>x>>y>>cost;
         V[x].push_back({y,cost});
         V[y].push_back({x,cost});
        }
}
void prim(){
    int i,j;
    nume2 var;
    uz[1]=true;
    for(i=0;i<V[1].size();i++)
        heap.push({1,V[1][i].x,V[1][i].c});
    for(i=2;i<=n;i++)
        {while(uz[heap.top().x])
               heap.pop();
         var=heap.top();
         dp[var.x]=var.c;
         uz[var.x]=true;

         arb[var.y].push_back({var.x,var.c});
         trans[var.x].push_back({var.y,var.c});

         for(j=0;j<V[var.x].size();j++)
             if(!uz[V[var.x][j].x])
                heap.push({var.x,V[var.x][j].x,V[var.x][j].c});
        }
}
void dfs(int node){
    int i;

    cate++;
    euler[cate]=node;
    level[cate]=h[node];

    uz[node]=true;

    if(!ind[node])
       ind[node]=cate;

    for(i=0;i<arb[node].size();i++)
        if(!uz[arb[node][i].x])
           {h[arb[node][i].x]=h[node]+1;
            hmax=maxim(hmax,h[node]);
            dfs(arb[node][i].x);

            cate++;
            euler[cate]=node;
            level[cate]=h[node];
           }
}
void constr(){
    int i,j;
    for(i=1;i<=2*n-1;i++)
        M[i][0]=i;
    for(j=1; (1<<j)<=2*n-1; j++)
        for(i=1;i+(1<<j)-1<=2*n-1;i++)
            if(level[M[i][j-1]] < level[M[i+(1<<(j-1))][j-1]])
                M[i][j]=M[i][j-1];
                else
                M[i][j]=M[i+(1<<(j-1))][j-1];
}
void dfs2(int node,int rad,int h){
    int i;
    for(i=0;i<trans[node].size();i++)
        {dist[rad][h]=maxim(dist[rad][h-1],trans[node][i].c);
         dfs2(trans[node][i].x,rad,h+1);
        }
}