There are n cities in Berland. Some pairs of them are connected with m directed roads. One can use only these roads to move from one city to another. There are no roads that connect a city to itself. For each pair of cities (x, y) there is at most one road from x to y.

A path from city s to city t is a sequence of cities p₁, p₂, ... , p_k, where p₁ = s, p_k = t, and there is a road from city p_i to city p_i + 1 for each i from 1 to k - 1. The path can pass multiple times through each city except t. It can't pass through t more than once.

A path p from s to t is ideal if it is the lexicographically minimal such path. In other words, p is ideal path from s to t if for any other path q from s to t p_i < q_i, where i is the minimum integer such that p_i ≠ q_i.

There is a tourist agency in the country that offers q unusual excursions: the j-th excursion starts at city s_j and ends in city t_j.

For each pair s_j, t_j help the agency to study the ideal path from s_j to t_j. Note that it is possible that there is no ideal path from s_j to t_j. This is possible due to two reasons:

• there is no path from s_j to t_j;
• there are paths from s_j to t_j, but for every such path p there is another path q from s_j to t_j, such that p_i > q_i, where i is the minimum integer for which p_i ≠ q_i.

The agency would like to know for the ideal path from s_j to t_j the k_j-th city in that path (on the way from s_j to t_j).

For each triple s_j, t_j, k_j (1 ≤ j ≤ q) find if there is an ideal path from s_j to t_j and print the k_j-th city in that path, if there is any.

The first line contains three integers n, m and q (2 ≤ n ≤ 3000,0 ≤ m ≤ 3000, 1 ≤ q ≤ 4·10⁵) — the number of cities, the number of roads and the number of excursions.

Each of the next m lines contains two integers x_i and y_i (1 ≤ x_i, y_i ≤ n, x_i ≠ y_i), denoting that the i-th road goes from city x_i to city y_i. All roads are one-directional. There can't be more than one road in each direction between two cities.

Each of the next q lines contains three integers s_j, t_j and k_j (1 ≤ s_j, t_j ≤ n, s_j ≠ t_j, 1 ≤ k_j ≤ 3000).

In the j-th line print the city that is the k_j-th in the ideal path from s_j to t_j. If there is no ideal path from s_j to t_j, or the integer k_j is greater than the length of this path, print the string '-1' (without quotes) in the j-th line.

7 7 5
1 2
2 3
1 3
3 4
4 5
5 3
4 6
1 4 2
2 6 1
1 7 3
1 3 2
1 3 5

#include <iostream>

#include <algorithm>

#include <cstring>

#include <cstdio>

#include <vector>

#include <queue>

#include <stack>

#include <cstdlib>

#include <iomanip>

#include <cmath>

#include <cassert>

#include <ctime>

#include <cstdlib>

#include <map>

#include <set>

using namespace std;

#pragma comment(linker, "/stck:1024000000,1024000000")

#define lowbit(x) (x&(-x))

#define max(x,y) (x>=y?x:y)

#define min(x,y) (x<=y?x:y)

#define MAX 100000000000000000

#define MOD 1000000007

#define pi acos(-1.0)

#define ei exp(1)

#define PI 3.1415926535897932384626433832

#define ios() ios::sync_with_stdio(true)

#define INF 1044266558

#define mem(a) (memset(a,0,sizeof(a)))

typedef long long ll;

struct point{int s,t,k,id;}q[];

vector<point>fq[];

vector<int>v[];

int dnf[],low[],vis[],pos[],x,y;

int val[],coun,num,n,m,r,k;

bool cmp(point a,point b)

{

    return a.s<b.s;

}

void tarjan(int u,int fa)

{

    dnf[u]=++coun;

    low[u]=INF;

    vis[u]=;

    pos[num++]=u;

    if(fa)

    {

        for(int i=;i<fq[u].size();i++)

            if(fq[u][i].k<=num) val[fq[u][i].id]=pos[fq[u][i].k-];

    }

    for(int i=;i<v[u].size();i++)

    {

        if(!dnf[v[u][i]])

        {

            tarjan(v[u][i],fa && dnf[u]<low[u]);//防止自环

            low[u]=min(low[v[u][i]],low[u]);

        }

        else if(vis[v[u][i]]) low[u]=min(low[u],dnf[v[u][i]]);

    }

    vis[u]=;

    --num;

}

int main()

{

    scanf("%d%d%d",&n,&m,&r);

    memset(val,-,sizeof(val));

    for(int i=;i<m;i++)

    {

        scanf("%d%d",&x,&y);

        v[x].push_back(y);

    }

    for(int i=;i<=n;i++)

    {

        sort(v[i].begin(),v[i].end());

    }

    for(int i=;i<r;i++)

    {

        scanf("%d%d%d",&x,&y,&k);

        q[i]=(point){x,y,k,i};

    }

    sort(q,q+r,cmp);

    for(int i=;i<r;i++)

    {

        fq[q[i].t].push_back(q[i]);

        if(q[i].s!=q[i+].s)

        {

            coun=num=;

            memset(dnf,,sizeof(dnf));

            memset(low,,sizeof(low));

            memset(vis,,sizeof(vis));

            tarjan(q[i].s,);

            for(int j=;j<=n;j++) fq[j].clear();

        }

    }

    for(int i=;i<r;i++)

        printf("%d\n",val[i]);

    return ;

}