You are given a directed acyclic graph with n vertices and m edges. There are no self-loops or multiple edges between any pair of vertices. Graph can be disconnected.

You should assign labels to all vertices in such a way that:

  * Labels form a valid permutation of length n — an integer sequence such that each integer from 1 to n appears exactly once in it. 
  * If there exists an edge from vertex v to vertex u then labelv should be smaller than labelu. 
  * Permutation should be lexicographically smallest among all suitable. 



Find such sequence of labels to satisfy all the conditions.

Input

The first line contains two integer numbers n, m (2 ≤ n ≤ 105, 1 ≤ m ≤ 105).

Next m lines contain two integer numbers v and u (1 ≤ v, u ≤ n, v ≠ u) — edges of the graph. Edges are directed, graph doesn't contain loops or multiple edges.

Output

Print n numbers — lexicographically smallest correct permutation of labels of vertices.

Examples

Input

3 3
1 2
1 3
3 2


Output

1 3 2 


Input

4 5
3 1
4 1
2 3
3 4
2 4


Output

4 1 2 3 


Input

5 4
3 1
2 1
2 3
4 5


Output

3 1 2 4 5 
#!/usr/local/bin/python3

from collections import defaultdict
import heapq

num_nodes, num_edges = map(int, input().split())

ins = defaultdict(set)
out = defaultdict(int)

for _ in range(num_edges):
    node_out, node_in = map(int, input().split())
    ins[node_in].add(node_out)
    out[node_out] += 1

zeros = [-node for node in range(num_nodes, 0, -1) if out[node] == 0]

final_mappings = {}
current_index = num_nodes

while current_index > 0:

    node = -heapq.heappop(zeros)
    final_mappings[node] = current_index
    current_index -= 1

    for node_out in ins[node]:
        out[node_out] -= 1
        if out[node_out] == 0:
            heapq.heappush(zeros, -node_out)
    
print(' '.join(str(final_mappings[node]) for node in range(1, num_nodes + 1)))
