//#pragma GCC optimize("Ofast", "unroll-loops")
//#pragma GCC target("sse", "sse2", "sse3", "ssse3", "sse4")

#ifdef __APPLE__
#include <iostream>
#include <cmath>
#include <algorithm>
#include <stdio.h>
#include <cstdint>
#include <cstring>
#include <string>
#include <cstdlib>
#include <vector>
#include <bitset>
#include <map>
#include <queue>
#include <ctime>
#include <stack>
#include <set>
#include <list>
#include <random>
#include <deque>
#include <functional>
#include <iomanip>
#include <sstream>
#include <fstream>
#include <complex>
#include <numeric>
#include <cassert>
#include <array>
#include <tuple>
#include <unordered_map>
#include <unordered_set>
#include <thread>
#else
#include <bits/stdc++.h>
#endif

#define all(a) a.begin(),a.end()
#define len(a) (int)(a.size())
#define mp make_pair
#define pb push_back
#define fir first
#define sec second
#define fi first
#define se second

using namespace std;

typedef pair<int, int> pii;
typedef long long ll;
typedef long double ld;

template<typename T>
bool umin(T &a, T b) {
    if (b < a) {
        a = b;
        return true;
    }
    return false;
}
template<typename T>
bool umax(T &a, T b) {
    if (a < b) {
        a = b;
        return true;
    }
    return false;
}

#if __APPLE__
#define D for (bool _FLAG = true; _FLAG; _FLAG = false)
#define LOG(...) print(#__VA_ARGS__" ::", __VA_ARGS__) << endl
template <class ...Ts> auto &print(Ts ...ts) { return ((cerr << ts << " "), ...); }
#else
#define D while (false)
#define LOG(...)
#endif

const int max_n = 7077, inf = 1000111222;

int N;
int used[max_n], nxt[max_n], pr[max_n];
bool f[max_n][max_n];

bool try_khun(int v) {
    if (used[v]) {
        return false;
    }
    used[v] = 1;
    for (int to = 0; to < N; ++to) {
        if (f[v][to] && pr[to] == -1) {
            pr[to] = v;
            nxt[v] = to;
            return true;
        }
    }
    for (int to = 0; to < N; ++to) {
        if (f[v][to] && try_khun(pr[to])) {
            pr[to] = v;
            nxt[v] = to;
            return true;
        }
    }
    return false;
}

vector<vector<int>> minimum_path_cover(int n) {
    memset(nxt, -1, sizeof(nxt));
    memset(pr, -1, sizeof(pr));
    N = n;
    for (int run = 1; run; ) {
        run = 0;
        ::memset(used, 0, sizeof(used));
        for (int i = 0; i < n; ++i) {
            if (nxt[i] == -1 && try_khun(i)) {
                run = 1;
            }
        }
    }
    vector<char> is_start(n, 1);
    for (int i = 0; i < n; ++i) {
//        cout << nxt[i] << endl;
        if (nxt[i] == -1) {
            continue;
        }
        is_start[nxt[i]] = 0;
    }
    vector<vector<int>> paths;
    for (int i = 0; i < n; ++i) {
        if (is_start[i]) {
            vector<int> path;
            for (int v = i; v != -1; v = nxt[v]) {
                path.push_back(v);
            }
            paths.push_back(path);
        }
    }
    return paths;
}

int n, m, pos_in_order[max_n];
vector<int> g[max_n], order;

void dfs(int v) {
    used[v] = 1;
    for (int to : g[v]) {
        if (!used[to]) {
            dfs(to);
        }
    }
    order.push_back(v);
}

void dfs2(int v, bool f[]) {
    f[pos_in_order[v]] = 1;
    for (int to : g[v]) {
        if (!f[pos_in_order[to]]) {
            dfs2(to, f);
        }
    }
}

int main() {
//    freopen("input_m.txt", "r", stdin);
//    freopen("input_m.txt", "w", stdout);

    ios_base::sync_with_stdio(0);
    cin.tie(0);

    if (0) {
        n = m = 7000;
        for (int i = 0; i < m; ++i) {
            int u = rand() % n;
            int v = rand() % n;
            u = i;
            v = (i + 1) % m;
            g[u].push_back(v);
        }
    } else {
        cin >> n >> m;
        while (m--) {
            int u, v;
            cin >> u >> v;
            --u;
            --v;
            g[u].push_back(v);
        }
    }
    for (int i = 0; i < n; ++i) {
        if (!used[i]) {
            dfs(i);
        }
    }
    reverse(order.begin(), order.end());
    for (int i = 0; i < order.size(); ++i) {
        pos_in_order[order[i]] = i;
    }
    for (int i = 0; i < order.size(); ++i) {
        assert(pos_in_order[order[i]] == i);
        dfs2(order[i], f[i]);
    }
    for (int i = 0; i < n; ++i) {
        ::memset(f[i], 0, i + 1);
    }
    if (0) {
        for (int i = 0; i < n; ++i) {
            for (int j = 0; j < n; ++j) {
                cout << f[i][j];
            }
            cout << endl;
        }
    }
    auto paths = minimum_path_cover(n);
    vector<int> ans(n);
    int id = 0;
    for (auto path : paths) {
        ++id;
        for (int v : path) {
            ans[order[v]] = id;
        }
    }
    for (int i = 0; i < n; ++i) {
        cout << ans[i] << " ";
    }
    cout << "\n";
}