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 Go (1.6) (judge verdict: Wrong Answer)

package main

import (
	"bufio"
	"container/list"
	"fmt"
	"os"
	"strconv"
	"strings"
)

//scanで一行づつ読み込む
var sc = bufio.NewScanner(os.Stdin)
var wtr = bufio.NewWriter(os.Stdout)

//sort
// array := []int{5, 1, 4, 2, 3}
// sort.Sort(sort.IntSlice(array))

func main() {
	// a := make([]int, n)
	// A := strings.Split(nextLine(), " ")

	N := strings.Split(nextLine(), " ")
	// n, _ := strconv.Atoi(input[0])

	n, _ := strconv.Atoi(N[0])
	m, _ := strconv.Atoi(N[1])

	var arr = make(map[int][]dishh)
	ans := make([]int, n+1, n+2)
	memo := make([]bool, n+1, n+2)

	for i := 0; i < n+m-1; i++ {
		tmp := strings.Split(nextLine(), " ")
		a, _ := strconv.Atoi(tmp[0])
		b, _ := strconv.Atoi(tmp[1])

		// dishCur := []dishh{{curA, curB}}
		if _, ok := arr[a]; ok {

			arr[a] = append(arr[a], dishh{a, b})
			memo[b] = true
		} else {
			arr[a] = []dishh{{a, b}}
			memo[b] = true
		}

	}

	queue := list.New()
	root := 0

	for i := 1; i < n+1; i++ {
		if !memo[i] {
			root = i
			break
		}
	}

	memo = make([]bool, n+1, n+2) //memo[:len(memo)+1]
	memo[root] = true
	queue.PushBack(root)
	for {

		curT := queue.Remove(queue.Front())

		if cur, ok := curT.(int); ok {

			for _, val := range arr[cur] {
				// fmt.Println("current : ", root, val)

				if memo[val.second] {
					ans[val.second] = val.first
				} else {
					ans[val.second] = val.first
					memo[val.second] = true
					queue.PushBack(val.second)
				}
			}
		}

		if queue.Len() == 0 {
			break
		}
	}

	for i := 1; i < n+1; i++ {
		fmt.Fprintln(wtr, ans[i])
	}

	// fmt.Fprintln(wtr, ans-against)
	_ = wtr.Flush()
}

func nextLine() string {
	sc.Scan()
	return sc.Text()
}

func min(a, b int) int {
	if a < b {
		return a
	}
	return b
}
func max(a, b int) int {
	if a > b {
		return a
	}
	return b
}
func com(a, b int) int {

	if a > b {
		return 0
	}
	return abs(a - b)
}

func abs(a int) int {
	if a < 0 {
		return a * -1
	}
	return a
}

type dishh struct {
	first  int
	second int
}

// 構造体のスライス
type dish []dishh

// 以下インタフェースを満たす

func (p dish) Len() int {
	return len(p)
}

func (p dish) Swap(i, j int) {
	p[i], p[j] = p[j], p[i]
}

func (p dish) Less(i, j int) bool {

	return p[i].first+p[i].second > p[j].first+p[j].second
}