#include <iostream>
#include <vector>
#include <queue>
#include <algorithm>
#include <map>
#include <ctime>
#include <random>
#include <cassert>

using namespace std;
using ll = long long;

const int mod = 998244353;

struct Edge {
    int nxt, flow, cap;
};

struct Flow {
    int n, total_flow;
    vector <vector <int>> G;
    vector <Edge> edge_list;
    int s, d;
    vector <int> prv;
    bool bfs() {
        queue <int> q;
        for (int i = 0; i < n; i++) {
            prv[i] = -1;
        }
        prv[s] = 0;
        q.push(s);
        while (!q.empty()) {
            int curr = q.front();
            q.pop();
            for (int edge_ind : G[curr]) {
                Edge curr_edge = edge_list[edge_ind];
                if (prv[curr_edge.nxt] == -1 && curr_edge.flow < curr_edge.cap) {
                    prv[curr_edge.nxt] = edge_ind;
                    q.push(curr_edge.nxt);
                }
            }
            if (prv[d] != -1) {
                return 1;
            }
        }
        return 0;
    }

    Flow(int _n) {
        n = _n;
        G.resize(n);
        prv.resize(n);
        s = 0;
        d = n - 1;
        total_flow = 0;
    }
    void addEdge(int x, int y, int cap) {
        edge_list.push_back({y, 0, cap});
        edge_list.push_back({x, 0, 0});
        G[x].push_back(edge_list.size() - 2);
        G[y].push_back(edge_list.size() - 1);
    }
    void pushFlow() {
        while (bfs()) {
            for (int edge_ind : G[d]) {
                int min_flow = 1e9;
                if (prv[edge_list[edge_ind].nxt] == -1) {
                    continue;
                }
                prv[d] = edge_ind^1;
                for (int nod = d; nod != s; nod = edge_list[prv[nod]^1].nxt) {
                    min_flow = min(min_flow, edge_list[prv[nod]].cap - edge_list[prv[nod]].flow);
                }
                for (int nod = d; nod != s; nod = edge_list[prv[nod]^1].nxt) {
                    edge_list[prv[nod]].flow += min_flow;
                    edge_list[prv[nod] ^ 1].flow -= min_flow;
                }
                total_flow += min_flow;
            }

        }
    }
    void dfsSolution(int nod, vector <int> &color, int c) {
        color[nod] = c;
        for (int edge_ind : G[2 * nod + 1]) {
            if (edge_list[edge_ind].flow != 1) {
                continue;
            }
            if (edge_list[edge_ind].nxt == 0 || edge_list[edge_ind].nxt == n - 1) {
                continue;
            }
            int nxt = edge_list[edge_ind].nxt / 2 - 1;
            if (!color[nxt]) {
                dfsSolution(nxt, color, c);
            }
        }
    }
    int getFlow() {
        return total_flow;
    }
};


struct Graph {
    int n, m, nrctc;
    vector <pair <int, int>> edges;
    vector <vector <int>> G, revG;
    vector <int> comp;
    void readGraph() {
        for (int i = 0; i < m; i++) {
            int x, y;
            cin >> x >> y;
            x--, y--;
            edges[i] = {x, y};
            G[x].push_back(y);
            revG[y].push_back(x);
        }
    }

    void dfs1(int nod, vector <int> &used, vector <int> &ordine) {
        used[nod] = 1;
        for (int nxt : G[nod]) {
            if (used[nxt]) {
                continue;
            }
            dfs1(nxt, used, ordine);
        }
        ordine.push_back(nod);
    }
    void dfs2(int nod, int c) {
        comp[nod] = c;
        for (int nxt : revG[nod]) {
            if (comp[nxt]) {
                continue;
            }
            dfs2(nxt, c);
        }
    }

    void computeScc() {
        vector <int> used(n, 0);
        vector <int> ordine;
        for (int i = 0; i < n; i++) {
            if (used[i]) {
                continue;
            }
            dfs1(i, used, ordine);
        }
        reverse(ordine.begin(), ordine.end());
        for (int i = 0; i < n; i++) {
            int nod = ordine[i];
            if (comp[nod]) {
                continue;
            }
            nrctc++;
            dfs2(nod, nrctc);
        }
    }

    vector <vector <int>> simplifyEdges() {
        vector <vector <int>> newG(nrctc, vector <int> ());
        for (auto [x, y] : edges) {
            if (comp[x] == comp[y]) {
                continue;
            }
            newG[comp[x] - 1].push_back(comp[y] - 1);
        }
        for (int i = 0; i < nrctc; i++) {
            sort(newG[i].begin(), newG[i].end());
            newG[i].erase(unique(newG[i].begin(), newG[i].end()), newG[i].end());
        }
        return newG;
    }

    void printSolution(vector <int> &color) {
        for (int i = 0; i < n; i++) {
            cout << color[comp[i] - 1] << ' ';
        }
    }

    Graph(int _n, int _m) {
        n = _n;
        m = _m;
        edges.resize(m);
        G.resize(n);
        revG.resize(n);
        comp.resize(n, 0);
        nrctc = 0;
    }
};

void solve() {
    int n, m;
    cin >> n >> m;
    Graph sccGraph(n, m);
    sccGraph.readGraph();
    sccGraph.computeScc();
    vector <vector <int>> G = sccGraph.simplifyEdges();
    n = sccGraph.nrctc;

    Flow flowGraph(2 * n + 2);
    for (int i = 0; i < n; i++) {
        flowGraph.addEdge(0, 2 * i + 1, 1);
        flowGraph.addEdge(2 * i + 2, 2 * n + 1, 1);
        flowGraph.addEdge(2 * i + 2, 2 * i + 1, 1);
        for (int x : G[i]) {
            flowGraph.addEdge(2 * i + 1, 2 * x + 2, 1);
        }
    }
    flowGraph.pushFlow();
    vector <int> color(n, 0);
    int cnt = 0;
    for (int i = 0; i < n; i++) {
        if (color[i]) {
            continue;
        }
        cnt++;
        flowGraph.dfsSolution(i, color, cnt);
    }
    sccGraph.printSolution(color);
}

signed main() {
#ifdef LOCAL
    freopen("test.in", "r", stdin);
    freopen("test.out", "w", stdout);
#endif // LOCAL
    ios_base::sync_with_stdio(false);
    cin.tie(0);
    cout.tie(0);
    int nrt = 1;
    //cin >> nrt;
    while (nrt--) {
        solve();
    }
    return 0;
}