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>
#define REP(i, n) for(ll i = 0; i < (ll)n; i++)
#define FOR(i, a, b) for(ll i = (a); i < (ll)b; i++)
#define ALL(obj) (obj).begin(), (obj).end()
#define INF (1ll << 60)
#define sz(x) int(x.size())
using namespace std;
typedef long long ll;
using vl = vector<ll>;
using vvl = vector<vl>;
typedef double db;
typedef string str;
typedef pair<ll, ll> p;
constexpr int MOD = 1000000007;
using ll = long long;
template <class T> inline bool chmin(T &a, T b) {
    if(a > b) {
        a = b;
        return true;
    }
    return false;
}
template <class T> inline bool chmax(T &a, T b) {
    if(a < b) {
        a = b;
        return true;
    }
    return false;
}

void print(const std::vector<int> &v) {
    std::for_each(v.begin(), v.end(), [](int x) { std::cout << x << " "; });
    std::cout << std::endl;
}

template <typename KeyType, typename ValueType>
std::pair<KeyType, ValueType> get_max(const std::map<KeyType, ValueType> &x) {
    using pairtype = std::pair<KeyType, ValueType>;
    return *std::max_element(x.begin(), x.end(),
                             [](const pairtype &p1, const pairtype &p2) {
                                 return p1.second < p2.second;
                             });
}
vector<int> A;
vector<int> B;
vector<int> dist;
vector<int> par;
queue<int> que;
vector<vector<int>> edge;

// bfs
void bfs(int root) {
    queue<int> que;
    que.push(root);
    while(!que.empty()) {
        int v = que.front();
        que.pop();
        for(int next : edge[v]) {
            if(dist[next] != -1) {
                continue;
            } else {
                dist[next] = dist[v] + 1;
                par[next] = v;
                que.push(next);
            }
        }
    }
}
// dfs
void dfs(int root) {
    for(int next : edge[root]) {
        if(dist[next] == -1) {
            par[next] = root;
            dist[next] = dist[root] + 1;
            dfs(next);
        }
    }
}
int main() {
    int N, M;
    // N頂点, M本の有向辺
    cin >> N >> M;
    dist.resize(N);
    par.resize(N);
    REP(i, N) {
        dist[i] = -1;
        par[i] = 0;
    }
    A.resize(N - 1 + M);
    B.resize(N - 1 + M);
    map<int, int> cnt;
    edge.resize(N);
    REP(i, N) { cnt[i] = 0; } // return 0;
    REP(i, N - 1 + M) {
        cin >> A[i] >> B[i];
        A[i]--;
        B[i]--;
        cnt[B[i]]--;
        edge[A[i]].push_back(B[i]);
    }
    auto max = get_max(cnt);
    int root = max.first;
    // return 0;
    //幅優先
    dist[root] = 0;
    dfs(root);
    REP(i, N) { par[i]++; }
    par[root] = 0;
    REP(i, N) { cout << par[i] << endl; }
    // REP(i, N) { cout << dist[i] << endl; }
    return 0;
}