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.*;

public class Main {
    public static void main(String[] args) throws IOException {
        FastScanner in = new FastScanner(System.in);
        PrintWriter out = new PrintWriter(System.out);
        new Main().run(in, out);
        out.close();
    }

    public static long mod = 17352642619633L;

    int N;
    int M;
    List<Integer>[] adj;
    int[] ret;
    void run(FastScanner in, PrintWriter out) {
        N = in.nextInt();
        M = in.nextInt();
        adj = new List[N+2];
        ret = new int[N+2];
        for (int i = 0; i < adj.length; i++) adj[i] = new ArrayList<>();
        int[] deg = new int[N+2];
        for (int i = 0; i < M; i++) {
            int u = in.nextInt();
            int v = in.nextInt();
            deg[u]++;
            // adj[u].add(v);
            adj[v].add(u);
        }
        PriorityQueue<Integer> pq = new PriorityQueue<>((a,b) -> b-a);
        for (int i = 1; i <= N; i++) {
            if (deg[i] == 0) pq.offer(i);
        }

        int sz = N;
        while (!pq.isEmpty()) {
            int u = pq.poll();
            ret[u] = sz--;

            for (int v : adj[u]) {
                deg[v]--;
                if (deg[v] == 0) pq.offer(v);
            }
        }
        for (int i = 1; i <= N; i++) {
            out.print(ret[i]+" ");
        }
        out.println();


    }


    static class FastScanner {
        BufferedReader br;
        StringTokenizer st;

        public FastScanner(InputStream in) {
            br = new BufferedReader(new InputStreamReader(in));
            st = null;
        }

        String next() {
            while (st == null || !st.hasMoreElements()) {
                try {
                    st = new StringTokenizer(br.readLine());
                } catch (IOException e) {
                    e.printStackTrace();
                }
            }
            return st.nextToken();
        }

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

        long nextLong() {
            return Long.parseLong(next());
        }
    }
}
