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 
/*
If you want to aim high, aim high
Don't let that studying and grades consume you
Just live life young
******************************
What do you think? What do you think?
1st on Billboard, what do you think of it
Next is a Grammy, what do you think of it
However you think, I’m sorry, but shit, I have no fcking interest
*******************************
I'm standing on top of my Monopoly board
That means I'm on top of my game and it don't stop
til my hip don't hop anymore
https://www.a2oj.com/Ladder16.html
*******************************
Shining through the city with a little funk and soul
*******************************
300iq as writer = Sad!
*/
import java.util.*;
import java.io.*;
import java.math.*;

   public class x825E
   {
      static ArrayDeque<Integer>[] edges;
      public static void main(String hi[]) throws Exception
      {
         BufferedReader infile = new BufferedReader(new InputStreamReader(System.in));
         StringTokenizer st = new StringTokenizer(infile.readLine());
         int N = Integer.parseInt(st.nextToken());
         int M = Integer.parseInt(st.nextToken());
         edges = new ArrayDeque[N+1];
         for(int i=1; i <= N; i++)
            edges[i] = new ArrayDeque<Integer>();
         while(M-->0)
         {
            st = new StringTokenizer(infile.readLine());
            int a = Integer.parseInt(st.nextToken());
            int b = Integer.parseInt(st.nextToken());
            edges[a].add(b);
         }
         ArrayList<Integer> sort = new ArrayList<Integer>();
         boolean[] seen = new boolean[N+1];
         for(int v=1; v <= N; v++)
            if(!seen[v])
               dfs(v, seen, sort);
         ArrayDeque<Integer>[] buckets = new ArrayDeque[N+1];
         for(int v=1; v <= N; v++)
            buckets[v] = new ArrayDeque<Integer>();
         for(int v=1; v <= N; v++)
            for(int next: edges[v])
               buckets[next].add(v);
         int[] res = new int[N+1];
         PriorityQueue<Integer> pq = new PriorityQueue<Integer>(Comparator.reverseOrder());
         int[] removed = new int[N+1];
         for(int v=1; v <= N; v++)
            if(edges[v].size() == 0)
               pq.add(v);
         int tag = N;
         while(pq.size() > 0)
         {
            int curr = pq.poll();
            for(int parent: buckets[curr])
            {
               removed[parent]++;
               if(removed[parent] == edges[parent].size())
                  pq.add(parent);
            }
            res[curr] = tag--;
         }
         StringBuilder sb = new StringBuilder();
         for(int i=1; i <= N; i++)
            sb.append(res[i]+" ");
         System.out.println(sb);
      }
      public static void dfs(int curr, boolean[] seen, ArrayList<Integer> ls)
      {
         seen[curr] = true;
         for(int next: edges[curr])
            if(!seen[next])
               dfs(next, seen, ls);
         ls.add(curr);
      }
   }