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: Time Limit Exceeded)

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

namespace AtCoder {
    public class Program {
        static int[] getKeys(char delimiter) {
            var Keys = Console.ReadLine().Split(' ');
            int N = Keys.Length;
            int[] Ns = new int[N];
            for (int i = 0; i < N; i++) {
                Ns[i] = int.Parse(Keys[i]);
            }
            return Ns;
        }
        public static void Show<T>(T[,] map) {
            int H = map.GetLength(0);
            int W = map.GetLength(1);
            Console.WriteLine("-------------------------");
            for (int i = 0; i < H; i++) {
                for (int j = 0; j < W; j++) {
                    Console.Write(map[i, j] + " ");
                }
                Console.WriteLine();
            }
            Console.WriteLine("-------------------------");
        }
        public static void Show<T>(T[,] map, string delimiter) {
            int H = map.GetLength(0);
            int W = map.GetLength(1);
            Console.WriteLine("-------------------------");
            for (int i = 0; i < H; i++) {
                for (int j = 0; j < W; j++) {
                    Console.Write(map[i, j] + delimiter);
                }
                Console.WriteLine();
            }
            Console.WriteLine("-------------------------");
        }
        public static void Show<T>(IEnumerable<T> ts) {
            foreach (var item in ts) {
                Console.Write(item + " ");
            }
            Console.WriteLine();
        }
        public static void Show<T>(IEnumerable<T> ts, string delimiter) {
            foreach (var item in ts) {
                Console.Write(item + delimiter);
            }
            Console.WriteLine();
        }

        static List<Edge> getEdge(int n) {
            int[] Key;
            List<Edge> edges = new List<Edge>();
            for (int i = 0; i < n; i++) {
                Key = getKeys(' ');
                edges.Add(new Edge(Key[0], Key[1]));
            }
            return edges;
        }

        static void Main() {
            var Key = getKeys(' ');
            var nodes = new int[Key[0]];
            for (int i = 0; i < nodes.Length; i++) {
                nodes[i] = i + 1;
            }
            var edges = getEdge(Key[0] + Key[1] - 1);
            var Copy = new List<Edge>();
            //答えを格納する配列と、入力辺を持たない頂点配列の2つを用意する。
            List<int> Sorted = new List<int>();
            List<Edge> SortedEdge = new List<Edge>();
            List<int> Roots = nodes.Except(edges.Select(x => x.To).Distinct()).ToList();
            while (Roots.Count > 0) {
                int n = Roots.First();
                Roots.Remove(n);
                Sorted.Add(n);
                //取り出したNode nから伸びる辺をリストアップ。
                var Outs = edges.Where(x => x.From == n).ToArray();
                //その辺が行き着くNodeについて考える。
                for (int i = 0; i < Outs.Length; i++) {
                    int to = Outs[i].To;
                    edges.Remove(Outs[i]);
                    Copy.Add(Outs[i]);
                    //もしそのNodeが他に入力辺を持たないなら、Rootに追加する。
                    if (edges.Where(x => x.To == to).Count() == 0) { Roots.Add(to); SortedEdge.Add(Outs[i]); }
                }
            }
            if (edges.Count > 0) {
                Console.WriteLine("閉路を検出しました。");
                return;
            }
//            Show(Sorted);
//            Show(SortedEdge);
            SortedEdge.Sort((x, y) => x.To - y.To);
            int[] Answer = new int[nodes.Length];
            for (int i = 0; i < SortedEdge.Count; i++) {
                Answer[SortedEdge[i].To - 1] = SortedEdge[i].From;
            }
            foreach (var item in Answer) {
                Console.WriteLine(item);
            }
        }

        public class Node {
            public int Number;
            public List<Edge> In, Out;
            public Node(int n) {
                Number = n;
                In = new List<Edge>();
                Out = new List<Edge>();
            }
            public override string ToString() {
                StringBuilder SB = new StringBuilder();
                SB.AppendLine("Number:" + Number);
                SB.AppendLine("IN-Edge:");
                foreach (var item in In) {
                    SB.Append(item.From + " ");
                }
                SB.AppendLine();
                SB.AppendLine("OUT-Edge:");
                foreach (var item in Out) {
                    SB.Append(item.To + " ");
                }
                SB.AppendLine();
                return SB.ToString();
            }
        }
        public class Edge {
            public int From, To;
            public Edge(int from, int to) {
                From = from;
                To = to;
            }
            public override string ToString() {
                return From + "->" + To;
            }
        }
    }
}