/*Sortare topologica
    Rezolvarea se bazeaza pe o parcurgere in adancime care calculeaza timpii de terminare pentru fiecare varf v. Pe masura ce
fiecare varf este terminat, este inserat in capul unei liste simplu inlantuite.
    Daca culoarea unui nod este ALB, inseamna ca acesta mai are noduri vecine care tb parcurse. Daca nodul nu mai are noduri
adiacente, inseamna ca acesta este terminal(la un moment dat), deci culoarea lui devine NEGRU si il adaugam in lista
Culoarea GRI cu care este initializat fiecare nod la fiecare DFS este folosita deoarece muchiile se pot repeta, deci pt a nu mai
parcurge inutil inca o data subarborele.*/

#include <iostream>
#include <fstream>
#include <vector>
#define DIM 50005
#define ALB 0
#define NEGRU 1
#define GRI 2

using namespace std;

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

struct node
{
    int info;
    node * next;
};

node * L[DIM];
node * lista;
vector <int> v;
bool color[DIM];

 void adaugare(int x, int y, node * L[])
 {
     node *p = new node;
     p->info = y;
     p->next = L[x];
     L[x] = p;
 }

void citire(int &n, int &m, node * L[])
{
    f>>n>>m;
    int x,y;
    for(int i=1; i<=m; i++)
    {
        f>>x>>y;
        adaugare(x,y,L);
    }
}

void push(int vf)
{
    node * p = new node;
    p->info = vf;
    p->next = lista;
    lista = p;
}

void DFS(int i)
{
    color[i] = GRI; //deoarece nodurile se pot repeta
    for(node *p = L[i]; p; p = p->next)
        if(color[p->info] == ALB)
            DFS(p->info);
    push(i);
    color[i] = NEGRU;
}

void TopSort(int n, node * L[])
{
    for(int i=1; i<=n; i++)
        if(color[i] == ALB)
            DFS(i);
}

void afisare(){
    //afisarea solutiei
    while(lista)
    {
        g<<lista->info<<" ";
        lista = lista->next;
    }
}

int main()
{
  int n,m;
  citire(n,m,L);
  TopSort(n,L);
  afisare();
}