#include <vector>
#include <iostream>
using namespace std;

const int MOD = 986802277;

class modint {
private:
	int x;
public:
	modint() : x(0) {}
	modint(long long x_) : x(x_ >= 0 ? x_ % MOD : (x_ + 1) % MOD + (MOD - 1)) {}
	int val() const { return x; }
	modint& operator+=(const modint& m) { x = (x + m.x) % MOD; return *this; }
	modint& operator-=(const modint& m) { x = (x - m.x + MOD) % MOD; return *this; }
	modint& operator*=(const modint& m) { x = 1LL * x * m.x % MOD; return *this; }
	modint operator+(const modint& m) const { return modint(*this) += m; }
	modint operator-(const modint& m) const { return modint(*this) -= m; }
	modint operator*(const modint& m) const { return modint(*this) *= m; }
	modint pow(long long b) const {
		modint res(1), a(*this);
		while (b) {
			if (b & 1) {
				res *= a;
			}
			a *= a;
			b >>= 1;
		}
		return res;
	}
	modint inv() const { return pow(MOD - 2); }
};

#include <string>

string to_string(const vector<int>& arr) {
	string res = "[";
	for (int i = 0; i < int(arr.size()); i++) {
		if (i != 0) {
			res += ", ";
		}
		res += to_string(arr[i]);
	}
	res += "]";
	return res;
}

string to_string(const vector<modint>& arr) {
	string res = "[";
	for (int i = 0; i < int(arr.size()); i++) {
		if (i != 0) {
			res += ", ";
		}
		res += to_string(arr[i].val());
	}
	res += "]";
	return res;
}

int main() {
	// step #1. input
	cin.tie(nullptr);
	ios::sync_with_stdio(false);
	int N, M;
	cin >> N >> M;
	vector<int> A(M), B(M);
	for (int i = 0; i < M; i++) {
		cin >> A[i] >> B[i];
		A[i]--; B[i]--;
	}
	
	// step #2. initialize
	vector<int> col(2 * N), g(2 * N), c0(2 * N), c1(2 * N);
	for (int i = 0; i < 2 * N; i++) {
		col[i] = 0;
		g[i] = i;
		c0[i] = 1;
		c1[i] = 0;
	}

	// step #3. dynamic programming
	int sum = 0;
	vector<modint> dp(2 * N + 1);
	dp[0] = 1;
	auto add = [&](int x) -> void {
		if (x == 0) {
			return;
		}
		for (int i = sum; i >= 0; i--) {
			dp[i + x] += dp[i];
		}
		sum += x;
	};
	auto rollback = [&](int x) -> void {
		if (x == 0) {
			return;
		}
		sum -= x;
		for (int i = 0; i <= sum; i++) {
			dp[i + x] -= dp[i];
		}
	};
	for (int i = 0; i < 2 * N; i++) {
		add(1);
	}

	// step #4. processing
	for (int i = M - 1; i >= 0; i--) {
		if (g[A[i]] == g[B[i]]) {
			continue;
		}
		int ga = g[A[i]], gb = g[B[i]];
		int da = c0[ga] - c1[ga];
		int db = c0[gb] - c1[gb];
		if (da < db) {
			swap(A[i], B[i]);
			swap(ga, gb);
			swap(da, db);
		}
		int f = int(col[A[i]] == col[B[i]]);
		rollback(da);
		rollback(db);
		add(f == 0 ? da + db : da - db);
		if (dp[sum / 2].val() != 0) {
			for (int j = 0; j < 2 * N; j++) {
				if (g[j] == gb) {
					g[j] = ga;
					col[j] ^= f;
				}
			}
			if (f == 0) {
				c0[ga] += c0[gb];
				c1[ga] += c1[gb];
			} else {
				c0[ga] += c1[gb];
				c1[ga] += c0[gb];
			}
		} else {
			rollback(f == 0 ? da + db : da - db);
			rollback(f == 0 ? da - db : da + db);
			for (int j = 0; j < 2 * N; j++) {
				if (g[j] == gb) {
					g[j] = ga;
					col[j] ^= f ^ 1;
				}
			}
			if (f == 1) {
				c0[ga] += c0[gb];
				c1[ga] += c1[gb];
			} else {
				c0[ga] += c1[gb];
				c1[ga] += c0[gb];
			}
		}
	}

	// step #5. output
	for (int i = 0; i < 2 * N; i++) {
		cout << col[i];
	}
	cout << endl;

	return 0;
}