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 
/**
 * @author Finn Lidbetter
 */
import java.util.*;
import java.io.*;
import java.awt.geom.*;

public class TaskE {
  public static void main(String[] args) throws IOException {
    BufferedReader br = new BufferedReader(new InputStreamReader(System.in));
    StringBuilder sb = new StringBuilder();
    String[] s = br.readLine().split(" ");
    int n = Integer.parseInt(s[0]);
    int m = Integer.parseInt(s[1]);

    Node[] nodes = new Node[n];
    for (int i=0; i<n; i++) {
      nodes[i] = new Node(i);
    }
    for (int i=0; i<m; i++) {
      s = br.readLine().split(" ");
      int a = Integer.parseInt(s[0])-1;
      int b = Integer.parseInt(s[1])-1;
      // edges are reversed
      nodes[b].adj.add(nodes[a]);
      nodes[a].deg++;
    }

    TreeSet<Node> degrees = new TreeSet<>();
    for (int i=0; i<n; i++) {
      degrees.add(nodes[i]);
    }
    int[] perm = new int[n];
    for (int i=n; i>0; i--) {
      Node curr = degrees.pollFirst();
      perm[curr.id] = i;
      for (Node x:curr.adj) {
        degrees.remove(x);
        Node rein = nodes[x.id];
        rein.deg--;
        degrees.add(rein);
      }
    }
    for (int i=0; i<n; i++) {
      sb.append(perm[i] + ((i==n-1) ? "\n":" "));
    }
    System.out.print(sb);

  }
}
class Node implements Comparable<Node> {
  int id;
  ArrayList<Node> adj;
  int deg;
  public Node(int idd) {
    id = idd;
    adj = new ArrayList<Node>();
  }
  public int compareTo(Node n2) {
    if (deg==n2.deg)
      return n2.id-id;
    return deg-n2.deg;
  }
}
