#include <bits/stdc++.h>

using namespace std;

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

#define cin fin
#define cout fout
#define ll long long

int nr=0;
vector<vector<pair<int, ll>>> g(15001);
int n, m, k;
vector<tuple<ll, int, int>> edge;
int parent[15001];
int rnk[15001];

int find(int i) {
    if (parent[i]==-1) {
        return i;
    }
    return parent[i]=find(parent[i]);
}

void unite(int x, int y) {
    int s1=find(x), s2=find(y);
    if (s1!=s2) {
        if (rnk[s1]<rnk[s2]) {
            parent[s1]=s2;
            rnk[s2]+=rnk[s1];
        } else {
            parent[s2]=s1;
            rnk[s1]+=rnk[s2];
        }
    }
}

void kruskal() {
    sort(edge.begin(), edge.end());
    for(auto [cost, x, y] : edge) {
        if (find(x)!=find(y)) {
            unite(x, y);
            nr++;
            g[x].push_back({y, cost});
            g[y].push_back({x, cost});
        }
    }
}

const int LOG=15;
int tata[15001][LOG];
ll maxi[15001][LOG];
int depth[15001];

void dfs(int node, int node_tata, int w) {
    tata[node][0]=node_tata;
    maxi[node][0]=w;
    for(int i = 1; i < LOG; i++) {
        tata[node][i] = tata[tata[node][i-1]][i-1];
        maxi[node][i] = max(maxi[node][i-1], maxi[tata[node][i-1]][i-1]);
    }
    for(auto [i, cost] : g[node]) {
        if (i==node_tata) continue;
        depth[i]=depth[node]+1;
        dfs(i, node, cost);
    }
}

ll query(int x, int y) {
    if (depth[x]<depth[y]) swap(x, y);
    ll ans=0;
    int diff = depth[x]-depth[y];
    for(int i = 0; i < LOG; i++) {
        if (diff&(1<<i)) {
            ans = max(ans, maxi[x][i]);
            x = tata[x][i];
        }
    }
    if (x==y)return ans;
    for(int i = LOG-1; i >= 0; i--) {
        if (tata[x][i]!=tata[y][i]) {
            ans = max(ans, max(maxi[x][i], maxi[y][i]));
            x = tata[x][i];
            y = tata[y][i];
        }
    }
    ans = max(ans, max(maxi[x][0], maxi[y][0]));
    return ans;
}

int main()
{
    cin >> n >> m >> k;
    for(int  i = 0; i <= n; i++) {
        parent[i]=-1;
        rnk[i]=1;
    }
    for(int i = 1; i <= m; i++) {
        int x, y;
        ll c;
        cin >> x >> y >> c;
        edge.push_back({c, x, y});
    }
    kruskal();
    dfs(1, 0, 0);
    while(k--) {
        int x, y;
        cin >> x >> y;
        cout << query(x, y) << "\n";
    }
    return 0;
}