#include <bits/stdc++.h>

#define pb push_back
#define F first
#define S second
#define MP make_pair
#define all(x) x.begin(),x.end()
#define Hagry ios::sync_with_stdio(false);cout.tie(NULL);cin.tie(NULL);

using namespace std;
using ll = long long;
using pi = pair<int, int>;
using vi = vector<int>;
using vpi = vector<pair<int, int>>;
using vvi = vector<vector<int>>;
using ti = tuple<int, int, int>;
const int OO = 1e9 + 5;
const int N = 2e5 + 5;

struct Record {
    int comp, weight, sz;

    Record() {}

    Record(int comp, int weight, int sz) : comp(comp), weight(weight), sz(sz) {}
};

struct DSU {
    vi par, sz;
    vvi childs;
    //comp after merge, weight, size after merge
    vector<vector<Record>> merges;

    DSU(int n) {
        par.resize(n + 1);
        sz.resize(n + 1);
        childs.resize(n + 1);
        merges.resize(n + 1);
        for (int i = 1; i <= n; ++i) {
            par[i] = i;
            sz[i] = 1;
            merges[i].pb({i, 0, 1});
            childs[i].pb(i);
        }
    }

    int find(int a) {
        if (a == par[a])return a;
        return find(par[a]);
    }

    void unite(int a, int b, int w) {
        a = find(a);
        b = find(b);
        if (a == b)return;
        if (sz[a] > sz[b])
            swap(a, b);

        par[a] = b;
        sz[b] += sz[a];
        for (int c:childs[a]) {
            childs[b].pb(c);
            merges[c].pb({b, w, sz[b]});
        }
        childs[a].clear();
    }

};

struct Edge {
    int a, b, w;

    Edge() {}

    Edge(int a, int b, int w) : a(a), b(b), w(w) {
    }

    bool operator<(const Edge &e2) {
        return w < e2.w;
    }
};

void TC() {
    int n, m, q;
    cin >> n >> m >> q;

    vector<Edge> edges;
    int a, b, w;
    for (int i = 0; i < m; ++i) {
        cin >> a >> b >> w;
        edges.pb(Edge(a, b, w));
    }
    sort(all(edges));

    DSU dsu(n);
    for (auto e:edges) {
        dsu.unite(e.a, e.b, e.w);
    }

    while (q--) {
        cin >> a >> b;
        auto v1 = dsu.merges[a];
        auto v2 = dsu.merges[b];
        map<int, int> ind;
        for (int i = 0; i < v2.size(); ++i)
            ind[v2[i].comp] = i;

        bool found = false;
        for (auto e:v1) {
            if (ind.find(e.comp) != ind.end()) {
                auto e2 = v2[ind[e.comp]];
                assert((e.weight >= e2.weight && e.sz >= e2.sz)
                       || (e.weight <= e2.weight && e.sz <= e2.sz));
                cout << max(e.weight, e2.weight) << " ";
                cout << max(e.sz, e2.sz) << "\n";
                found = true;
                break;
            }
        }
        assert(found);
    }
}

int32_t main() {
#ifndef ONLINE_JUDGE
    freopen("input.in", "r", stdin);
    freopen("output.out", "w", stdout);
#endif
    Hagry
    int t = 1;
//    cin >> t;
    while (t--) {
        TC();
//        cout << '\n';
    }
    return 0;
}