"""# 

### 谜题描述
Sergey just turned five years old! When he was one year old, his parents gave him a number; when he was two years old, his parents gave him an array of integers. On his third birthday he received a string. When he was four, his mother woke him up in a quiet voice, wished him to be a good boy and gave him a rooted tree. Today he celebrates his birthday again! He found a directed graph without loops as a present from his parents.

Since Sergey is a very curious boy, he immediately came up with a thing to do. He decided to find a set Q of vertices in this graph, such that no two vertices x, y ∈ Q are connected by an edge, and it is possible to reach any vertex z ∉ Q from some vertex of Q in no more than two moves. 

After a little thought, Sergey was able to solve this task. Can you solve it too?

A vertex y is reachable from a vertex x in at most two moves if either there is a directed edge (x,y), or there exist two directed edges (x,z) and (z, y) for some vertex z.

Input

The first line of input contains two positive integers n and m (1 ≤ n ≤ 1 000 000, 1 ≤ m ≤ 1 000 000) — the number of vertices and the number of edges in the directed graph.

Each of the following m lines describes a corresponding edge. Each one contains two integers a_i and b_i (1 ≤ a_i, b_i ≤ n, a_i ≠ b_i) — the beginning and the end of the i-th edge. The graph may contain multiple edges between the same pair of vertices.

Output

First print the number k — the number of selected vertices. Then print k distinct integers — the indices of the selected vertices.

If multiple answers exist you can output any of them. In particular, you don't have to minimize the number of vertices in the set. It is guaranteed, that there is always at least one valid set.

Examples

Input

5 4
1 2
2 3
2 4
2 5


Output

4
1 3 4 5 


Input

3 3
1 2
2 3
3 1


Output

1
3 

Note

In the first sample, the vertices 1, 3, 4, 5 are not connected. The vertex 2 is reachable from vertex 1 by one edge.

In the second sample, it is possible to reach the vertex 1 in one move and the vertex 2 in two moves.

The following pictures illustrate sample tests and their answers.

<image> <image>

Here is a reference code to solve this task. You can use this to help you genereate cases or validate the solution.
```python
#include <bits/stdc++.h>
using namespace std;
bool bit(int n, int i) { return (n >> i) & 1; }
int ceil(int a, int b) { return ceil(((long double)a) / b); }
int faltu;
const int mod = 1e9 + 7;
const long long inf = 4e18;
const long long ninf = -inf;
const int imax = 2e9 + 100;
const int maxn = 1e6 + 100;
int n, m;
vector<int> g[maxn];
vector<int> save;
bool mark[maxn], mark1[maxn];
int main() {
  ios_base::sync_with_stdio(0);
  ;
  time_t t1, t2;
  t1 = clock();
  srand(time(0));
  cin >> n >> m;
  for (int i = 0; i < m; i++) {
    int a, b;
    cin >> a >> b;
    g[a].push_back(b);
  }
  for (int i = 1; i <= n; i++) {
    if (!mark[i]) {
      mark[i] = true;
      save.push_back(i);
      for (int j : g[i]) {
        mark[j] = true;
      }
    }
  }
  reverse(save.begin(), save.end());
  vector<int> ans;
  for (int i : save) {
    if (!mark1[i]) {
      ans.push_back(i);
      for (int j : g[i]) {
        mark1[j] = true;
      }
    }
  }
  cout << ans.size() << endl;
  for (int i : ans) {
    cout << i << ' ';
  }
  t2 = clock();
  cerr << \"time taken: \" << t2 - t1 << endl;
  return 0;
}
```


请完成上述谜题的训练场环境类实现，包括所有必要的方法。
"""

from bootcamp import Basebootcamp
import json
import random
import re

from bootcamp import Basebootcamp

class Esergeysproblembootcamp(Basebootcamp):
    def __init__(self, **params):
        super().__init__()
        self.n = params.get('n', 5)
        self.m = params.get('m', 4)
        self.seed = params.get('seed', 42)
        random.seed(self.seed)

    def case_generator(self):
        n = self.n
        m = self.m
        edges = set()
        while len(edges) < m:
            a = random.randint(1, n)
            b = random.randint(1, n)
            if a != b:
                edges.add((a, b))
        edges = list(edges)
        
        mark = [False] * (n + 1)
        save = []
        for i in range(1, n+1):
            if not mark[i]:
                mark[i] = True
                save.append(i)
                for a, b in edges:
                    if a == i:
                        if not mark[b]:
                            mark[b] = True
        save.reverse()
        mark1 = [False] * (n + 1)
        ans = []
        for i in save:
            if not mark1[i]:
                ans.append(i)
                for a, b in edges:
                    if a == i and not mark1[b]:
                        mark1[b] = True
        question_case = {
            'n': n,
            'm': m,
            'edges': edges,
            'correct_Q': ans
        }
        return question_case

    @staticmethod
    def prompt_func(question_case):
        n = question_case['n']
        m = question_case['m']
        edges = question_case['edges']
        prompt = "给定一个有向无环图，包含 {} 个顶点和 {} 条边。请找出满足以下条件的顶点集合 Q：\n".format(n, m)
        prompt += "1. Q中的任意两个顶点之间没有直接的有向边相连。\n"
        prompt += "2. 所有不在Q中的顶点，可以在最多两步内到达Q中的某个顶点。\n"
        prompt += "输入的边如下：\n"
        for a, b in edges:
            prompt += "  {} -> {}\n".format(a, b)
        prompt += "\n请输出Q集合的大小k，以及Q中的顶点，按升序排列。\n"
        prompt += "例如：\n4\n1 3 4 5\n"
        prompt += "请将答案放在[answer]标签中，例如：\n"
        prompt += "[answer]\n4\n1 3 4 5\n[/answer]\n"
        prompt += "你的答案："
        return prompt

    @staticmethod
    def extract_output(output):
        pattern = r'\[answer\](.*?)\[\/answer\]'
        matches = re.findall(pattern, output, re.DOTALL)
        if not matches:
            return None
        answer_content = matches[-1].strip()
        lines = answer_content.split('\n')
        if len(lines) < 2:
            return None
        try:
            k = int(lines[0].strip())
            q = list(map(int, lines[1].strip().split()))
            if len(q) != k:
                return None
            return q
        except:
            return None

    @classmethod
    def _verify_correction(cls, solution, identity):
        n = identity['n']
        edges = identity['edges']
        correct_Q = identity['correct_Q']
        if sorted(solution) == sorted(correct_Q):
            return True
        
        edge_set = set((a, b) for a, b in edges)
        Q = solution
        Q_set = set(Q)
        
        for i in range(len(Q)):
            for j in range(i+1, len(Q)):
                if (Q[i], Q[j]) in edge_set or (Q[j], Q[i]) in edge_set:
                    return False
        
        adj = [[] for _ in range(n+1)]
        for a, b in edges:
            adj[a].append(b)
        
        for z in range(1, n+1):
            if z not in Q_set:
                found = False
                for x in Q:
                    if (x, z) in edge_set:
                        found = True
                        break
                if not found:
                    for y in adj[z]:
                        for x in Q:
                            if (x, y) in edge_set:
                                found = True
                                break
                        if found:
                            break
                if not found:
                    return False
        return True