#include <bits/stdc++.h>
using namespace std;
typedef long long ll;
typedef pair<int, int> pii;
typedef pair<ll, ll> pll;
#define X first
#define Y second
#define ALL(v) v.begin(), v.end()
#define pb push_back
#define SZ(a) ((int)a.size())

const int N = 7000;

bitset<N> G[N], nG[N], disG[N], vis, first;

struct SCC {
    int low[N], dfn[N], bln[N], n, Time, nScc;
    bool instack[N];
    vector<int> st;
    vector<int> _G[N], SCC[N];
    void init(int _n) {
        n = _n;
    }
    void add_edge(int a, int b) {
        _G[a].pb(b);
    }
    void dfs(int u) {
        dfn[u] = low[u] = ++Time;
        instack[u] = 1, st.pb(u);
        for (int i : _G[u])
            if (!dfn[i])
                dfs(i), low[u] = min(low[i], low[u]);
            else if (instack[i] && dfn[i] < dfn[u])
                low[u] = min(low[u], dfn[i]);
        if (low[u] == dfn[u]) {
            int tmp;
            do {
                tmp = st.back(), st.pop_back();
                instack[tmp] = 0, bln[tmp] = nScc;
            } while (tmp != u);
            ++nScc;
        }
    }
    void solve() {
        for (int i = 0; i < n; ++i)
            if (!dfn[i]) dfs(i);
        for (int i = 0; i < n; ++i)
            SCC[bln[i]].pb(i);
        for (int i = 0; i < nScc; ++i)
            for (int j : SCC[i])
                for (int k : _G[j])
                    if (bln[k] != i) {
                        G[i][bln[k]] = 1;
                        G[i] |= G[bln[k]];
                    }
    }
} scc;

int dis[N], cur[N], done[N];
int rgt[N], lft[N];

int dfs(int u) {
    for (int &i = cur[u]; i < scc.nScc;) {
        int v = i;
        i = nG[u]._Find_next(i);
        if (!~lft[v] || (!done[lft[v]] && dfs(lft[v]))) {
            rgt[u] = v;
            lft[v] = u;
            return 1;
        }
    }
    done[u] = 1;
    return 0;
}

bool bfs() {
    fill(dis, dis + scc.nScc, -1);
    queue<int> q;
    for (int i = first._Find_first(); i < scc.nScc; i = first._Find_next(i))
        q.push(i), dis[i] = 0;
    for (int i = 0; i < scc.nScc; ++i)
        disG[i].reset(), vis[i] = 1;
    int flag = 0;
    while (!q.empty()) {
        int u = q.front();
        q.pop();
        auto nw = G[u] & vis;
        for (int i = nw._Find_first(); i < scc.nScc; i = nw._Find_next(i)) {
            disG[dis[u]][i] = 1, vis[i] = 0;
            if (!~lft[i]) flag = 1;
            else q.push(lft[i]), dis[lft[i]] = dis[u] + 1;
        }
    }
    return flag;
}

int solve() {
    int ans = 0;
    for (int i = 0; i < scc.nScc; ++i)
        first[i] = 1, lft[i] = rgt[i] = -1;
    while (bfs()) {
        for (int i = 0; i < scc.nScc; ++i)
            if (~dis[i])
                nG[i] = G[i] & disG[dis[i]];
            else
                nG[i].reset();
        for (int i = 0; i < scc.nScc; ++i)
            cur[i] = nG[i]._Find_first(), done[i] = 0;
        for (int i = first._Find_first(); i < scc.nScc; i = first._Find_next(i))
            if (!done[i] && dfs(i))
                ++ans, first[i] = 0; 
    }
    return ans;
}

int clr[N];

int main() {
    ios::sync_with_stdio(0), cin.tie(0);
    int n, m;
    cin >> n >> m;
    scc.init(n);
    while (m--) {
        int a, b;
        cin >> a >> b;
        scc.add_edge(a - 1, b - 1);
    }
    scc.solve();
    
    int ans = scc.nScc - solve(), c = 0;
    for (int i = 0; i < scc.nScc; ++i)
        if (!~lft[i]) {
            ++c;
            for (int x = i; ~x; x = rgt[x])
                clr[x] = c;
        }
    assert(ans == c);
    for (int i = 0; i < n; ++i)
        cout << clr[scc.bln[i]] << " \n"[i + 1 == n];
}