#include <iostream>
#include <deque>
#include <vector>
#include <algorithm>
#include <map>
#include <set>
#include <queue>
int main()
{
    int64_t n, m, q;

    std::cin >> n >> m >> q;
    std::vector < std::vector<std::pair<int, int64_t> > > edges(n);

    for (int i = 0; i < m; i++)
    {
        int64_t u, v, t;
        std::cin >> u >> v >> t;
        edges[u - 1].push_back({ v - 1, t });
        edges[v - 1].push_back({ u - 1, t });
    }

    std::vector<std::vector<std::pair<int, int64_t> > > children(n);

    struct Visit
    {
        int next;
        int64_t cost;
        int prev;
        bool operator<(const Visit& other) const
        {
            return cost > other.cost;
        }
    };

    std::vector<bool> visited(n);
    std::priority_queue<Visit> pq;
    for (int i = 0; i < n; i++)
    {
        if (visited[i])
            continue;
            
            
        pq.push({ i,0,-1 });
        while (!pq.empty())
        {
            Visit next = pq.top();
            pq.pop();
            if (visited[next.next])
                continue;
            visited[next.next] = true;

            if (next.prev != -1)
                children[next.prev].push_back({next.next, next.cost});

            for (auto nb : edges[next.next])
            {
                if (!visited[nb.first])
                    pq.push({ nb.first, nb.second, next.next });
            }
        }
    }

    int L = 0;
    int i = n;
    while (i > 0)
    {
        i /= 2;
        L++;
    }   

    struct Prev
    {
        int idx;
        int64_t maxtoll;
    };
    std::vector<std::vector<Prev> > up(n);
    for (int i = 0; i < n; i++)
    {
        up[i].resize(L);
        for(int j=0; j<L; j++)
            up[i][j].idx = -1;
    }

    std::vector<std::pair<int, int> > childidxrange(n);
    int idx = 0;
    
    for(int i=0; i<n; i++)
        visited[i] = false;
        
    std::deque<int> dfs;
    dfs.push_front(0);
    while(!dfs.empty())
    {
        int next = dfs.front();
        dfs.pop_front();
        if(visited[next])
        {
            childidxrange[next].second = idx-1;
        }
        else
        {
            visited[next] = true;
            childidxrange[next].first = idx++;
            dfs.push_front(next);
            for(auto it : children[next])
                dfs.push_front(it.first);
        }
    }
    for(int i=0; i<n; i++)
    {
        for(auto it : children[i])
        {
            up[it.first][0].idx = i;
            up[it.first][0].maxtoll = it.second;
        }
    }
    for(int i=1; i<L; i++)
    {
        for(int j=0; j<n; j++)
        {
            if(up[j][i-1].idx != -1 && up[up[j][i-1].idx][i-1].idx != -1)
            {
                up[j][i].idx = up[up[j][i-1].idx][i-1].idx;
                up[j][i].maxtoll = std::max(up[j][i-1].maxtoll, up[up[j][i-1].idx][i-1].maxtoll);
            }
        }
    }
    
    /*for(int i=0; i<n; i++)
    {
        std::cout << "Vertex " << i << std::endl;
        for(int j=0; j<L; j++)
        {
            std::cout << up[i][j].idx << " " << up[i][j].maxtoll << std::endl;
        }
    }*/
    
    std::vector<std::pair<int, int> > queries(q);
    for(int i=0; i<q; i++)
    {
        int a, b;
        std::cin >> a >> b;
        queries[i].first = a-1;
        queries[i].second = b-1;
    }
 
    std::vector<int64_t> firstanswers(q);   
    std::vector<int64_t> secondanswers(q);      
    
    struct Edge
    {
        int v1;
        int v2;
        int64_t cost;
        bool operator<(const Edge &other) const
        {
            return cost < other.cost;
        }
    };
    
    std::map<int64_t, std::vector<int> > queriestohandle;
    std::vector<Edge> sortededges;
    for(int i=0; i<n; i++)
    {
        for(auto it : edges[i])
        {
            if(i < it.first)
            {
                sortededges.push_back({i, it.first, it.second});
                queriestohandle[it.second].resize(0); // touch to insert entry
            }
        }
    }    
    std::sort(sortededges.begin(), sortededges.end());
    
    
    for(int i=0; i<q; i++)
    {
        int64_t val = 0;
        int jmp = L-1;
        int a = queries[i].first;
        int b = queries[i].second;
        int bidx = childidxrange[b].first;
        
        //std::cout << childidxrange[a].first << " " << childidxrange[a].second << " " << childidxrange[b].first << " " << childidxrange[b].second << std::endl;
        
        if(childidxrange[a].first > bidx || childidxrange[a].second < bidx)
        {
            while(jmp >= 0)
            {
                if(up[a][jmp].idx == -1)
                {
                    jmp--;
                    continue;
                }
                if(childidxrange[up[a][jmp].idx].first <= bidx && bidx <= childidxrange[up[a][jmp].idx].second)
                {
                    jmp--;
                    continue;
                }
                val = std::max(val, up[a][jmp].maxtoll);
                a = up[a][jmp].idx;
                jmp--;
            }
            val = std::max(val, up[a][0].maxtoll);
            a = up[a][0].idx;
        }
        
        int64_t val2 = 0;
        if(b != a)
        {
            int aidx = childidxrange[a].first;
            jmp = L-1;
            while(jmp >= 0)
            {
                if(up[b][jmp].idx == -1)
                {
                    jmp--;
                    continue;
                }
                if(childidxrange[up[b][jmp].idx].first <= aidx && aidx <= childidxrange[up[b][jmp].idx].second)
                {
                    jmp--;
                    continue;
                }
                val2 = std::max(val2, up[b][jmp].maxtoll);
                b = up[b][jmp].idx;
                jmp--;
            }
            val2 = std::max(val2, up[b][0].maxtoll);
            b = up[b][0].idx;
        }
        
        firstanswers[i] = std::max(val, val2);
        auto it = queriestohandle.find(firstanswers[i]);
        ++it;
        if(it != queriestohandle.end())
            it->second.push_back(i);
        else
            secondanswers[i] = n;
    }
    
    struct UnionFind
    {
        std::vector<int> parent;
        std::vector<int> compsize;
        UnionFind(int n)
        {
            parent.resize(n);
            compsize.resize(n);
            for(int i=0; i<n; i++)
            {
                parent[i] = i;
                compsize[i] = 1;
            }
        }
        
        int find(int idx)
        {
            if(parent[parent[idx]] != parent[idx])
            {
                parent[idx] = find(parent[idx]);
            }
            return parent[idx];
        }
        
        int size(int idx)
        {
            return compsize[find(idx)];
        }
        
        void doUnion(int idx1, int idx2)
        {
            int f1 = find(idx1);
            int f2 = find(idx2);
            if(f1 == f2)
                return;
            int newsize = compsize[f1] + compsize[f2];
            parent[f1] = f2;
            compsize[f2] = newsize;            
        }
        
    };
    
    UnionFind uf(n);
    std::set<int64_t> done;
    for(auto it : sortededges)
    {
        if(!done.count(it.cost))
        {
            done.insert(it.cost);
            for(auto q : queriestohandle[it.cost])
            {
                secondanswers[q] = uf.size(queries[q].first);
            }
        }
        uf.doUnion(it.v1, it.v2);
    }
    
    for(int i=0; i<q; i++)
        std::cout << firstanswers[i] << " " << secondanswers[i] << std::endl;
}