#include <iostream>
#include <vector>
#include <string>
#include <stack>
#include <set>
#include <map>

#include "optimization.h"
#include <unordered_map>

#include <cassert>
#include <cstdio>
#include <algorithm>


using namespace std;
int n, m;
vector<bool> mark;
vector<int> comp;
vector<vector<int>> graph;
vector<int> order;
int cc = 0;

void dfs1(int v) {
    mark[v] = true;
    for (auto u: graph[v]) {
        if (!mark[u]) dfs1(u);
    }
    order.push_back(v);
}

void dfs2(int v, int cc) {
    comp[v] = cc;
    for (auto u: graph[v]) {
        if (comp[v] == -1) {
            dfs2(u, cc);
        }
    }
}

int main() {
    cin >> n >> m;
//    vector<bool> x((n+1)*2, 0);
    graph.resize((n + 1) * 2);
    for (int i = 0; i < m; i++) {
        int a, a_val, b, b_val;
        cin >> a >> a_val >> b >> b_val;
//        if (a_val == 1) {
//            graph[a * 2].push_back(b_val ? );
//        } else {
//            graph[a * 2 + 1].push_back(b);
//        }
//        if (b_val == 1) {
//            graph[b * 2].push_back(a);
//        } else {
//            graph[b * 2 + 1].push_back(a);
//        }
//        graph[a_val == 1 ? a*2 : a * 2 + 1].push_back(b_val ? b * 2 + 1 : 2 *b);
//        graph[b_val == 1 ? b*2 : b * 2 + 1].push_back(a_val ? a * 2 + 1 : 2 *a);
        graph[2 * a + 1 - a_val].push_back(2 * b + b_val);
        graph[2 * b + 1 - b_val].push_back(2 * a + a_val);
    }

    mark.resize(2 * (n + 1), false);
    for (int i = 1; i <= 2 * n; ++i) {
        if (!mark[i]) dfs1(i);
    }

    comp.resize(2 * (n + 1), -1);
    reverse(order.begin(), order.end());
    for (auto v: order) {
        if (comp[v] == -1) {
            dfs2(v, ++cc);
        }
    }

    for (int i = 1; i <= 2*n; i+=2) {
        cout << (comp[i + 1] > comp[i]);
    }
}