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

int ctc;
vector<int> ctcv[100001];
vector<int> drum;

void dfs(int node, vector<int> L[], vector<int> &viz, vector<int> &order, bool pos)
{
    viz[node] = 1;
    if(!pos) ctcv[ctc].push_back(node);

    for(auto elem: L[node])
    {
        if(!viz[elem])
        {
            dfs(elem, L, viz, order, pos);
        }
        //else ctcv[ctc].push_back(elem);
    }

    if(pos)
        order.push_back(node);
}

void afis1(ofstream &fout)
{
    fout << ctc << '\n';
    for(int i = 1; i <= ctc; i ++)
    {
        for(auto j: ctcv[i])
            fout << j << ' ';
        fout << '\n';
    }
}

void afis2(ofstream &fout)
{
    fout << ctc << '\n';
    for(int i = 1; i <= ctc; i ++)
    {
        for(auto j: ctcv[i])
            fout << i << ' ';
    }
}

void kosaraju()
{
    ifstream fin("ctc.in");
    ofstream fout("ctc.out");

    int n, m;
    fin >> n >> m;

    vector<int> L[n + 1];
    vector<int> LT[n + 1];
    vector<int> viz(n + 1, 0);

    vector<int> order;

    for(int i = 1; i <= m; i ++)
    {
        int x, y;
        fin >> x >> y;

        L[x].push_back(y);
        LT[y].push_back(x);
    }

    for(int i = 1; i <= n; i ++)
        if(viz[i] == 0) dfs(i, L, viz, order, true);

    for(int i = 1; i <= n; i ++) viz[i] = 0;

    reverse(order.begin(), order.end());

    for(auto i: order)
    {
        if(viz[i] == 0)
        {
            ctc ++;
            dfs(i, LT, viz, order, false);
        }
    }

    //afis1(fout);

    afis2(fout);
}

void dfs2(int node, vector<int> L[], vector<int>& viz, bool &pos, int parent)
{
    viz[node] = 1;
    if(!pos) return;

    for(auto elem: L[node])
    {
        if(!pos) break;
        if(viz[elem] == 0)
            dfs2(elem, L, viz, pos, node);
        else 
        {
            if(parent != elem)
            {
                pos = false;
                drum.push_back(elem);
                break;
            }
        }
    }

    drum.push_back(node); 
}

void detectare_ciclu()
{
    int n, m;

    cin >> n >> m;

    vector<int> L[n + 1];

    for(int i = 1; i <= m; i ++)
    {
        int x, y;
        cin >> x >> y;

        L[x].push_back(y);
        L[y].push_back(x);
    }

    vector<int> viz(n + 1, 0);
    bool pos = true;

    for(int i = 1; i <= n; i ++)
    {
        if(viz[i] == 0)
            dfs2(i, L, viz, pos, 0);
    }

    if(pos) cout << "IMPOSSIBLE";
    else{
        cout << drum.size() << '\n';
        for(auto d: drum)
            cout << d << ' ';
    }
}

void dfs3(int node, vector<int> L[], vector<int> &viz, ofstream& fout)
{
    viz[node] = 1;

    fout << node << ' ';

    for(auto elem: L[node])
    {
        if(viz[elem] == 0)
        {
            dfs3(elem, L, viz, fout);
        }
    }

}


void sortare_topologica()
{
    ifstream fin("sortaret.in");
    ofstream fout("sortaret.out");

    int n, m;

    fin >> n >> m;

    vector<int> L[n + 1];

    for(int i = 1; i <= n; i ++)
    {
        int x, y;

        fin >> x >> y;

        L[x].push_back(y);
    }

    for(int i = 1; i <= n; i ++)
        L[i].erase(unique(L[i].begin(), L[i].end()), L[i].end());

    int l_min = 1e9, node;

    for(int i = 1; i <= n; i ++)
    {
        if(L[i].size() < l_min)
        {
            l_min = L[i].size();
            node = i;
        }
    }

    vector<int> viz(n + 1, 0);

    dfs3(1, L, viz, fout);

}

int main()
{
    sortare_topologica();
    return 0;
}