#include <fstream>
#import <algorithm>
#import <vector>
#import <map>
#import <set>
#import <deque>
#import <queue>
#import <cassert>
//#import <cmath>
#import <cstring>
#import <cctype>
#import <cstdlib>
#import <stack>
#import<unordered_map>
#define lene using std::cin;using std::cout
class RMQ
{
    ///lucruri necesare
    std::vector<std::vector<int>>rmq;
    std::vector<int>lg;
    int n;
    //////////////////////

    void build(std::vector<int>&a)
    {
        for(int i=2;i<=n;i++)
        {
            lg[i]=lg[i/2]+1;
        }
        rmq=std::vector<std::vector<int>>(lg[n]+2,std::vector<int>(n+1,0));
        rmq[0]=a;
        for(int i=1;(1<<i)<=n;i++)
        {
            for(int j=1;j+(1<<i)-1<=n;j++)
            {
                rmq[i][j]=std::max(rmq[i-1][j],rmq[i-1][j+(1<<(i-1))]);
            }
        }
    }
public:
    RMQ(){}
    RMQ(std::vector<int>&a)
    {
        n=(int)a.size()-1;
        lg=std::vector<int>(n+1,0);
        build(a);
    }
    int query(int l,int r)
    {
        int lung=lg[r-l+1];
        return std::max(rmq[lung][l],rmq[lung][r-(1<<lung)+1]);
    }
};


class decomp
{
    std::vector<int>s,t,head,h,poz;
    std::vector<int>e={0};
    std::vector<std::vector<std::pair<int,int>>>g;
    int n;
    RMQ rmq;



    void dfs1(int nod,int tata)
    {
        t[nod]=tata;
        h[nod]=h[tata]+1;
        for(auto &c:g[nod])
        {
            if(c.first==tata)continue;
            dfs1(c.first,nod);
            s[nod]+=s[c.first];
        }
        std::sort(g[nod].begin(),g[nod].end(),[&](std::pair<int,int> a,std::pair<int,int> b){return (s[a.first]>s[b.first]);});
    }
    void dfs2(int nod,int tata,int val,int cap)
    {
        head[nod]=cap;
        poz[nod]=(int)e.size();
        e.push_back(val);
        bool first=1;
        for(auto &c:g[nod])
        {
            if(c.first==tata)continue;
            if(first)
            {
                first=0;
                dfs2(c.first,nod,c.second,cap);
            }
            else
            {
                dfs2(c.first,nod,c.second,c.first);
            }
        }

    }
public:
    decomp(){}
    decomp(std::vector<std::vector<std::pair<int,int>>>_g): g(_g)
    {
        n=(int)_g.size()-1;
        s=std::vector<int>(n+1,1);
        t.resize(n+1);
        head.resize(n+1);
        h.resize(n+1);
        poz.resize(n+1);
        h[0]=0;
        dfs1(1,0);
        dfs2(1,0,0,1);
        rmq=RMQ(e);
        ///h,head,poz,t,s verificate
    }
    int query(int a,int b)
    {
        int rez=-1;
        while(head[a]!=head[b])
        {
            if(h[head[a]]>h[head[b]])std::swap(a,b);
            rez=std::max(rez,rmq.query(poz[head[b]],poz[b]));
            b=t[head[b]];
        }
        if(a!=b)
        {
            rez=std::max(rez,rmq.query(std::min(poz[a],poz[b])+1,std::max(poz[a],poz[b])));
        }
        return rez;
    }
};

class DSU
{
    std::vector<int>t;
    int root(int x)
    {
        if(x==t[x])return x;
        t[x]=root(t[x]);
        return t[x];
    }
public:
    DSU(int n)
    {
        t.resize(n+1);
        for(int i=1;i<=n;i++)
        {
            t[i]=i;
        }
    }

    int unite(int a,int b)
    {
        int x=root(a);
        int y=root(b);
        if(x==y)
        {
            return 0;
        }
        t[y]=x;
        return 1;
    }
};

struct trei
{
    int x,y,val;
    trei(){}
    trei(int _x,int _y,int _val):x(_x),y(_y), val(_val){}
    bool operator <(trei b)
    {
        return (this->val<b.val);
    }
};
class InParser {
private:
	FILE *fin;
	char *buff;
	int sp;

	char read_ch() {
		++sp;
		if (sp == 4096) {
			sp = 0;
			fread(buff, 1, 4096, fin);
		}
		return buff[sp];
	}

public:
	InParser(const char* nume) {
		fin = fopen(nume, "r");
		buff = new char[4096]();
		sp = 4095;
	}

	InParser& operator >> (int &n) {
		char c;
		while (!isdigit(c = read_ch()) && c != '-');
		int sgn = 1;
		if (c == '-') {
			n = 0;
			sgn = -1;
		} else {
			n = c - '0';
		}
		while (isdigit(c = read_ch())) {
			n = 10 * n + c - '0';
		}
		n *= sgn;
		return *this;
	}

	InParser& operator >> (long long &n) {
		char c;
		n = 0;
		while (!isdigit(c = read_ch()) && c != '-');
		long long sgn = 1;
		if (c == '-') {
			n = 0;
			sgn = -1;
		} else {
			n = c - '0';
		}
		while (isdigit(c = read_ch())) {
			n = 10 * n + c - '0';
		}
		n *= sgn;
		return *this;
	}
};
main()
{
    InParser cin("radiatie.in");
    std::ofstream cout("radiatie.out");
    int n,k,q;
    cin>>n>>k>>q;
    std::vector<trei>t(k);
    std::vector<std::vector<std::pair<int,int>>>a(n+1);
    DSU dsu(n);
    for(auto &c:t)
    {
        cin>>c.x>>c.y>>c.val;
    }
    std::sort(t.begin(),t.end());
    for(auto &c:t)
    {
        if(dsu.unite(c.x,c.y))
        {
            a[c.x].push_back(std::make_pair(c.y,c.val));
            a[c.y].push_back(std::make_pair(c.x,c.val));
        }
    }
    decomp tree(a);
    while(q--)
    {
        int x,y;
        cin>>x>>y;
        cout<<tree.query(x,y)<<'\n';
    }
}