1. 1
2. 2
3. 3
4. 4
5. 5
6. 6
7. 7
8. 8
9. 9
10. 10
11. 11
12. 12
13. 13
14. 14
15. 15
16. 16
17. 17
18. 18
19. 19
20. 20
21. 21
22. 22
23. 23
24. 24
25. 25
26. 26
27. 27
28. 28
29. 29
30. 30
31. 31
32. 32
33. 33
34. 34
35. 35
36. 36
37. 37
38. 38
39. 39
40. 40
41. 41
42. 42
43. 43
44. 44
45. 45
46. 46
47. 47
48. 48
49. 49
50. 50
51. 51
52. 52
53. 53
54. 54
55. 55
56. 56
57. 57
58. 58
59. 59
60. 60
61. 61
62. 62
63. 63
64. 64
65. 65
66. 66

#include <bits/stdc++.h>
using namespace std;

int N, idx[100001];
bitset<100001> vis, ans;
vector<int> path;
unordered_set<int> G[100001];

void solve() {
	vis.reset();
	for (int i = 0; i < path.size() - 1; ++i) {
		G[path[i]].erase(path[i + 1]);
	}
	memset(idx, -1, sizeof idx);
	for (int i = 0; i < path.size(); ++i) idx[path[i]] = i;
	int m = 0;
	ans.set();
	for (int i = 0; i < path.size() - 1; ++i) {
		m = max(i + 1, m);
		queue<int> q;
		q.push(path[i]);
		while (q.size()) {
			int u = q.front();
			q.pop();
			if (vis[u]) continue;
			vis[u] = 1;
			if (u != path[i] && idx[u] != -1) {
				for (int j = m; j < idx[u]; ++j)
					ans[j] = 0;
				m = max(idx[u], m);
				continue;
			}			
			for (auto& v : G[u]) {
				if (!vis[v]) q.push(v);
			}
		}
	}
	vector<int> out;
	for (int i = 1; i < path.size() - 1; ++i)
		if (ans[i]) out.push_back(path[i]);
	sort(begin(out), end(out));
	cout << out.size() << '\n';
	for (auto& x : out) cout << x << '\n';
}

void dfs(int u) {
	vis[u] = 1;
	path.push_back(u);
	if (u == N) {
		solve();
		exit(0);
	}	
	for (auto& v : G[u]) {
		if (!vis[v]) dfs(v);
	}
	path.pop_back();
}

int main() {
	int M; cin >> N >> M;
	while (M--) {
		int a, b; cin >> a >> b;
		G[a].insert(b);
	}
	dfs(1);
}