#include <iostream>
#include <bits/stdc++.h>

#define MAX_SIZE 100001

using namespace std;

//ifstream f("bfs.in");
//ofstream g("bfs.out");

ifstream fin("dfs.in");
ofstream gout("dfs.out");

ifstream f("sortaret.in");
ofstream g("sortaret.out");


class Graf
{
    int nrNoduri;
    int nrMuchii;
    int start;
    vector <int> adj[MAX_SIZE];


public:

    void citire_orientat();
    void citire_neorientat();
    void BFS();
    void DFS();
    void DFS_helper(int, vector <bool>&);
    void topological_sort();
    void topological_sort_helper(int, vector<bool>&, stack<int>&);



};

void Graf::citire_orientat()
{
    int first, second;

    f>>nrNoduri;
    f>>nrMuchii;
    ///f>>start;    ///comentat pt sortarea topologica

    for(int i = 0; i < nrMuchii; i++)
    {
        f>>first>>second;
        adj[first].push_back(second);
    }
}

void Graf::citire_neorientat()
{
    int first, second;
    fin>>nrNoduri>>nrMuchii;
    for(int i = 0; i < nrMuchii; i++)
    {
        fin>>first>>second;
        adj[first].push_back(second);
        adj[second].push_back(first);

    }
}

void Graf::BFS()
{
    queue <int> coada;
    coada.push(start);
    bool visited[MAX_SIZE] = {};
    visited[start] = 1;
    int cost[MAX_SIZE] = {};
    cost[start] = 0;

    int nodCrt;

    while (coada.size())
    {
        nodCrt = coada.front();

        for(int i = 0; i < adj[nodCrt].size(); i++)
        {
            if(!visited[adj[nodCrt][i]])
            {
                coada.push(adj[nodCrt][i]);
                cost[adj[nodCrt][i]] = cost[nodCrt] + 1;
                visited[adj[nodCrt][i]] = 1;
            }
        }
        coada.pop();
    }

    for(int i = 1; i <= nrNoduri; i++)
    {
        if(visited[i] == 1)
            g<<cost[i]<<" ";
        else
            g<<"-1 ";
    }


}

void Graf::DFS()
{
    vector <bool> visited(MAX_SIZE);
    int nrCompConexe = 0;

    for (int i = 1; i <= nrNoduri; i++)
    {
        if(!visited[i])
        {
            DFS_helper(i, visited);
            nrCompConexe += 1;
        }
    }

    gout<<nrCompConexe;

}


void Graf::DFS_helper(int s, vector<bool>& visited)
{
    visited[s] = 1;

    for (int i = 0; i < adj[s].size(); i++)
    {
        if(!visited[adj[s][i]])
            DFS_helper(adj[s][i], visited);
    }
}


///sortarea topologica este practic un DFS modificat
///in care daca ajungem intr-un nod care nu mai are vecini nevizitati,
///il trecem intr-o stiva, iar la final afisam stiva

void Graf::topological_sort()
{
    stack <int> stiva;
    vector <bool> visited(MAX_SIZE);

    for (int i = 1; i <= nrNoduri; i++)
    {
        if(!visited[i])
        {
            topological_sort_helper(i, visited, stiva);
        }
    }

    while(!stiva.empty())
    {
        g<<stiva.top()<<" ";
        stiva.pop();
    }
}

void Graf::topological_sort_helper(int s, vector<bool>& visited, stack <int>& stiva)
{
    visited[s] = 1;

    for (int i = 0; i < adj[s].size(); i++)
    {
        if(!visited[adj[s][i]])
            topological_sort_helper(adj[s][i], visited, stiva);
    }

    stiva.push(s);
}

int main()
{
    Graf G;

    //G.citire_orientat();
    //G.BFS();

    //G.citire_neorientat();
    //G.DFS();

    G.citire_orientat();
    G.topological_sort();

    return 0;
}