# include <cstdio>
# include <algorithm>
# include <vector>

using namespace std;

# define FIN "radiatie.in"
# define FOUT "radiatie.out"
# define max(a,b) (a > b ? a : b)
# define MAX_M 30010
# define MAX_N 15005
# define MAX_D 16

struct muchie
{
   int a, b, c;
} G[MAX_M];

int N, M, KO, i, j, ct, a, b, LCA, aux, d, rasp;
int H[MAX_M];
int T[MAX_M];
int P[MAX_N];
int D[MAX_N];
int Rmq[MAX_D][MAX_M];
int Str[MAX_D][MAX_N];
int Max[MAX_D][MAX_N];
vector <int> E[MAX_N];
vector <int> C[MAX_N];

    int cmp(muchie a, muchie b)
    {
        return a.c < b.c;
    }
    
    int parinte(int a)
    {
        while (T[a])  a = T[a];
        return a;
    }
    
    void df(int nod)
    {
        int i, L;
        
        H[nod] = 1;
        L = E[nod].size();
        Rmq[0][++ct] = nod;
        P[nod] = ct;
        
        for (i = 0; i < L; ++i)
          if (!H[E[nod][i]])
            {
               Str[0][E[nod][i]] = nod;
               Max[0][E[nod][i]] = C[nod][i];
               D[E[nod][i]] = D[nod] + 1;
               df(E[nod][i]);
               Rmq[0][++ct] = nod;
            }
    }
    
    int comp(int a, int LCA)
    {
        int rez = 0;
        
        while (a != LCA)
          {
             rez = max(rez, Max[H[D[a]-D[LCA]]][a]);
             a = Str[H[D[a]-D[LCA]]][a];
          }
          
        return rez;
    }

    int main()
    {
        freopen(FIN,"r",stdin);
        freopen(FOUT,"w",stdout);
        
        scanf("%d%d%d",&N, &M, &KO);
        for (i = 1; i <= M; ++i)
          scanf("%d%d%d",&G[i].a, &G[i].b, &G[i].c);
          
        sort(G + 1, G + M + 1, cmp);
               
        for (i = 1; i <= M; ++i)
          {
             int father1, father2;
             
             father1 = parinte(G[i].a);
             father2 = parinte(G[i].b);
             
             if (father1 != father2)
               {
                  E[G[i].a].push_back(G[i].b);
                  E[G[i].b].push_back(G[i].a);
                  C[G[i].a].push_back(G[i].c);
                  C[G[i].b].push_back(G[i].c);
                  
                  if (H[father1] < H[father2])
                    T[father1] = father2;
                  if (H[father1] > H[father2])
                    T[father2] = father1;
                  if (H[father1] == H[father2])
                    {
                       T[father1] = father2;
                       H[father2]++;
                    }                 
               }
          }
        
        for (i = 1; i <= N; H[i] = 0, ++i);
          
        ct = 0;
        for (i = 1; i <= N; ++i)
          if (!H[i]) df(i);
        
        H[1] = 0;
        for (i = 2; i <= ct; ++i)
          H[i] = H[i >> 1] + 1;
          
        for (i = 1; i <= H[N]; ++i)
          for (j = 1; j <= N; ++j)
            {
               Str[i][j] = Str[i-1][Str[i-1][j]];
               if (Str[i][j])
                 Max[i][j] = max(Max[i-1][j], Max[i-1][Str[i-1][j]]);
            }
        
        for (i = 1; (1 << i) <= ct; ++i)
          for (j = 1; j + (1 << i) - 1 <= ct; ++j)
            if (D[Rmq[i-1][j]] < D[Rmq[i-1][j+(1<<(i-1))]])
              Rmq[i][j] = Rmq[i-1][j];
            else
              Rmq[i][j] = Rmq[i-1][j+(1<<(i-1))];
        
        for (i = 1; i <= KO; ++i)
          {
             scanf("%d%d",&a,&b);
             if (P[a] > P[b])
               {
                  aux = a;
                  a = b;
                  b = aux;
               }
             d = H[P[b] - P[a] + 1];
             if (D[Rmq[d][P[a]]] < D[Rmq[d][P[b]-(1<<d)+1]])
               LCA = Rmq[d][P[a]];
             else
               LCA = Rmq[d][P[b]-(1<<d)+1];
             
             rasp = max(comp(a, LCA),comp(b,LCA));
             printf("%d\n",rasp);
          }
          
        return 0;
    }