#include <iostream>
#include <vector>
#include <queue>
#include <algorithm>
#include <fstream>
#include <unordered_map>

using namespace std;

struct Edge {
    int u, v, length;
};

bool bfs(const unordered_map<int, vector<pair<int, int>>>& graph, int N, int start, int end, int maxLength) {
    vector<bool> visited(N + 1, false);
    queue<int> q;
    q.push(start);
    visited[start] = true;

    while (!q.empty()) {
        int node = q.front();
        q.pop();

        if (node == end) {
            return true;
        }

        for (const auto& neighbor : graph.at(node)) {
            int nextNode = neighbor.first;
            int edgeLength = neighbor.second;
            if (!visited[nextNode] && edgeLength <= maxLength) {
                visited[nextNode] = true;
                q.push(nextNode);
            }
        }
    }

    return false;
}

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

    int N, M, K;
    fin >> N >> M >> K;

    vector<Edge> edges(M);
    unordered_map<int, vector<pair<int, int>>> graph;

    for (int i = 0; i < M; ++i) {
        fin >> edges[i].u >> edges[i].v >> edges[i].length;
        graph[edges[i].u].emplace_back(edges[i].v, edges[i].length);
        graph[edges[i].v].emplace_back(edges[i].u, edges[i].length);
    }

    vector<pair<int, int>> queries(K);
    for (int i = 0; i < K; ++i) {
        fin >> queries[i].first >> queries[i].second;
    }
    
    vector<int> uniqueLengths;
    for (const auto& edge : edges) {
        uniqueLengths.push_back(edge.length);
    }
    sort(uniqueLengths.begin(), uniqueLengths.end());
    uniqueLengths.erase(unique(uniqueLengths.begin(), uniqueLengths.end()), uniqueLengths.end());

    vector<int> results(K);
    for (int i = 0; i < K; ++i) {
        int x = queries[i].first;
        int y = queries[i].second;
        int low = 0;
        int high = uniqueLengths.size() - 1;
        int bestLength = uniqueLengths[high];

        while (low <= high) {
            int mid = low + (high - low) / 2;
            if (bfs(graph, N, x, y, uniqueLengths[mid])) {
                bestLength = uniqueLengths[mid];
                high = mid - 1;
            } else {
                low = mid + 1;
            }
        }

        results[i] = bestLength;
    }

    for (const auto& result : results) {
        fout << result << "\n";
    }

    fin.close();
    fout.close();

    return 0;
}