#include <bits/stdc++.h>

#define ff first
#define ss second
#define mp make_pair
#define pb push_back
using namespace std;
using ll = long long;
using ld = long double;


const int maxn = 10005, rootn = 105;
struct DSU {
    int n;
    vector<int> f;
    vector<int> ones, zeros;
    vector<vector<int>> comp;

    DSU (int n_): n(n_) {
        f.resize(n);
        ones.resize(n);
        comp.resize(n);
        zeros.resize(n);

        for (int i=0; i<n; ++i) {
            f[i] = i;
            ones[i] = 1;
            zeros[i] = 0;
            comp[i].pb(i);
        }
    }

    int find(int a) { return f[a] = f[a] == a ? a : find(f[a]); }
    int size(int a) { return comp[a].size(); }
    void merge(int a, int b) {
        a = find(a), b = find(b);
        if (a == b) return;

        if (size(a) < size(b)) swap(a, b);

        f[b] = a;
        ones[a] += ones[b];
        zeros[a] += zeros[b];

        while (comp[b].size()) {
            comp[a].pb(comp[b].back());
            comp[b].pop_back();
        }
    }
};
int main(){
	#ifdef LOCAL
		freopen("in","r", stdin);
		freopen("out","w",stdout);
	#endif
	ios_base::sync_with_stdio(0); cin.tie(0);

    int n, m; cin >> n >> m;
    
    vector<int> from, to, col(2*n);
    DSU dsu(2*n);

    for (int i=0; i+1<2*n; ++i) from.pb(i), to.pb(i+1);
    for(int i=0; i<m; ++i) {
        int u, v; cin >> u >> v;
        from.pb(u-1), to.pb(v-1);
    }

    set<int> comp;
    vector<pair<int, int>> process;

    auto go = [&](bitset<maxn>& dp, set<int>& a, vector<int>&& ig) -> void {
        dp[0] = 1;
        for(int u : a) {
            if(ig[0]==u || ig[1]==u) continue;

            dp = (dp<<(dsu.ones[u])) | (dp<<(dsu.zeros[u]));
        }
    };
    auto flip = [&](int& u) {
        for(int& w : dsu.comp[u]) col[w] ^=1;
        swap(dsu.ones[u], dsu.zeros[u]);
    };
    auto solve = [&]() -> void {
        set<int> other;
        for(int i=0; i<2*n; ++i) {
            if(!comp.count(dsu.find(i))) other.insert(dsu.find(i));
        }

        bitset<maxn> dpc, dpo;
        dpo.reset();
        go(dpo, other, {-1, -1});

        for(pair<int, int>& p : process) {
            int u = dsu.find(p.ff), v = dsu.find(p.ss);
            if (u == v) continue;

            dpc = dpo;
            go(dpc, comp, {u, v});
            int cnt = col[p.ff] == col[p.ss] ? dsu.zeros[u] + dsu.ones[v] : dsu.zeros[u] + dsu.zeros[v];

            if (n - cnt >=0 && dpc[n - cnt]) {
                if (col[p.ff] == col[p.ss]) flip(v);
            } else {
                if (col[p.ff] != col[p.ss]) flip(v);
            }

            dsu.merge(u, v);
            if (dsu.find(u) != u) comp.erase(u);
            if (dsu.find(v) != v) comp.erase(v);
        }

        comp.clear();
        process.clear();
    };

    while (from.size()) {
        int u=from.back(), v = to.back();
        from.pop_back(), to.pop_back();
        
        process.pb({u, v});
        comp.insert(dsu.find(u));
        comp.insert(dsu.find(v));

        if(comp.size()>=rootn) solve();
    }
    solve();

    for(int i=0; i<2*n; ++i) cout << col[i];
    cout << endl;
	return 0;
}