Problem:
Score : 500 points

Problem Statement

There is a rooted tree (see Notes) with N vertices numbered 1 to N.
Each of the vertices, except the root, has a directed edge coming from its parent.
Note that the root may not be Vertex 1.

Takahashi has added M new directed edges to this graph.
Each of these M edges, u \rightarrow v, extends from some vertex u to its descendant v.

You are given the directed graph with N vertices and N-1+M edges after Takahashi added edges.
More specifically, you are given N-1+M pairs of integers, (A_1, B_1), ..., (A_{N-1+M}, B_{N-1+M}), which represent that the i-th edge extends from Vertex A_i to Vertex B_i.

Restore the original rooted tree.

Notes

For "tree" and other related terms in graph theory, see the article in Wikipedia, for example.

Constraints

3 \leq N

1 \leq M

N + M \leq 10^5

1 \leq A_i, B_i \leq N

A_i \neq B_i

If i \neq j, (A_i, B_i) \neq (A_j, B_j).

The graph in input can be obtained by adding M edges satisfying the condition in the problem statement to a rooted tree with N vertices.

Input

Input is given from Standard Input in the following format:

N M
A_1 B_1
:
A_{N-1+M} B_{N-1+M}

Output

Print N lines.
In the i-th line, print 0 if Vertex i is the root of the original tree, and otherwise print the integer representing the parent of Vertex i in the original tree.

Note that it can be shown that the original tree is uniquely determined.

Sample Input 1

3 1
1 2
1 3
2 3

Sample Output 1

0
1
2

The graph in this input is shown below:

It can be seen that this graph is obtained by adding the edge 1 \rightarrow 3 to the rooted tree 1 \rightarrow 2 \rightarrow 3.

Sample Input 2

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

Sample Output 2

6
4
2
0
6
2

Solution in C++14 (GCC 5.4.1) (judge verdict: Wrong Answer)

#include <bits/stdc++.h>
using namespace std;
#define  rep(i, n) for(int i = 0; i < n; i++) 
#define  all(x) (x).begin(),(x).end()     // 昇順ソート
#define  rall(v) (v).rbegin(), (v).rend() // 降順ソート
#define  INF 1LL << 60
typedef long long int LL;
typedef long long int ll;
#define pll pair<ll, ll>
#define F first
#define S second
const int MOD = 1000000007;
template<class T> bool chmax(T &a, const T &b) { if (a<b) { a=b; return true; } return false; }
template<class T> bool chmin(T &a, const T &b) { if (a>b) { a=b; return true; } return false; }
//sort(all(x))とするとソートできるよ
// 10^x は pow(10,(x)) 
// 任意のlogは　対数の底の変換を使う    log(N) / log(任意の底)

int main(){
    int N,M;cin >> N >> M;
    vector<vector<int>> G(N,vector<int>());
    vector<int> h(N);
    rep(i,N){
        int a,b;cin >> a >> b;
        a--;b--;
        G[a].push_back(b);
        h[b]++;
    }
    queue<int> zero;

    rep(i,N)if(h[i] == 0)zero.push(i);

    vector<int> dist(N);    //dist[i]:=i番目の頂点を通るときの最長経路      この問題では根っこが1つしかないはずなので、根っこからの最長距離にあたるはず

    int j = 0;
    while(zero.size()){
        int v = zero.front();zero.pop();
        for(auto nv : G[v]){
            h[nv]--;
            chmax(dist[nv],dist[v]+1);
            if(h[nv] == 0)zero.push(nv);
        }
    }

    vector<int> ans(N,-1);
    rep(v,N) for(auto nv : G[v]) if(dist[nv] - dist[v] == 1) ans[nv] = v;   // 距離の差が1のものが必然的に隣り合ったもので、これがもともとのグラフの経路のはず。※1

    rep(i,N)cout << ans[i] + 1 << endl;     // +1 はグラフ作成時に0indexにしたやつをもとに戻すのと、根っこは0を出力なので、-1+1=0にするため。根は一つしかないから（至言）

}

// ※1 これに関しては、解説放送がわかりやすい。
//     端的に説明すると、距離差が2以上のとき、つまり頂点をジャンプして子孫につながるルートが正規ルートだと仮定すると、距離差１の経路は新たに頂点を生まないと生えてこないことになる。
//     これは明らかにグラフ形成と有向辺の追加のルールに反しているので矛盾。