#include <bits/stdc++.h>
//#define in cin
//#define out cout

using namespace std;

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

const int nmax = 15007;
const int mmax = 2*nmax;
const int lgmax = 30;

struct DSU
{
    struct node
    {
        int p,s;
        node()
        {
            p=0;
            s=1;
        }
    }nodes[nmax];
    int getP(int ind)
    {
        if(nodes[ind].p==0)return ind;
        return nodes[ind].p=getP(nodes[ind].p);
    }
    bool sameTree(int a,int b)
    {
        return getP(a)==getP(b);
    }
    void unite(int a,int b)
    {
        int pa=getP(a);
        int pb=getP(b);
        if(pa==pb)return;
        if(nodes[pa].s>nodes[pb].s)swap(pa,pb);
        nodes[pa].p=pb;
        nodes[pb].s+=nodes[pa].s;
    }
}dsu;

struct edge
{
    int a,b,c;
    edge(int a=0,int b=0,int c=0):a(a),b(b),c(c){}
    bool operator<(const edge &other)
    {
        return c<other.c;
    }
    void debug()
    {
        cerr<<a<<' '<<b<<' '<<c<<'\n';
    }
}edges[mmax],queries[nmax];

int n,m,k;
vector<pair<int,int>> adj[nmax];
int parent[nmax][lgmax],maxx[nmax][lgmax];
int d[nmax];

void dfs(int ind=1,int p=0,int depth=1,int maximum=0)
{
    parent[ind][0]=p;
    maxx[ind][0]=maximum;
    d[ind]=depth;
    for(int i=1;i<lgmax;i++)
    {
        parent[ind][i]=parent[parent[ind][i-1]][i-1];
        maxx[ind][i]=max(maxx[ind][i-1],maxx[parent[ind][i-1]][i-1]);
    }

    for(auto j:adj[ind])
    {
        if(j.first!=p)
        {
            dfs(j.first,ind,depth+1,j.second);
        }
    }
}

int lca(int a,int b)
{
    int maximus = 0;

    if(d[a]>d[b])
    {
        int diff=d[a]-d[b];
        for(int i=0,bit=1;i<lgmax;i++,bit<<=1)
        {
            if(bit&diff)
            {
                maximus=max(maximus,maxx[a][i]);
                a=parent[a][i];
            }
        }
    }
    else if(d[b]>d[a])
    {
        int diff=d[b]-d[a];
        for(int i=0,bit=1;i<lgmax;i++,bit<<=1)
        {
            if(bit&diff)
            {
                maximus=max(maximus,maxx[b][i]);
                b=parent[b][i];
            }
        }
    }

    for(int i=lgmax-1;i>=0;i--)
    {
        if(parent[a][i]!=parent[b][i])
        {
            maximus=max(maximus,maxx[a][i]);
            maximus=max(maximus,maxx[b][i]);
            a=parent[a][i];
            b=parent[b][i];
        }
    }

    if(a!=b)
    {
        maximus=max(maximus,maxx[a][0]);
        maximus=max(maximus,maxx[b][0]);
    }

    return maximus;
}

int main()
{
    in>>n>>m>>k;
    for(int i=0;i<m;i++)
    {
        in>>edges[i].a>>edges[i].b>>edges[i].c;
    }
    sort(edges,edges+m);
    for(int i=0;i<m;i++)
    {
        if(!dsu.sameTree(edges[i].a,edges[i].b))
        {
            dsu.unite(edges[i].a,edges[i].b);
            adj[edges[i].a].push_back({edges[i].b,edges[i].c});
            adj[edges[i].b].push_back({edges[i].a,edges[i].c});
        }
    }
    dfs();
    for(int i=0;i<k;i++)
    {
        int a,b;
        in>>a>>b;
        out<<lca(a,b)<<'\n';
    }
}