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# (Mono 4.6.2.0) (judge verdict: Wrong Answer)

using System;
using System.Collections;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Threading.Tasks;

namespace Atcoder
{
    class vertices
    {
        public int number;
        public List<vertices> children= null;
        public List<vertices> parents = null;
        public int depth;
        public vertices()
        {
            this.depth = 0;
            this.number = 0;
            this.children = new List<vertices>();
            this.parents = new List<vertices>();
        }

    }


    class Program
    {
        static void Main(string[] argsv)
        {
            var split = Console.ReadLine().Split();
            int N = int.Parse(split[0]);
            int M = int.Parse(split[1]);
            vertices[] vertices = new Atcoder.vertices[N];
            for (int i = 0; i < N; i++)
            {
                vertices[i] = new Atcoder.vertices();
                vertices[i].number = i+1;
            }
            int[] candidate_root = new int[N];
            for (int i = 0; i < N + M - 1; i++)
            {
                split = Console.ReadLine().Split();
                int A = int.Parse(split[0]);
                int B = int.Parse(split[1]);
                vertices[A - 1].children.Add(vertices[B - 1]);
                vertices[B - 1].parents.Add(vertices[A - 1]);
                candidate_root[B - 1] = 1;

            }
            ;
            int ignore = 0;
            for (int i = 0; i < candidate_root.Length; i++)
            {
                if (candidate_root[i] == 1) continue;

                Queue<int> queue = new Queue<int>();
                queue.Enqueue(i);

                while (queue.Count != 0)
                {
                    int task = queue.Dequeue();
                    for (int j = 0; j < vertices[task].children.Count; j++)
                    {
                        if (vertices[task].children[j].depth!= 0)
                        {
                            ignore++;
                            vertices[task].children[j].parents = vertices[task].children[j].parents.Where(x => x.number != task).ToList();
                            vertices[task].children.RemoveAt(j);
                            j--;
                            continue;
                        }
                        else
                        {
                            vertices[task].children[j].depth = vertices[task].depth + 1;
                            queue.Enqueue(vertices[task].children[j].number - 1);
                        }

                    }

                }

                int[] output = new int[N];
                if (ignore == M)
                {
                    queue.Enqueue(i);
                    while (queue.Count != 0)
                    {
                        int task = queue.Dequeue();
                        for (int j = 0; j < vertices[task].children.Count; j++)
                        {
                            if (vertices[task].children[j].depth == vertices[task].depth + 1)
                            {
                                output[vertices[task].children[j].number-1] = vertices[task].number;
                                queue.Enqueue(vertices[task].children[j].number - 1);
                            }
                        }
                    }
                }
                for (int d = 0; d < output.Length; d++)
                {
                    Console.WriteLine(output[d]);
                }
            }
        }
    }
}