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.*;
import java.lang.reflect.Array;
import java.math.BigInteger;
import java.util.*;


public class q5 {
	
	
	
	
	public static void main(String[] args) throws IOException {
		
		Reader.init(System.in);
		PrintWriter out=new PrintWriter(System.out);
		StringBuffer output=new StringBuffer("");
		int n=Reader.nextInt();
		int m=Reader.nextInt();
		ArrayList<Integer>[] gph=new ArrayList[n+1];
		for(int i=1;i<=n;i++) gph[i]=new ArrayList<Integer>();
		int[] deg=new int[n+1];
		for(int i=0;i<m;i++) {
			int a=Reader.nextInt();
			int b=Reader.nextInt();
			gph[b].add(a);
			deg[a]++;
		}
		PriorityQueue<Integer> pq=new PriorityQueue<Integer>(new Comparator<Integer>() {
			public int compare(Integer a,Integer b) {
				return b-a;
			}
		});
		int[] ans=new int[n+1];
		for(int i=1;i<=n;i++) if(deg[i]==0) pq.add(i);
		int toassign=n;
		while(pq.size()!=0) {
			int a=pq.poll();
			ans[a]=toassign;
			toassign--;
			for(int j:gph[a]) {
				deg[j]--;
				if(deg[j]==0) {
					pq.add(j);
				}
			}
		}
		for(int i=1;i<=n;i++) out.print(ans[i]+" ");
		out.print(output.toString());
		out.flush();
	}
}



class NoD{
	int a, b;
	NoD(int aa,int bb){
		a=Math.min(aa, bb);b=Math.max(aa, bb);
	}
}







class Reader {
    static BufferedReader reader;
    static StringTokenizer tokenizer;
    /** call this method to initialize reader for InputStream */
    static void init(InputStream input) {
        reader = new BufferedReader(
                     new InputStreamReader(input) );
        tokenizer = new StringTokenizer("");
    }
    /** get next word */
    static String nextLine() throws IOException{
    	return reader.readLine();
    }
    static String next() throws IOException {
        while ( ! tokenizer.hasMoreTokens() ) {
            //TODO add check for eof if necessary
            tokenizer = new StringTokenizer(
                   reader.readLine() );
        }
        return tokenizer.nextToken();
    }
    static int nextInt() throws IOException {
        return Integer.parseInt( next() );
    }
    static long nextLong() throws IOException {
        return Long.parseLong( next() );
    }
    static double nextDouble() throws IOException {
        return Double.parseDouble( next() );
    }
}