#include <bits/stdc++.h>

using namespace std;

typedef long long ll;

typedef long long val_t;

const int N = 15000 + 10;

struct DSU {
    int Parent[N], Rank[N], Size[N], cnt;
    void init(int n) {
        for (int i = 1; i <= n; i++) {
            Parent[i] = i, Rank[i] = 0, Size[i] = 1;
        }
        cnt = n;
    }
    int find(int v) {
        if (Parent[v] == v) return v;
        else return Parent[v] = find(Parent[v]);
    }
    void unite(int u, int v) {
        u = find(u), v = find(v);
        if (u == v) return;
        if (Rank[u] < Rank[v]) swap(u, v);
        if (Rank[v] == Rank[u]) Rank[u]++;
        Parent[v] = u, cnt--;
        Size[u] += Size[v];
    }
};

struct Kosaraju {
    const int n;
    vector<vector<int>> g[2];
    vector<bool> used;
    vector<int> post;
    vector<vector<int>> comps;
    vector<int> id;
    Kosaraju(int _n) : n(_n) {
        g[0].resize(n + 1);
        g[1].resize(n + 1);
        used.resize(n + 1, false);
        id.resize(n + 1);
    }
    void add_edge(int u, int v) {
        g[0][u].push_back(v);
        g[1][v].push_back(u);
    }
    void dfs_inv(int v) {
        used[v] = true;
        for (int to : g[1][v]) {
            if (!used[to]) {
                dfs_inv(to);
            }
        }
        post.push_back(v);
    }
    void dfs(int v, vector<int>& comp) {
        used[v] = true;
        comp.push_back(v);
        for (int to: g[0][v]) {
            if (!used[to]) {
                dfs(to, comp);
            }
        }
    }
    const vector<vector<int>>& find_scc() {
        for (int i = 1; i <= n; i++) {
            used[i] = false;
        }
        for (int i = 1; i <= n; i++) {
            if (!used[i]) {
                dfs_inv(i);
            }
        }
        reverse(post.begin(), post.end());
        for (int i = 1; i <= n; i++) {
            used[i] = false;
        }
        for (int v : post) {
            if (!used[v]) {
                vector<int> comp;
                dfs(v, comp);
                comps.push_back(comp);
            }
        }
        reverse(comps.begin(), comps.end());
        // edges go from left to right
        for (int i = 0; i < comps.size(); i++) {
            for (int v : comps[i]) {
                id[v] = i + 1;
            }
        }
        return comps;
    }
};

const val_t inf = 1e18;

struct Edge {
    int s, e;
    val_t cap, flow;
    int id;
};

vector<int> g[N];
vector<Edge> edges;
int dist[N], ptr[N];
queue<int> q;
bool used[N];
int par[N];
vector<int> path;
vector<vector<int>> ans;

void add_edge(int s, int e, val_t cap, int id) {
    Edge forw = {s, e, cap, 0, id};
    Edge back = {e, s, 0, 0, -id};
    g[s].push_back(edges.size());
    edges.push_back(forw);
    g[e].push_back(edges.size());
    edges.push_back(back);
}

bool bfs(int src, int sink) {
    while (!q.empty()) q.pop();
    q.push(src);
    for (int i = 0; i < N; i++) dist[i] = -1;
    dist[src] = 0;
    while (!q.empty() && dist[sink] == -1) {
        int v = q.front();
        q.pop();
        for (int i = 0; i < g[v].size(); i++) {
            int id = g[v][i];
            int u = edges[id].e;
            if (dist[u] == -1 && edges[id].flow < edges[id].cap) {
                q.push(u);
                dist[u] = dist[v] + 1;
            }
        }
    }
    return dist[sink] != -1;
}

val_t dfs(int v, val_t flow, int sink) {
    if (!flow) return 0;
    if (v == sink) return flow;
    while (ptr[v] < g[v].size()) {
        int id = g[v][ptr[v]];
        int u = edges[id].e;
        if (dist[u] != dist[v] + 1) {
            ptr[v]++;
            continue;
        }
        val_t pushed = dfs(u, min(flow, edges[id].cap - edges[id].flow), sink);
        if (pushed) {
            edges[id].flow += pushed;
            edges[id ^ 1].flow -= pushed;
            return pushed;
        }
        ptr[v]++;
    }
    return 0;
}

val_t max_flow(int src, int sink) {
    val_t flow = 0;
    while (true) {
        if (!bfs(src, sink)) break;
        for (int i = 0; i < N; i++) ptr[i] = 0;
        while (val_t pushed = dfs(src, inf, sink)) {
            flow += pushed;
        }
    }
    return flow;
}

void dfs1(int v) {
    used[v] = true;
    for (int id : g[v]) {
        int to = edges[id].e;
        if (edges[id].id > 0 && edges[id].flow > 0 && !used[to]) {
            par[to] = id;
            dfs1(to);
        }
    }
}

DSU dsu;

int col_comp[N];
int ans_col[N];

int main() {
    ios_base::sync_with_stdio(false);
    cin.tie(nullptr);
#ifdef LOCAL
    freopen("input.txt", "r", stdin);
#endif

    int n, m;
    cin >> n >> m;

    Kosaraju ksj(n);

    for (int i = 1; i <= m; i++) {
        int u, v;
        cin >> u >> v;
        ksj.add_edge(u, v);
    }
    ksj.find_scc();

    int k = ksj.comps.size();

    int src = 0;
    int trg = 2 * k + 1;
    for (int i = 1; i <= n; i++) {
        for (int j : ksj.g[0][i]) {
            if (ksj.id[i] != ksj.id[j]) {
                add_edge(ksj.id[i], ksj.id[j] + k, inf, 1);
            }
        }
    }
    for (int i = 1; i <= k; i++) {
        add_edge(src, i, 1, 1);
        add_edge(i + k, trg, 1, 1);
        add_edge(i + k, i, inf, 1);
    }

    max_flow(src, trg);

    while (true) {
        for (int i = 0; i <= 2 * k + 1; i++) {
            used[i] = false;
            par[i] = 0;
        }
        dfs1(src);
        if (!used[trg]) {
            break;
        }
        int v = trg;
        path.clear();
        while (v != src) {
            path.push_back(par[v]);
            v = edges[par[v]].s;
        }
        reverse(path.begin(), path.end());
        val_t mn = inf;
        for (int id : path) {
            mn = min(mn, edges[id].flow);
        }
        vector<int> cur;
        for (int id : path) {
            cur.push_back(edges[id].e);
            edges[id].flow -= mn;
        }
        cur.pop_back();
        ans.push_back(cur);
    }

    dsu.init(k);
    for (const auto& path : ans) {
        dsu.unite(path.front(), path.back() - k);
    }

    for (int i = 1, j = 0; i <= k; i++) {
        if (dsu.find(i) == i) {
            col_comp[i] = ++j;
        }
    }
    for (int i = 1; i <= k; i++) {
        col_comp[i] = col_comp[dsu.find(i)];
        for (int v : ksj.comps[i - 1]) {
            ans_col[v] = col_comp[i];
        }
    }
    for (int i = 1; i <= n; i++) {
        cout << ans_col[i] << " ";
    }
    cout << "\n";

#ifdef LOCAL
    cout << "\nTime elapsed: " << double(clock()) / CLOCKS_PER_SEC << " s.\n";
#endif
}