#include <iostream>
#include <vector>
#include <algorithm>

#define MAXM 30000
#define MAXN 15000
#define MAX_LOG 14

using namespace std;

struct edge{
  int b, cost;
};

struct parent{
  int parent, parentCost;
};

struct node{
  int lvl;
  bool visited;
  parent parents[MAX_LOG];
  vector <edge> children;
};

struct graphEdge{
  int a, b, cost;
};

bool comp(graphEdge a, graphEdge b) {
  return a.cost < b.cost;
}

graphEdge m[MAXM];
node tree[MAXN + 1];
int unions[MAXN + 1];
int logg[MAXN + 1];

void precalcLog() {
  int i;

  for ( i = 2; i <= MAXN; i++ ) {
    logg[i] = logg[i / 2] + 1;
  }

}

int findFather(int x) {
  if ( unions[x] == 0 )
    return x;
  return unions[x] = findFather(unions[x]);
}

void unite(int x, int y) {
  int fatherX, fatherY;

  fatherX = findFather(x);
  fatherY = findFather(y);

  if ( fatherX != fatherY )
    unions[fatherX] = fatherY;
}

void addEdge(int a, int b, int cost) {
  tree[a].children.push_back({b, cost});
  tree[b].children.push_back({a, cost});
}

void dfs(int pos, int level) {
  tree[pos].visited = true;
  tree[pos].lvl = level;

  for ( edge i : tree[pos].children ) {
    if ( !tree[i.b].visited ) {
      tree[i.b].parents[0].parent = pos;
      tree[i.b].parents[0].parentCost = i.cost;
      dfs(i.b, level + 1);
    }
  }
}

int solve(int a, int b) {
  int ans, i;

  ans = 0;

  if ( tree[a].lvl > tree[b].lvl )
    swap(a, b);

  i = logg[tree[b].lvl - tree[a].lvl];
  while ( i >= 0 && tree[b].lvl > tree[a].lvl ) {
    if ( tree[b].lvl - (1 << i) >= tree[a].lvl ) {
      ans = max(ans, tree[b].parents[i].parentCost);
      b = tree[b].parents[i].parent;
    }
    i--;
  }


  if ( a != b ) {
    for ( i = logg[tree[a].lvl]; i >= 0; i-- ) {
      if ( tree[a].parents[i].parent != tree[b].parents[i].parent ) {
        ans = max(ans, max(tree[a].parents[i].parentCost, tree[b].parents[i].parentCost));
        a = tree[a].parents[i].parent;
        b = tree[b].parents[i].parent;
      }
    }

    ans = max(ans, tree[a].parents[0].parentCost);
  }

  return ans;
}

int main() {
  FILE *fin, *fout;
  fin = fopen("radiatie.in", "r");
  fout = fopen("radiatie.out", "w");

  int n, m2, i, k, fatherA, fatherB, a, b, lvl;

  fscanf(fin, "%d%d%d", &n, &m2, &k);
  precalcLog();

  for ( i = 0; i < m2; i++ ) {
    fscanf(fin, "%d%d%d", &m[i].a, &m[i].b, &m[i].cost);
  }

  sort(m, m + m2, comp);

  for ( i = 0; i < m2; i++ ) {
    fatherA = findFather(m[i].a);
    fatherB = findFather(m[i].b);

    if ( fatherA != fatherB ) {
      addEdge(m[i].a, m[i].b, m[i].cost);
      unite(m[i].a, m[i].b);
    }
  }

  for ( i = 1; i <= n; i++ ) {
    if ( !tree[i].visited ) {
      dfs(i, 1);
      tree[i].parents[0].parent = i;
      tree[i].parents[0].parentCost = 0;
    }
  }

  for ( lvl = 1; (1 << lvl) < n; lvl++ ) {
    for ( i = 1; i <= n; i++ ) {
      tree[i].parents[lvl].parent = tree[tree[i].parents[lvl - 1].parent].parents[lvl - 1].parent;
      tree[i].parents[lvl].parentCost = max(tree[i].parents[lvl - 1].parentCost, tree[tree[i].parents[lvl - 1].parent].parents[lvl - 1].parentCost);
    }
  }

  while ( k-- ) {
    fscanf(fin, "%d%d", &a, &b);

    fprintf(fout, "%d\n", solve(a, b));
  }

  fclose(fin);
  fclose(fout);

  return 0;
}