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

using namespace std;

class graph
{
    // bitul 1 orientat sau neorientat, bitul 2 cost muchie
    enum input {orientat = 1, neorientat = 2, cu_cost = 4, fillLat = 8};
    struct muchie
    {
        int from, to, cost;
        muchie(int _from, int _to, int _cost = 1):
            from(_from), to(_to), cost(_cost)
            {

            }
    };
    int n,m;
    int* extraArgs = nullptr;

    vector<int>* la = nullptr;
    vector<int>* lat = nullptr;
    vector<pair<int,int>>* lac = nullptr;

    int* dist = nullptr;
    int* ids = nullptr;
    int* lowLink = nullptr;

    vector<int> topo;

    ifstream f;
    ofstream g;
public:
    void readData(string nume_fisier, input _tip_graf, vector<pair<int**, int>> initVecs = vector<pair<int**,int>>(), int _extra_args_count = 0);
    //////////////////////////////////////////////////////////////////////////////////
    void bfs();
    //////////////////////////////////////////////////////////////////////////////////
    void dfs();
    void dfsTopo(int from);
    //////////////////////////////////////////////////////////////////////////////////
    void ctc();
    void dfsCtc(int nod, vector<vector<int>>& cc);
    //////////////////////////////////////////////////////////////////////////////////
    void sortaret();
};

void graph::readData (string nume_fisier, input _tip_graf, vector<pair<int**, int>> initVecs, int _extra_args_count)
{
    f.open(nume_fisier);

    f >> n >> m;

    for (auto& per: initVecs)
    {
        int** p = per.first;
        int val = per.second;
        *p = new int[n+1];
        for (int i = 1; i <= n; i++)
            (*p)[i] = val;
    }

    if (_extra_args_count)
    {
        extraArgs = new int[_extra_args_count];
        for (int i = 0; i < _extra_args_count; i++)
            f >> extraArgs[i];
    }
    int x,y,c;

    if (_tip_graf & input::orientat)
    {
        if (_tip_graf & input::cu_cost)
        {
            lac = new vector<pair<int,int>>[n+1];
            for (int i = 1; i <= m; i++)
            {
                f >> x >> y >> c;
                lac[x].push_back({y,c});
            }
        }
        else
        {
            if (_tip_graf & input::fillLat)
            {
                la = new vector<int>[n+1];
                lat = new vector<int>[n+1];
                for (int i = 1; i <= m; i++)
                {
                    f >> x >> y;
                    // cout << x << ' ' << y << '\n';
                    la[x].push_back(y);
                    lat[y].push_back(x);
                }
            }
            else
            {
                la = new vector<int>[n+1];
                for (int i = 1; i <= m; i++)
                {
                    f >> x >> y;
                    la[x].push_back(y);
                }
            }
        }
    }
    else if (_tip_graf & input::neorientat)
    {
        if (_tip_graf & input::cu_cost)
        {
            lac = new vector<pair<int,int>>[n+1];
            for (int i = 1; i <= m; i++)
            {
                f >> x >> y >> c;
                lac[x].push_back({y,c});
                lac[y].push_back({x,c});
            }
        }
    }

    f.close();
}

void graph::bfs()
{
    ofstream g("bfs.out");
    readData("bfs.in", input::orientat, {{&dist, -1}}, 1);

    int start = extraArgs[0];

    queue<int> q;
    q.push(start);
    dist[start] = 0;

    while (q.size())
    {
        for (auto to: la[q.front()])
        {
            if (dist[to] == -1)
            {
                q.push(to);
                dist[to] = dist[q.front()] + 1;
            }
        }
        q.pop();
    }

    for (int i = 1; i <= n; i++)
        g << dist[i] << ' ';

    delete[] la;
    delete[] extraArgs;
    delete[] dist;
}

void graph::dfsTopo(int from)
{
    dist[from] = 1;
    for (auto to: la[from])
    {
        if (!dist[to])
            dfsTopo(to);
    }
    topo.push_back(from);
}

void graph::dfs()
{
    ofstream g("dfs.out");
    readData("dfs.in", input::neorientat, {{&dist, 0}});

    int cc = 0;
    for (int i = 1; i <= n; i++)
    {
        if (!dist[i])
        {
            dfsTopo(i);
            cc++;
        }
    }

    g << cc;

    delete[] la;
    delete[] dist;
}

void graph::dfsCtc(int nod, vector<vector<int>>& cc)
{
    dist[nod] = 1;
    cc[cc.size() - 1].push_back(nod);
    for (auto to: lat[nod])
    {
        if (!dist[to])
            dfsCtc(to, cc);
    }
}

void graph::ctc()
{
    ofstream g("ctc.out");
    readData("ctc.in", (input)(input::orientat | input::fillLat), {{&dist, 0}});

    for (int i = 1; i <= n; i++)
    {
        if (!dist[i])
            dfsTopo(i);
    }
    reverse(topo.begin(), topo.end());

    memset(dist, 0, sizeof(int) * (n+1));
    vector<vector<int>> cc;
    for (auto nod: topo)
    {
        if (!dist[nod])
        {
            cc.push_back(vector<int>());
            dfsCtc(nod, cc);
        }
    }

    g << cc.size() << '\n';
    for (auto& row: cc)
    {
        for (auto el: row)
            g << el << ' ';
        g << '\n';
    }

    delete[] dist;
    delete[] la;
    delete[] lat;
}

void graph::sortaret()
{
    ofstream g("sortaret.out");
    readData("sortaret.in", (input)(input::orientat), {{&dist, 0}});

    for (int i = 1; i <= n; i++)
    {
        if (!dist[i])
            dfsTopo(i);
    }
    reverse(topo.begin(), topo.end());

    for (auto el: topo)
        g << el << ' ';

    delete[] dist;
    delete[] la;
}

int main()
{
    graph g;
    g.sortaret();

    return 0;
}