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 Java8 (OpenJDK 1.8.0) (judge verdict: Accepted)

import java.util.*;
import java.io.*;

/*
   AtCoder contest
   coder : yoichidon
 */

class Pair<E extends Comparable<E>,F extends Comparable<F>> implements Comparable<Pair<E,F>>{
    E first;
    F second;
    public Pair(E first, F second){
        this.first=first;
        this.second=second;
    }
    public E getFirst(){return first;}
    public F getSecond(){return second;}
    public String toString(){
        return "<"+first.toString()+","+second.toString()+">";
    }
    public int hashCode(){
        return first.hashCode()*30011+second.hashCode()+2;
    }
    public boolean equals(Object obj) {
        if (this == obj)
            return true;
        if (obj == null)
            return false;
        if (getClass() != obj.getClass())
            return false;
        Pair another = (Pair) obj;
        return this.getFirst().equals(another.getFirst())&&this.getSecond().equals(another.getSecond());
    }

    public int compareTo(Pair<E,F> another){
        if(this.getFirst().equals(another.getFirst())){
            return this.getSecond().compareTo(another.getSecond());
        }
        return this.getFirst().compareTo(another.getFirst());
    }

}

class Graph{
    int nodeNum;
    LinkedList<Integer>[] parents;
    LinkedList<Integer>[] children;
    Set<Integer> leaf;
    Set<Integer> top;

    public Graph(int nodeNum){
        this.nodeNum = nodeNum;
        this.parents = new LinkedList[nodeNum];
        this.children = new LinkedList[nodeNum];
        this.leaf = new HashSet<Integer>();
        this.top = new HashSet<Integer>();
        for(int n=0; n<nodeNum; n++){
            parents[n] = new LinkedList<>();
            children[n] = new LinkedList<>();
            leaf.add(n);
            top.add(n);
        }
    }
    public void addEdge(int parent, int child){
        children[parent].add(child);
        parents[child].add(parent);
        leaf.remove(parent);
        top.remove(child);
    }

    public LinkedList<Integer> topologicalSort(){
        LinkedList<Integer>[] p = new LinkedList[nodeNum];
        for(int n=0; n<nodeNum; n++) p[n] = new LinkedList<>(parents[n]);
        LinkedList<Integer>[] c = new LinkedList[nodeNum];
        for(int n=0; n<nodeNum; n++) c[n] = new LinkedList<>(children[n]);


        PriorityQueue<Integer> S = new PriorityQueue<>(top);
        LinkedList<Integer> L = new LinkedList<>();
        while(! S.isEmpty()){
            int n = S.poll();
            L.addLast(n);
            for(int m: children[n]){
                p[m].remove(new Integer(n));
                c[n].remove(new Integer(m));
                if(p[m].isEmpty()) S.add(m);
            }
        }
        return L;
    }


}


public class Main {

    public static void main(String[] args) {
        Scanner sc = new Scanner(System.in);
        int N = sc.nextInt();
        int M = sc.nextInt();

        Graph graph = new Graph(N);
        for(int e=0; e<N+M-1; e++){
            graph.addEdge(sc.nextInt()-1, sc.nextInt()-1);
        }


        LinkedList<Integer> tp = graph.topologicalSort();
        //System.out.println(graph.topologicalSort());
        int[] parents = new int[N]; Arrays.fill(parents, -1);
        for(int n:tp){
            for(int m:graph.children[n]) parents[m]=n;
        }

        for(int n=0; n<N; n++) System.out.println(parents[n]+1);


    }
}