#include <fstream>
#include <algorithm>
#include <ctime>
#include <cstdlib>

#define pe pair<int, int>
#define mp make_pair
#define fi first
#define se second

using namespace std;

struct tr {
    int a, b, c;
    tr(int _a = 0, int _b = 0, int _c = 0) {
        a = _a;
        b = _b;
        c = _c;
    }

    inline bool operator < (const tr &x) const {
        return c < x.c;
    }
};

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

const int MAX_N = 15100;

int dad[MAX_N];
int h[MAX_N];
int d[16][MAX_N];
int t[16][MAX_N];

vector<tr> mu;
vector<pe> A[MAX_N];

int find(int nod) {
    if(dad[nod] == nod) {
        return nod;
    }
    return dad[nod] = find(dad[nod]);
}

void merge(int a, int b) {
    a = find(a);
    b = find(b);
    if(rand() & 1) {
        dad[a] = b;
    }
    else {
        dad[b] = a;
    }
}

void dfs(int nod, int dad, int cost) {
    t[0][nod] = dad;
    d[0][nod] = cost;
    h[nod] = h[dad] + 1;
    for(auto it : A[nod]) {
        if(it.fi != dad) {
            dfs(it.fi, nod, it.se);
        }
    }
}

void pregen(int n) {
    for(int j = 1; j <= 15; j++) {
        for(int i = 1; i <= n; i++) {
            t[j][i] = t[j - 1][t[j - 1][i]];
            d[j][i] = max(d[j - 1][i], d[j - 1][t[j - 1][i]]);
        }
    }
}

int query(int a, int b) {
    int ans = 0;
    if(h[a] < h[b]) {
        swap(a, b);
    }
    for(int j = 15; j >= 0; j--) {
        if(h[t[j][a]] >= h[b]) {
            ans = max(ans, d[j][a]);
            a = t[j][a];
        }
    }

    for(int j = 15; j >= 0; j--) {
        if(t[j][a] != t[j][b]) {
            ans = max(ans, d[j][a]);
            ans = max(ans, d[j][b]);
            a = t[j][a];
            b = t[j][b];
        }
    }

    if(a != b) {
        ans = max(ans, d[0][a]);
        ans = max(ans, d[0][b]);
    }
    return ans;
}

int main() {
    srand(time(NULL));
    int n, m, q;
    fin >> n >> m >> q;
    for(int i = 1; i <= n; i++) {
        dad[i] = i;
    }
    for(int i = 1; i <= m; i++) {
        int a, b, c;
        fin >> a >> b >> c;
        mu.push_back(tr(a, b, c));
    }
    sort(mu.begin(), mu.end());
    for(auto it : mu) {
        if(find(it.a) != find(it.b)) {
            merge(it.a, it.b);
            A[it.a].push_back(mp(it.b, it.c));
            A[it.b].push_back(mp(it.a, it.c));
        }
    }
    
    h[0] = MAX_N;
    dfs(1, 0, 0);
    pregen(n);
    for(int i = 1; i <= q; i++) { 
        int a, b;
        fin >> a >> b;
        fout << query(a, b) << '\n';
    }
    return 0;
}