#include <iostream>
#include <fstream>
#include <vector>
#include <algorithm>
#include <stack>
#include <queue>

using namespace std;

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

const int DIM = 15005;
const int LGMAX = 18;

int n,m,k,x,y,c,rg[DIM],t[DIM],viz[DIM],H[DIM],Min[DIM],p,C[DIM],F[DIM];

struct StructRMQ
{
    int val,nod;
}rmq[LGMAX][DIM*2+5];

int lg[DIM*2+5];

stack <int> Stack;

vector < pair<int,int> > G[DIM];
vector <int> S;

struct Tree
{
    int x,y,c;
}P[DIM];

bool Compare(Tree a, Tree b)
{
    return (a.c<b.c);
}

int Find(int nod)
{
    while(nod!=t[nod])
        nod=t[nod];
    return nod;
}

void Union(int x, int y)
{
    if(rg[x]<rg[y])
        t[x]=y;
    else if(rg[y]<rg[x])
        t[y]=x;
    else
    {
        t[x]=y;
        rg[y]++;
    }
}

void GetGraph()
{
    for(int i=1;i<=m;i++)
    {
        int a=P[i].x;
        int b=P[i].y;
        if(Find(a)!=Find(b))
            {
                G[a].push_back(make_pair(b,P[i].c));
                G[b].push_back(make_pair(a,P[i].c));
                Union(Find(a),Find(b));
            }
    }
}

void Read()
{
    fin>>n>>m>>k;
    for(int i=1;i<=m;i++)
            fin>>P[i].x>>P[i].y>>P[i].c;
    for(int i=1;i<=n;i++)
        {
            rg[i]=1;
            t[i]=i;
        }
    sort(P+1,P+1+m,Compare);
}

void Euler()
{
    int root=1;
    Stack.push(root);
    viz[root]=1;
    H[root]=1;
    int nr=0;
    p=-1;
    for(int i=1;i<=n;i++)
        Min[i]=-1;
    while(!Stack.empty())
    {
        int CrtNode=Stack.top();
        S.push_back(CrtNode);
        if(Min[CrtNode]<0)
            Min[CrtNode]=nr;
        nr++;
        p++;
        bool ok=false;
        vector < pair<int,int> > ::iterator it;
        for(it=G[CrtNode].begin();it!=G[CrtNode].end();it++)
        {
            int next=((*it).first);
            if(!viz[next])
            {
                F[next]=CrtNode;
                C[next]=((*it).second);
                viz[next]=1;
                if(!H[next])
                    H[next]=H[CrtNode]+1;
                Stack.push(next);
                ok=true;
                break;
            }
        }
        if(!ok)
            Stack.pop();
    }
}

void GetPos(int NodeX, int NodeY, int &x, int &y)
{
    if(Min[NodeX]<Min[NodeY])
        {
            x=Min[NodeX];
            y=Min[NodeY];
        }
    else
        {
            x=Min[NodeY];
            y=Min[NodeX];
        }
}

void RMQ()
{
    lg[1]=0;
    for(int i=2;i<=p;i++)
        lg[i]=lg[i/2]+1;
    for(int i=0;i<=p;i++)
    {
        rmq[0][i].val=H[S[i]];
        rmq[0][i].nod=S[i];
    }
    for(int i=1;(1<<i)<=p;i++)
    {
        for(int j=0;j<=p-(1<<i)+1;j++)
        {
            int l=(1<<(i-1));
            if(rmq[i-1][j].val<rmq[i-1][j+l].val)
            {
                rmq[i][j].val=rmq[i-1][j].val;
                rmq[i][j].nod=rmq[i-1][j].nod;
            }
            else
            {
                rmq[i][j].val=rmq[i-1][j+l].val;
                rmq[i][j].nod=rmq[i-1][j+l].nod;
            }
        }
    }
}

int QueryRMQ(int x, int y)
{
    int diff=y-x+1;
    int l=lg[diff];
    int sh=diff-(1<<l);
    if(rmq[l][x].val<rmq[l][x+sh].val)
        return rmq[l][x].nod;
    return rmq[l][x+sh].nod;
}

void Query()
{
    while(k--)
    {
        int a,b;
        fin>>a>>b;
        GetPos(a,b,x,y);
        int LCA=QueryRMQ(x,y);
        int ans=0;
        fout<<ans<<'\n';
    }
}

int main()
{
    Read();
    GetGraph();
    Euler();
    RMQ();
    Query();
}