#include <bits/stdc++.h>
using namespace std;

#ifndef LOCAL
#pragma GCC optimize("O3")
#endif

#define fi first
#define se second
#define pii pair<int,int>
#define mp make_pair
#define endl '\n'
#define sp <<" "<<
#define eb emplace_back
#define MOD 1000000007
#define gcd(a,b) __gcd(a,b)
#define lcm(a,b) (a*(b/gcd(a,b)))
#define all(a) (a).begin(),(a).end()
#define rall(a) (a).rbegin(),(a).rend()

using ll = long long;
#define vec vector

template <class T> void print_v(vector<T> &v) { cout << "{"; for (auto x : v) cout << x << ","; cout << "}\n"; }
template <class T> void print_m(vector<vector<T>> &m) { for (auto v : m) print_v(v); cout << '\n'; }

#define fora(a) for(auto e:a)
#define it(i,s,e) for(long long int i=s;i<e;i++)
#define ita(i,s,e) for(long long int i=s;i<=e;i++)
#define itr(i,e,s) for(long long int i=e-1;i>=s;i--)
#define urs(r...)typename decay<decltype(r)>::type
#define rep(i,n)for(urs(n)i=0;i<(n);++i)


int n, m;
vec<pair<ll, ll>> curr;
vec<pair<ll, ll>> next_batch;

const int UNDETERMINED = 0;
const int READY = 1;
const int NOT_READY = 2;


void set_status(pair<ll, ll> &s, int idx, int status) {
    switch (status) {
        case UNDETERMINED:
            s.fi &= ~((ll)1 << idx);
            s.se &= ~((ll)1 << idx);
            break;
        case READY:
            s.fi |= ((ll)1 << idx );
            s.se &= ~((ll)1 << idx);
            break;
        case NOT_READY:
            s.fi &= ~((ll) 1 << idx);
            s.se |= ((ll) 1 << idx );
            break;
    }
}

int determine_status(pair<ll, ll> s, int i) {
    if ((s.fi & ( (ll)1 << i )) >> i) return READY;
    if ((s.se & ( (ll)1 << i )) >> i) return NOT_READY;
    return UNDETERMINED;
}


void print_status(pair<ll, ll> &s) {
    cout << s.fi sp s.se << endl;
    rep (idx, n+10) {
        char c;
        switch (determine_status(s, idx)) {
            case UNDETERMINED:
            c = '?';
            break;
            case READY:
            c = '1';
            break;
            case NOT_READY:
            c = '0';
            break;
        }
        cout << c;
    }
    cout << endl;
}

void compute_continuations(pair<ll, ll> s, int a, int b) {
    int a_status = determine_status(s, a);
    int b_status = determine_status(s, b);
    auto s1 = s;
    
    switch ((a_status << 2) + b_status) {
    case (UNDETERMINED << 2) + UNDETERMINED:
        set_status(s, a, NOT_READY);
        set_status(s, b, NOT_READY);
        next_batch.eb(s);
        set_status(s1, a, READY);
        set_status(s1, b, READY);
        next_batch.eb(s1);
        break;
    case (UNDETERMINED << 2) + NOT_READY:
        set_status(s, a, NOT_READY);
        set_status(s, b, UNDETERMINED);
        next_batch.eb(s);
        break;
    case (NOT_READY << 2) + UNDETERMINED:
    case (NOT_READY << 2) + NOT_READY:
    case (NOT_READY << 2) + READY:
    case (READY << 2) + READY:
    case (UNDETERMINED << 2) + READY:
        next_batch.eb(s);
        break;
    case (READY << 2) + UNDETERMINED:
        set_status(s, a, UNDETERMINED);
        set_status(s, b, READY);
        next_batch.eb(s);
        break;
    case (READY << 2) + NOT_READY:
        set_status(s, a, NOT_READY);
        set_status(s, b, READY);
        next_batch.eb(s);
        break;
    }
}

vec<int> seg_counts(400);

void fill_counts_for_len(int max_len) {
    if (max_len > 0) {
        for (int l = 1; l<=max_len; l++) {
            seg_counts[l] += max_len - l + 1;
        }
    }
}

void calc_segments(pair<ll, ll> s) {
    //cout << s.fi sp s.se << endl;
    if (s.fi == 0) {
        int len = 0;
        for (int i=0; i<n; i++) {
            if (determine_status(s, i) == UNDETERMINED) {
                len++;
                continue;
            }

            // NOT_READY
            fill_counts_for_len(len);
            len = 0;
        }

        fill_counts_for_len(len);
    } else {
        //cout << s.fi << endl;
        int rightmost = log2((s.fi & ~ ( s.fi - 1 )));
        int leftmost = 63-__builtin_clzll(s.fi);
        int rightmost_poss = rightmost;
        int leftmost_poss = leftmost;

        for (int power = rightmost; power < leftmost; power++) {
            if (determine_status(s, power) == NOT_READY) return;
        }

        for (int power = rightmost-1; power >= 0; power--) {
            if (determine_status(s, power) == UNDETERMINED) {
                rightmost_poss = power;
            } else {
                break;
            }
        }

        for (int power = leftmost+1; power < n; power++) {
            if (determine_status(s, power) == UNDETERMINED) {
                leftmost_poss = power;
            } else {
                break;
            }
        }

        // print_status(s);
        // cout << s.fi << endl;
        // cout << "basic " << rightmost sp leftmost << endl;
        // cout << "poss " << rightmost_poss sp leftmost_poss << endl;

        int min_len = leftmost-rightmost + 1;
        int max_len = leftmost_poss-rightmost_poss + 1;

        for (int len=min_len; len<=max_len; len++) {
            int max_left = min(leftmost_poss, rightmost+len-1);
            int max_right = max(rightmost_poss, leftmost-len+1);

            int range_len = max_left - max_right + 1;

            // cout << len sp min_len sp max_len << endl;
            // cout << len sp  range_len-len+1 << endl;
            seg_counts[len] += range_len-len+1;
        }
    }

    // for (int i=1; i<=n; i++) {
    //     cout << seg_counts[i] <<  " ";
    // }
    // cout << endl;
}

void solve() {
    cin >> n >> m;

    curr.eb(mp(0,0));

    rep (_, m) {
        int a, b;
        cin >> a >> b;

        for (auto s: curr) {
            compute_continuations(s, a-1, b-1);
        }
        swap (curr, next_batch);
        next_batch.clear();
    }
    
    for (auto x: curr) {
        calc_segments(x);
    }

    for (int i=1; i<=n; i++) {
        cout << seg_counts[i] % 2 <<  " ";
    }
    cout << endl;
}

int main() {
    ios_base::sync_with_stdio(0);
    cin.tie(0);

    solve();

    return 0;
}