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.util.ArrayList;
import java.util.PriorityQueue;
import java.util.StringTokenizer;

public class Main{
	public static void main(String args[]) throws IOException{
		InputReader scan = new InputReader();
		int n = scan.nextInt(), m = scan.nextInt(), currLabel = n;
		Node[] node = new Node[n];
		for(int i = 0; i < n; i++)
			node[i] = new Node(i);
		for(int i = 0; i < m; i++){
			int from = scan.nextInt()-1, to = scan.nextInt()-1;
			node[from].children++;
			node[to].parents.add(node[from]);
		}
		PriorityQueue<Node> pq = new PriorityQueue<>();
		for(int i = 0; i < n; i++)
			if(node[i].children == 0){
				pq.add(node[i]);
				node[i].added = true;
			}
		int[] result = new int[n];
		while(!pq.isEmpty()){
			Node curr = pq.poll();
			result[curr.index] = currLabel;
			currLabel--;
			for(Node par : curr.parents){
				if(par.added) continue;
				par.children--;
				if(par.children > 0) continue;
				pq.add(par);
				par.added = true;
			}
		}
		StringBuilder sb = new StringBuilder();
		for(int i = 0; i < n; i++)
			sb.append(result[i] +  " ");
		System.out.println(sb);
	}
	
	static class Node implements Comparable<Node>{
		int index, children;
		boolean added;
		ArrayList<Node> parents;
		public Node(int i){
			index = i; children = 0; added = false;
			parents = new ArrayList<>();
		}		
		@Override
		public int compareTo(Node other){
			return other.index - this.index;
		}
	}
        
	//Custom Scanner
	
	static class InputReader {
        public BufferedReader reader;
        public StringTokenizer tokenizer;

        public InputReader() {
            reader = new BufferedReader(new InputStreamReader(System.in));
            tokenizer = null;
        }

        public String next() {
            while (tokenizer == null || !tokenizer.hasMoreTokens()) {
                try {
                    tokenizer = new StringTokenizer(reader.readLine());
                } catch (IOException e) {
                    throw new RuntimeException(e);
                }
            }
            return tokenizer.nextToken();
        }

        public int nextInt() {
            return Integer.parseInt(next());
        }

    }

}