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

// Package main provides
//
// File:  main.go
// Author: ymiyamoto
//
// Created on Sun Jan 27 21:14:46 2019
//
package main

import "fmt"

type graph [][]int

func (g graph) dfs(n int, visited []bool) {
	for i := range g[n] {
		visited[g[n][i]] = true
		g.dfs(g[n][i], visited)
	}
}

func (g graph) root() int {
	roots := make([]bool, len(g))
	for i := range g {
		g.dfs(i, roots)
	}

	for i := range roots {
		if !roots[i] {
			return i
		}
	}
	return -1
}

func (g graph) depthDFS(n int, d int, depths []int) {
	if depths[n] < d {
		depths[n] = d
	}

	for i := range g[n] {
		g.depthDFS(g[n][i], d+1, depths)
	}
}

func (g graph) depth(n int) []int {
	dep := make([]int, len(g))
	dep[n] = 0
	for i := range g[n] {
		to := g[n][i]
		g.depthDFS(to, 1, dep)
	}
	return dep
}

func (g graph) parentsDFS(parent int, parents []int) {
	for i := range g[parent] {
		to := g[parent][i]
		if to != -1 {
			parents[to] = parent + 1
			g.parentsDFS(to, parents)
		}
	}
}

func (g graph) parents(root int) []int {
	parents := make([]int, len(g))
	parents[root] = 0
	g.parentsDFS(root, parents)
	return parents
}

func main() {
	var N, M int
	fmt.Scan(&N, &M)

	g := make(graph, N)
	for i := 0; i < N+M-1; i++ {
		var A, B int
		fmt.Scan(&A, &B)
		g[A-1] = append(g[A-1], B-1)
	}

	root := g.root()
	depths := g.depth(root)
	for i := range g {
		for j := range g[i] {
			if depths[i]+1 != depths[g[i][j]] {
				g[i][j] = -1
			}
		}
	}

	for _, p := range g.parents(root) {
		fmt.Println(p)
	}
}