#include <algorithm>
#include <stack>
#include <queue>
#include <deque>
#include <vector>
#include <string>
#include <set>
#include <map>
#include <cstring>

using namespace std;

//#include <iostream>
#include <fstream>

//ifstream cin ("input.in"); ofstream cout ("output.out");
ifstream cin ("radiatie.in"); ofstream cout ("radiatie.out");

static const int NMAX = 15e3+5;
static const int MMAX = 3e4+5;

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

class cmp {
public:
	const bool operator () ( const edgeType &a, const edgeType&b ) {
		return a.cost < b.cost;
	}
};

int n, m, k;

int Log2[NMAX];
int level[NMAX];
int father[NMAX];
int cardinal[NMAX];

edgeType edge[MMAX];

pair <int, int> dp[16][NMAX];

vector <pair<int, int>> graph[NMAX];

void read () {
	cin>>n>>m>>k;
	for ( int i = 1; i <= m; ++i ) {
		int x, y, c;
		cin>>x>>y>>c;
		edge[i] = {x, y, c};
	}
}

int parent (int vertex) {
	if ( father[vertex] == vertex ) {
		return vertex;
	}

	father[vertex] = parent(father[vertex]);
	return father[vertex];
}

void dsu (int a, int b) {
	int x = parent(a);
	int y = parent(b);

	if ( cardinal[y] > cardinal[x] ) {
		swap(x, y);
	}

	cardinal[x] += cardinal[y];
	father[y] = x;
}

void genApm() {
	sort(edge+1, edge+m+1, cmp());

	for ( int i = 1; i <= m; ++i ) {
		int a = edge[i].a;
		int b = edge[i].b;
		int cost = edge[i].cost;
		if ( parent(a) != parent(b) ) {
			dsu(edge[i].a, edge[i].b);

			graph[a].push_back({b, cost});
			graph[b].push_back({a, cost});
		}
	}
}

void dfs (int vertex, int depth) {
	level[vertex] = depth;

	for ( auto x:graph[vertex] ) {
		if ( !level[x.first] ) {
			dp[0][x.first] = {vertex, x.second};
			dfs(x.first, depth+1);
		}
	}
}

void getToLevel(int &vertex, int dist, int &ans) {
	while (dist) {
		ans = max(ans, dp[Log2[dist]][vertex].second);
		vertex = dp[Log2[dist]][vertex].first; 
		dist -= (1<<Log2[dist]);
	}
}

void getToLCA (int &x, int &y, int &ans) {
	for (int i = Log2[n]; i >= 0 && dp[i][x].first != dp[i][y].first; --i ) {
		ans = max (ans, max(dp[i][x].second,
							dp[i][y].second));
		x = dp[i][x].first;
		y = dp[i][y].first;
	}
}

int answer (int x, int y) {
	int ans = 0;

	if ( level[x] > level[y] ) {
		swap(x, y);
	}

	getToLevel(y, level[y]-level[x], ans);
	getToLCA(x, y, ans);

	if ( x != y ) {
		ans = max(ans, max(dp[0][x].second,
						   dp[0][y].second));
	}

	return ans;
}

int main() {
	ios::sync_with_stdio(false);
	cin.tie(0); cout.tie(0);

	for ( int i = 1; i <= NMAX-5; ++i ) {
		father[i] = i;
		cardinal[i] = 1;
	}

	for ( int i = 2; i <= Log2[NMAX-5]; ++i ) {
		Log2[i] = Log2[i/2]+1;
	}

	read();
	genApm();
	dfs(1, 1);

	for ( int i = 1; i <= Log2[n]; ++i ) {
		for ( int j = 1; j <= n; ++j ) {
			dp[i][j].first = dp[i-1][dp[i-1][j].first].first;
			dp[i][j].second = max(dp[i-1][j].second, dp[i-1][dp[i-1][j].first].second);
		}
	}

	for ( int i = 1; i <= k; ++i ) {
		int x, y;
		cin>>x>>y;
		cout<<answer(x, y)<<'\n';
	}
}