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: Accepted)

using System;
using System.Collections.Generic;
using System.Linq;
class Program{
	static List<int>[] li;
	static int[] s;
	static void Main(){
		Sc sc=new Sc();
		s=sc.Ia;
		li=new List<int>[s[0]+1];
		int[] h=new int[s[0]+1];
		h[0]=-1;
		int[] ans=new int[s[0]];
		for(int i = 1;i<=s[0];i++) {
			li[i]=new List<int>();
			ans[i-1]=-1;
		}
		for(int i = 0;i<s[0]+s[1]-1;i++) {
			int[] q=sc.Ia;
			li[q[0]].Add(q[1]);
			h[q[1]]++;
		}
		var pq=new Pq<Mo<int[]>>(s[0]+s[1]);
		for(int i = 1;i<=s[0];i++) {
			if(h[i]==0){
				ans[i-1]=0;
				for(int j=0;j<li[i].Count;j++){
					pq.Push(new Mo<int[]>(0,new int[]{li[i][j],i}));
				}
				break;
			}
		}
		while(pq.count>0){
			h[pq.Top().d[0]]--;
			if(h[pq.Top().d[0]]==0){
				ans[pq.Top().d[0]-1]=pq.Top().d[1];
				for(int j=0;j<li[pq.Top().d[0]].Count;j++){
					pq.Push(new Mo<int[]>(pq.Top().n+1,new int[]{li[pq.Top().d[0]][j],pq.Top().d[0]}));
				}
			}
			pq.Pop();
		}
		Console.WriteLine(String.Join("\n",ans));
	}
	static void Fu(int a,int b){
		for(int i=0;i<li[a].Count;i++) {
			
		}
	}
	static int ca(long[] a,long[] b){
		if(a[0]+b[0]<a[0]+b[0]){return 1;}
		else if(a[0]+b[0]>a[0]+b[0]){return -1;}
		else{return 0;}
	}
}
public class Mo<T>:IComparable{
	public int n;
	public T d;
	public Mo(int n,T d){this.n=n;this.d=d;}
	public int CompareTo(object obj){
		Mo<T> mymo=(Mo<T>)obj;
		if(mymo.n>this.n){return -1;}
		else if(mymo.n<this.n){return 1;}
		else{return 0;}
	}
}
public class Pq<T> where T:IComparable{
	private T[] he;
	public int count=0;
	public Pq(int max){he=new T[max];}
	public void Push(T x){
		int j=count;
		while(j!=0&&Compare(x,he[(j-1)/2])>0){he[j]=he[(j-1)/2];j=(j-1)/2;}
		he[j]=x;
		count++;
	}
	public void Pop(){
		count--;
		T r=he[count];
		int j=0;
		while(true){
			if(j*2+1<count){
				if(Compare(he[j*2+1],he[j*2+2])>0){j=j*2+1;}
				else{j=j*2+2;}
			}
			else if(j*2<count){j=j*2+1;}
			else{break;}
			if(Compare(he[j],r)<=0){j=(j-1)/2;break;}
			he[(j-1)/2]=he[j];
		}
		he[j]=r;
	}
	private int Compare(T x,T y){return y.CompareTo(x);}
	public int Count(){return count;}
	public T Top(){return he[0];}
}

class Sc{
	public int I{get{return int.Parse(Console.ReadLine());}}
	public long L{get{return long.Parse(Console.ReadLine());}}
	public double D{get{return double.Parse(Console.ReadLine());}}
	public string S{get{return Console.ReadLine();}}
	public int[] Ia{get{return Array.ConvertAll(Console.ReadLine().Split(),int.Parse);}}
	public long[] La{get{return Array.ConvertAll(Console.ReadLine().Split(),long.Parse);}}
	public double[] Da{get{return Array.ConvertAll(Console.ReadLine().Split(),double.Parse);}}
}