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 


import java.io.BufferedReader;
import java.io.IOException;
import java.io.InputStreamReader;
import java.io.PrintWriter;
import java.util.ArrayList;
import java.util.Collections;
import java.util.LinkedList;
import java.util.PriorityQueue;
import java.util.StringTokenizer;

public class MinimalLabels {
	public static PrintWriter out;
    
	   //-----------MyScanner class for faster input----------
	   public static class MyScanner {
	      BufferedReader br;
	      StringTokenizer st;
	 
	      public MyScanner() {
	         br = new BufferedReader(new InputStreamReader(System.in));
	      }
	 
	      String next() {
	          while (st == null || !st.hasMoreElements()) {
	              try {
	                  st = new StringTokenizer(br.readLine());
	              } catch (IOException e) {
	                  e.printStackTrace();
	              }
	          }
	          return st.nextToken();
	      }
	 
	      int nextInt() {
	          return Integer.parseInt(next());
	      }
	 
	      long nextLong() {
	          return Long.parseLong(next());
	      }
	 
	      double nextDouble() {
	          return Double.parseDouble(next());
	      }
	 
	      String nextLine(){
	          String str = "";
		  try {
		     str = br.readLine();
		  } catch (IOException e) {
		     e.printStackTrace();
		  }
		  return str;
	      }

	   }
	   public static void main(String args[]) throws Exception {
			class prob {
				class node {
					int v;
					ArrayList<Integer> adj = new ArrayList<Integer>();
					int incount;
					int label;
					public void add(int x) {
						this.adj.add(x);
					}
				}
				void dfs(node[] in, boolean[] visit, int label, PriorityQueue<Integer> bfs) {
					while (!bfs.isEmpty()) {
						int top = bfs.poll();
						if (visit[top]) {
							continue;
						}
						in[top].label = label--;
						visit[top] = true;
						
						for (int x :in[top].adj) {
							in[x].incount--;
							if (in[x].incount == 0) {
								bfs.add(x);
							}
						}
					}
				}
				public void solve() {
					MyScanner sc = new MyScanner();
					int n = sc.nextInt();
					int m = sc.nextInt();
					
					node[] in = new node[n];
					boolean[] visit = new boolean[n];
					
					for (int i = 0; i < n; ++i) {
						in[i] = new node();
						in[i].v = i;
					}
					for (int i = 0; i < m; ++i) {
						int x = sc.nextInt() - 1;
						int y = sc.nextInt() - 1;
						
						in[y].add(x);
						++in[x].incount;
					}
					int label = n;
					PriorityQueue<Integer> bfs = new PriorityQueue<Integer>(n, Collections.reverseOrder());
					for (int i = 0; i < n; ++i) {
						if (in[i].incount == 0) {
							bfs.add(i);
						}
					}
					dfs(in, visit, label, bfs);
					for (int i = 0; i < n; ++i) {
						System.out.print(in[i].label + " ");
					}
				}
			}
			prob s = new prob();
			s.solve();
		}
}
