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 javax.print.attribute.standard.MediaPrintableArea;
import java.math.BigDecimal;
import java.math.BigInteger;
import java.math.RoundingMode;
import java.io.*;
import java.util.*;
/**
 * Created by Firеfly on 1/1/2017.
 */
public class Task {
    public static void main(String[] args) throws IOException {
        Emaxx emaxx = new Emaxx();
    }
}


class Emaxx {
    FScanner fs;
    PrintWriter pw;
    int n, off, m, k;
    Integer W;
    ArrayList<Integer>[] graph;
    int[][] to;
    double[] comes, zh;
    int[] nums, res;
    LinkedList<Pair> qoue;
    boolean[] flags;
    Emaxx() throws IOException {
        fs = new FScanner(new InputStreamReader(System.in));
        // pw = new PrintWriter(new FileWriter("arithnumbers.out"));
        //  fs = new FScanner(new FileReader("C:\\Users\\Firеfly\\Desktop\\New Text Document.txt"));
        //     fs = new FScanner(new FileReader("input.txt"));;
        //       pw = new PrintWriter("output.txt");
        PrintWriter pw = new PrintWriter(System.out);
        n = fs.nextInt();
        m = fs.nextInt();
        graph = new ArrayList[n];
        ArrayList<Integer>[] graphout = new ArrayList[n];
        for (int i =0 ; i<n; i++)
        {
            graph[i] = new ArrayList<>();
            graphout[i] = new ArrayList<>();
        }
        for (int i = 0;i<m; i++) {
            int from = fs.nextInt()-1, to = fs.nextInt()-1;
            graph[from].add(to);
            graphout[to].add(from);
        }
        int[] sizes = new int[n];
        for (int i =0;i<n; i++)
            sizes[i] = graph[i].size();
        TreeMap<Integer, TreeSet<Integer>> map = new TreeMap<>();
        for (int i =0; i<n; i++) {
            if (map.containsKey(sizes[i]))
                map.get(sizes[i]).add(i);
            else {
                map.put(sizes[i], new TreeSet<>());
                map.get(sizes[i]).add(i);
            }
        }
        int[] ans= new int[n];
        int g = n;
        while (g!=0) {
            int cur = map.get(map.firstKey()).pollLast();
            ans[cur] = g--;
            for (int i = 0; i<graphout[cur].size(); i++) {
                int f = graphout[cur].get(i);
                map.get(sizes[f]).remove(f);
                if (map.get(sizes[f]).isEmpty())
                    map.remove(sizes[f]);
                sizes[f]--;
                if (map.containsKey(sizes[f]))
                    map.get(sizes[f]).add(f);
                else {
                    map.put(sizes[f], new TreeSet<>());
                    map.get(sizes[f]).add(f);
                }
            }
        }
        for (int i = 0; i<n; i++)
            pw.print(ans[i] + " ");

        pw.close();
    }



}


class Triple implements Comparable<Triple> {
    int t, ni, k;
    Triple(int x1, int y1, int c1) {
        t = x1; ni = y1; k = c1;
    }

    @Override
    public int compareTo(Triple triple) {
        return Integer.compare(t, triple.t);
    }
}
class Pair implements Comparable<Pair>{
    int x, y;
    Pair(int x1, int y1) {x = x1; y = y1;}
    Pair(){}
    @Override
    public int compareTo(Pair o) {
        return Integer.compare(x, o.x);
    }
}

class Algs {
    public static int[] Z_f(char[] s) {
        int[] zf = new int[s.length];
        zf[0] = -1;
        int l = 0, r= 0;
        for (int i = 1; i<s.length; i++) {
            if (i>r)
            {
                int g = i;
                while (g < s.length && s[g] == s[g-i])
                    g++;
                if (g == i)
                    continue;
                l = i;
                r = g-1;
                zf[i] = g-i;
            } else {
                if (zf[i-l]<=r-i+1)
                    zf[i] = zf[i-l];
                else {
                    int g = r+1;
                    while (g <s.length && s[g] == s[g-i])
                        g++;
                    if (g == r+1)
                        zf[i] = r-i+1;
                    else {
                        zf[i] = g-i;
                        r = g-1;
                        l = i;
                    }
                }
            }
        }
        return zf;
    }
}



class FScanner {
    BufferedReader br;
    StringTokenizer st;
    FScanner(InputStreamReader isr) {
        br = new BufferedReader(isr);
    }

    FScanner(FileReader fr) {
        br = new BufferedReader(fr);
    }

    String nextToken() throws IOException{
        while (st == null || !st.hasMoreTokens()) {
            String s = br.readLine();
            if (s == null)
                return null;
            st = new StringTokenizer(s);
        }
        return st.nextToken();
    }

    int nextInt() throws IOException {
        return Integer.parseInt(nextToken());
    }

    long nextLong() throws IOException {
        return Long.parseLong(nextToken());
    }

    double nextDouble() throws IOException {
        return Double.parseDouble(nextToken());
    }

    String nextLine() throws IOException {
        return br.readLine();
    }

    char nextChar() throws IOException {
        return (char) br.read();
    }
}
