#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>>;

const int OO = 1e9 + 5;
const int N = 2e5 + 5;
const int LG = 22;

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;
    }
};

struct Query {
    int a, b, w, id;

    Query() { w = 0; }
    Query(int a, int b, int id) : a(a), b(b), id(id) { w = 0; }
    bool operator<(const Query &qu) {
        return w < qu.w;
    }
};

struct DSU {
    int n, comps;
    vector<int> sz, par;

    DSU(int n) {
        this->n = n;
        comps = n;
        sz.resize(n + 1);
        par.resize(n + 1);
        for (int i = 1; i <= n; ++i) {
            sz[i] = 1;
            par[i] = i;
        }
    }

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

    bool same(int a, int b) { return find(a) == find(b); }

    bool unite(int a, int b) {
        a = find(a), b = find(b);
        if (a == b) return false;
        if (sz[a] < sz[b]) swap(a, b);
        par[b] = a;
        sz[a] += sz[b];
        comps--;
        return true;
    }
};

vector<Edge> kruskal(int n, vector<Edge> &edges) {
    DSU dsu(n);
    sort(all(edges));
    vector<Edge> res;
    for (auto edge:edges) {
        if (dsu.same(edge.a, edge.b))continue;
        dsu.unite(edge.a, edge.b);
        res.pb(edge);
    }
    return res;
}

vector<pi> adj[N];
int anc[N][LG], mx[N][LG], d[N];

void dfs(int u, int par, int w) {
    anc[u][0] = par;
    mx[u][0] = w;
    d[u] = d[par] + 1;
    for (auto e:adj[u])if(e.F != par)
        dfs(e.F, u, e.S);
}

void pre(int n) {
    for (int k = 1; k < LG; ++k) {
        for (int u = 1; u <= n; ++u) {
            anc[u][k] = anc[anc[u][k - 1]][k - 1];
            mx[u][k] = max(mx[u][k - 1], mx[anc[u][k - 1]][k - 1]);
        }
    }
}

pi binLift(int a, int x) {
    int mxE = 0;
    for (int bt = 0; bt < LG; ++bt) {
        if (x & (1 << bt)) {
            mxE = max(mxE, mx[a][bt]);
            a = anc[a][bt];
        }
    }
    return {a, mxE};
}

int LCA(int a, int b) {
    if (d[a] < d[b])
        swap(a, b);
    int ans = 0;
    tie(a, ans) = binLift(a, d[a] - d[b]);
    if (a == b)return ans;
    for (int bt = LG-1; bt >= 0; --bt) {
        if (anc[a][bt] == anc[b][bt])continue;
        ans = max({ans, mx[a][bt], mx[b][bt]});
        a = anc[a][bt];
        b = anc[b][bt];
    }
    ans = max(ans, mx[a][0]);
    return ans;
}


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

    vector<Edge> edges(m);
    int a, b, t;
    for (int i = 0; i < m; ++i) {
        cin >> a >> b >> t;
        edges[i] = Edge(a, b, t);
    }

    vector<Edge> MST = kruskal(n, edges);
    for (auto e:MST) {
        adj[e.a].pb({e.b, e.w});
        adj[e.b].pb({e.a, e.w});
    }
    dfs(1, 0, 0);
    pre(n);

    vector<Query> qrys(q);
    for (int i = 0; i < q; ++i) {
        cin >> a >> b;
        qrys[i] = Query(a, b, i);
        qrys[i].w = LCA(a, b);
    }

    DSU dsu(n);
    sort(all(edges));
    sort(all(qrys));
    vector<pi> ans(q);
    int ptr = 0;
    for (int e = 0; e < m;) {
        int st = e;
        for (; e < m && edges[st].w == edges[e].w; ++e)
            dsu.unite(edges[e].a, edges[e].b);
        for (; ptr < q && qrys[ptr].w<=edges[st].w; ++ptr)
            ans[qrys[ptr].id] = {qrys[ptr].w, dsu.sz[dsu.find(qrys[ptr].a)]};
    }
    for(auto e:ans)
        cout << e.F << " " << e.S << "\n";
}

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();
    }
    return 0;
}