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.util.*;
import java.io.*;
import java.text.*;
public class T{
    static final long p = (long)163577857;
    static final int MAX = (int)1e5+1;
    static final double eps = 1e-9;
    static FastReader in;
    
    public static void main(String[] args){
        in = new FastReader();
        int n = ni(), m = ni();
        ArrayList<Integer>[] adj = new ArrayList[n+1];
        TreeSet<Integer>[] set = new TreeSet[n+1];
        for(int i = 0; i<= n; i++){
            adj[i] = new ArrayList<>();
            set[i] = new TreeSet<>();
        }
        int[] deg = new int[n+1];
        for(int i = 0; i< m; i++){
            int u = ni(), v = ni();
            adj[v].add(u);
            deg[u]++;
        }
        int[] ans = new int[n+1];
        for(int i = 1; i<= n; i++)set[deg[i]].add(i);
        for(int i = n; i>= 1; i--){
            int ind = set[0].last();
            ans[ind] = i;
            set[0].remove(ind);
            for(int j:adj[ind]){
                set[deg[j]].remove(j);
                deg[j]--;
                set[deg[j]].add(j);
            }
        }
        StringBuilder out = new StringBuilder("");
        for(int i = 1; i<= n; i++)out.append(ans[i]+" ");
        System.out.println(out.toString());
    }
    
    static void p(Object o){
        System.out.print(o);
    }
    
    static void pn(Object o){
        System.out.println(o);
    }
    
    static String n(){
        return in.next();
    }
    
    static String nln(){
        return in.nextLine();
    }
    
    static int ni(){
        return Integer.parseInt(in.next());
    }
    
    static long nl(){
        return Long.parseLong(in.next());
    }
    
    static double nd(){
        return Double.parseDouble(in.next());
    }
    
    static class FastReader{
        BufferedReader br;
        StringTokenizer st;
        public FastReader(){
            br = new BufferedReader(new InputStreamReader(System.in));
        }
        
        public FastReader(String s) throws Exception{
            br = new BufferedReader(new FileReader(s));
        }
 
        String next(){
            while (st == null || !st.hasMoreElements()){
                try{
                    st = new StringTokenizer(br.readLine());
                }catch (IOException  e){
                    e.printStackTrace();
                }
            }
            return st.nextToken();
        }
 
        String nextLine(){
            String str = "";
            try{
                str = br.readLine();
            }catch (IOException e){
                e.printStackTrace();
            }
            return str;
        }
    }
}