#include <bits/stdc++.h>

using namespace std;

class TwoSat {
    private:
        int n;
        vector<vector<int>> rG, G, sccs;
        vector<int> ord, idx;
        vector<bool> vis, result;
        void dfs(int u) {
            vis[u] = true;
            for (int v: G[u])
                if (!vis[v]) dfs(v);
            ord.push_back(u);
        }
        void rdfs(int u) {
            vis[u] = false;
            idx[u] = sccs.size() - 1;
            sccs.back().push_back(u);
            for (int v: rG[u])
                if (vis[v]) rdfs(v);
        }
public:
        void init(int n_ ) {
            G.clear();
            G.resize(n = n_);
            rG.clear();
            rG.resize(n);
            sccs.clear();
            ord.clear();
            idx.resize(n);
            result.resize(n);
        }
        void add_edge(int u, int v) {
            G[u].push_back(v);
            rG[v].push_back(u);
        }

        bool solve() {
            vis.clear();
            vis.resize(n);
            for (int i = 0; i < n; i++)
                if (not vis[i])
                    dfs(i);
            reverse(ord.begin(), ord.end());
            for (int u: ord) {
                if (!vis[u]) continue;
                sccs.push_back(vector<int>());
                rdfs(u);
            }
            return true;
        }
        int get_idx(int u) {
            return idx[u];
        }
        int get_min_vertex(int sccid) {
            auto &v = sccs[sccid];
            return *min_element(v.begin(), v.end());
        }
        int get_count() {
            return sccs.size();
        }
} scc;

signed main() {
    cin.tie(nullptr) -> sync_with_stdio(false);
    int n, m;
    cin >> n >> m;
    scc.init(n);
    vector<pair<int,int>> es;
    for (int i = 0; i < m; i++) {
        int x, y;
        cin >> x >> y;
        --x, --y;
        es.emplace_back(x, y);
        scc.add_edge(x, y);
    }

    scc.solve();

    vector<int> ans;

    int k = scc.get_count();
    vector<int> deg(k);
    for (auto [x, y]: es) {
        x = scc.get_idx(x);
        y = scc.get_idx(y);
        if (x != y) ++deg[y];
    }

    // for (int i = 0; i < n; i++) {
    //     cerr << scc.get_idx(i) << ',';
    // }
    // cerr << endl;

    for (int j = 0; j < k; j++) {
        if (deg[j] == 0) {
            ans.push_back(scc.get_min_vertex(j));
        }
    }

    sort(ans.begin(), ans.end());
    for (int x: ans)
        cout << x + 1 << '\n';
}