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.util.*;
public class CF0825E {

    /**
     * First impression:
     * Same as topological sort, put vertex in queue as soon  as its indegree is 0, but use priorityqueue instead
     * Counterexample: 3 1, 3 1
     * Correct is 231 but I get 312
     * To deal with this, I instead do this in reverse: go from N to 1
     * Pick largest vertex with 0 outdegree
     * 
     */
    public static void main(String[] args) throws IOException {
        BufferedReader br=new BufferedReader(new InputStreamReader(System.in));
         StringTokenizer st=new StringTokenizer(br.readLine());
         int N=Integer.parseInt(st.nextToken());
         int M=Integer.parseInt(st.nextToken());
         int a,b; int[] outdeg=new int[N]; ArrayList<Integer> arl[]=new ArrayList[N];
         for (int i = 0; i < N; i++) {
            arl[i]=new ArrayList<>();
        }
         for (int i = 0; i < M; i++) {
            st=new StringTokenizer(br.readLine());
            a=Integer.parseInt(st.nextToken())-1;
            b=Integer.parseInt(st.nextToken())-1;
            arl[b].add(a); outdeg[a]++;
        }
         TreeSet<Integer> ts=new TreeSet<>();
         StringBuilder sb=new StringBuilder();
         for (int i = 0; i < N; i++) {
            if(outdeg[i]==0){
                ts.add(i);
            }
        }
        
         int p; int cnt=N; int[] l=new int[N];
         while(!ts.isEmpty()){
             p=ts.pollLast();l[p]=cnt; cnt--;
             for (int i : arl[p]) {
                 outdeg[i]--;
                 if(outdeg[i]==0){
                     ts.add(i);
                 }
             }
         }
         for (int i = 0; i < N; i++) {
            sb.append(l[i]).append(" ");
        }
         System.out.println(sb.toString());
    }
    
}
