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.io.*;
import java.util.TreeSet;
import java.util.ArrayList;
import java.util.List;
import java.util.Collections;
import java.util.StringTokenizer;

/**
 * Built using CHelper plug-in
 * Actual solution is at the top
 */
public class Main {
	public static void main(String[] args) {
		InputStream inputStream = System.in;
		OutputStream outputStream = System.out;
		InputReader in = new InputReader(inputStream);
		OutputWriter out = new OutputWriter(outputStream);
		TaskE solver = new TaskE();
		solver.solve(1, in, out);
		out.close();
	}
}

class TaskE {
	public void solve(int testNumber, InputReader in, OutputWriter out) {
		int n = in.nextInt(), m = in.nextInt();
		List<List<Integer>> rg = new ArrayList<>();
		List<Integer> outCnt = new ArrayList<>(Collections.nCopies(n, 0));
		for (int i = 0; i < n; ++i){
			rg.add(new ArrayList<>());
		}
		for (int i = 0; i < m; ++i){
			int u = in.nextInt() - 1, v = in.nextInt() - 1;
			rg.get(v).add(u);
			outCnt.set(u, outCnt.get(u) + 1);
		}
		TreeSet<Integer> vs = new TreeSet<>((a, b) -> b - a);
		List<Integer> answer = new ArrayList<>(Collections.nCopies(n, 0));
		for (int i = 0; i < n; ++i){
			if (outCnt.get(i) == 0){
				vs.add(i);
			}
		}
		for (int i = n; i > 0; --i){
			int v = vs.pollFirst();
			answer.set(v, i);
			List<Integer> next = rg.get(v);
			for (Integer to: next){
				int val = outCnt.get(to);
				if (val == 1){
					vs.add(to);
				} else {
					outCnt.set(to, val - 1);
				}
			}
		}
		for (Integer val: answer){
			out.print(val + " ");
		}
	}
}

class InputReader {
    BufferedReader br;
    StringTokenizer st;

    public InputReader(InputStream in)
    {
        br = new BufferedReader(new
                InputStreamReader(in));
    }

    public InputReader(String filename) throws IOException{
        br = new BufferedReader(new FileReader(filename));
    }

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

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

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

    public double nextDouble()
    {
        return Double.parseDouble(next());
    }

    public String nextLine()
    {
        String str = "";
        try
        {
            str = br.readLine();
        }
        catch (IOException e)
        {
            e.printStackTrace();
        }
        return str;
    }
}

class OutputWriter extends PrintWriter{
    public OutputWriter(Writer out) {
        super(out);
    }

    public OutputWriter(Writer out, boolean autoFlush) {
        super(out, autoFlush);
    }

    public OutputWriter(OutputStream out) {
        super(out);
    }

    public OutputWriter(OutputStream out, boolean autoFlush) {
        super(out, autoFlush);
    }

    public OutputWriter(String fileName) throws FileNotFoundException {
        super(fileName);
    }

    public OutputWriter(String fileName, String csn) throws FileNotFoundException, UnsupportedEncodingException {
        super(fileName, csn);
    }

    public OutputWriter(File file) throws FileNotFoundException {
        super(file);
    }

    public OutputWriter(File file, String csn) throws FileNotFoundException, UnsupportedEncodingException {
        super(file, csn);
    }
}

