#include <bits/stdc++.h>

using namespace std;

typedef long long ll;

const int N = 7e3 + 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 HopcroftKarp {
    bitset<N> adj_left[N];
    int matchL[N] = {};
    int matchR[N] = {};
    int root[N], prev[N], qq[N];

    void add_edge(int u, int v) {
        adj_left[u][v] = true;
    }
    void init(int L, int R) {
        for (int i = 1; i <= L; i++) {
            adj_left[i].reset();
            matchL[i] = 0;
        }
        for (int i = 1; i <= R; i++) {
            matchR[i] = 0;
        }
    }
    void init_matching(int L, int R) {
        for (int i = 1; i <= L; i++) {
            matchL[i] = 0;
        }
        for (int i = 1; i <= R; i++) {
            matchR[i] = 0;
        }
    }
    int maxmatching(int L, int R) {
        int sz = 0;
        for (bool updated = true; updated; ) {
            updated = false;
            for (int i = 1; i <= L; i++) {
                root[i] = -1;
                prev[i] = -1;
                qq[i] = 0;
            }
            int qi = 0, qj = 0;
            for (int i = 1; i <= L; i++) {
                if (matchL[i] == 0) {
                    qq[qj++] = i, root[i] = i, prev[i] = i;
                }
            }
            while (qi < qj) {
                int u = qq[qi++];
                if (matchL[root[u]] != 0) {
                    continue;
                }
                for (int v = adj_left[u]._Find_first(); v <= R; v = adj_left[u]._Find_next(v)) {
                    if (matchR[v] == 0) {
                        while (v != 0) {
                            matchR[v] = u, swap(matchL[u], v), u = prev[u];
                        }
                        updated = true;
                        sz++;
                        break;
                    }
                    if (prev[matchR[v]] == -1) {
                        v = matchR[v], prev[v] = u, root[v] = root[u], qq[qj++] = v;
                    }
                }
            }
        }
        return sz;
    }
};

DSU dsu;
HopcroftKarp hk;

vector<int> g[2][N];
bool used[N];
vector<int> post;
vector<vector<int>> comps;
int id[N];
int col_comp[N];
int ans[N];

vector<int> gr[N];
bitset<N> dp[N];

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);
        }
    }
}

void Kosaraju(int n) {
    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());
    for (int i = 0; i < comps.size(); i++) {
        for (int v : comps[i]) {
            id[v] = i + 1;
        }
    }
    // edges go from left to right
}

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;
    for (int i = 1; i <= m; i++) {
        int u, v;
        cin >> u >> v;
        add_edge(u, v);
    }
    Kosaraju(n);
    int k = comps.size();
    for (int i = 1; i <= n; i++) {
        for (int j : g[0][i]) {
            if (id[i] != id[j]) {
                gr[id[i]].push_back(id[j]);
            }
        }
    }

    for (int i = k; i >= 1; i--) {
        for (int j : gr[i]) {
            dp[i] |= dp[j];
            dp[i][j] = true;
        }
    }
    for (int i = 1; i <= k; i++) {
        hk.adj_left[i] = dp[i];
    }

    hk.maxmatching(k, k);
    dsu.init(k);
    for (int i = 1; i <= k; i++) {
        if (hk.matchL[i]) {
            dsu.unite(i, hk.matchL[i]);
        }
    }
    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 : comps[i - 1]) {
            ans[v] = col_comp[i];
        }
    }
    for (int i = 1; i <= n; i++) {
        cout << ans[i] << " ";
    }
    cout << "\n";

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