#include <bits/stdc++.h>

int32_t main() {
    std::ios_base::sync_with_stdio(false);
    std::cin.tie(nullptr);

    int n, m;
    std::cin >> n >> m;
    std::vector<std::array<int, 4>> input(m);
    for (auto& [l, r, k, val] : input) {
        std::cin >> l >> r >> k >> val;
        r++;
        k--;
    }

    const auto true_inp = input;

    auto check = [&](std::vector<int> ans) {
        bool fail = false;
        auto& input = true_inp;
        for (auto& [l, r, k, val] : input) {
            int sum = std::accumulate(ans.begin() + l, ans.begin() + r, 0);
            if (val == 0) {
                fail = fail || ((r - l) - sum <= k);
            } else {
                fail = fail || (sum < (r - l) - k);
            }
            if (fail) {
                break;
            }
        }
        return !fail;
    };

    if (n <= 18) {
        for (int mask = 0; mask < (1 << n); mask++) {
            std::vector<int> ans(n);
            for (int j = 0; j < n; j++) {
                ans[j] = (mask >> j) & 1;
            }
            if (check(ans)) {
                for (int i = 0; i < n; i++) {
                    std::cout << ans[i] << " \n"[i == n - 1];
                }
                return 0;
            }
        }
        std::cout << "-1\n";
        return 0;
    }

    std::vector<int> ans(n, -1);
    std::array<std::vector<int>, 3> prf;

    auto recalc = [&]() {
        for (int i = 0; i < 3; i++) {
            prf[i].assign(n + 1, 0);
            for (int j = 0; j < n; j++) {
                prf[i][j + 1] = prf[i][j] + (ans[j] == i - 1);
            }
        }
    };
    auto get = [&](int c, int l, int r) {
        return prf[c + 1][r] - prf[c + 1][l];
    };

    while (true) {
        recalc();

        bool fail = false;
        for (auto& [l, r, k, val] : input) {
            if (val == 0 && get(0, l, r) > k) {
                l = r = k = val = -1;
                continue;
            }
            if (val == 1 && get(1, l, r) >= (r - l - k)) {
                l = r = k = val = -1;
                continue;
            }

            if (get(-1, l, r) == 0) {
                std::cout << "-1\n";
                return 0;
            }
            if (val == 0 && k == r - l - 1 || val == 1 && k == 0) {
                for (int i = l; i < r; i++) {
                    if (ans[i] >= 0 && ans[i] != val) {
                        std::cout << "-1\n";
                        return 0;
                    }
                    assert(ans[i] == -1 || ans[i] == val);
                    ans[i] = val;
                }
                l = r = k = val = -1;
                fail = true;
                break;
            }
            assert(val == 0 && k == 0 || val == 1 && k == r - l - 1);
            if (get(-1, l, r) == 1) {
                int it = std::find(ans.begin() + l, ans.begin() + r, -1) - ans.begin();
                assert(it != r);

                ans[it] = val;
                l = r = k = val = -1;
                fail = true;
                break;
            }
        }
        input.erase(std::find(input.begin(), input.end(), std::array<int, 4>{-1, -1, -1, -1}), input.end());

        if (!fail) {
            for (auto& [l, r, k, val] : input) {
                assert(get(-1, l, r) >= 2);
            }
            for (int i = 0, c = 0; i < n; i++) {
                c += ans[i] == -1;
                if (ans[i] == -1) {
                    ans[i] = c % 2;
                }
            }

            // assert(check(ans));
            for (int i = 0; i < n; i++) {
                std::cout << ans[i] << " \n"[i == n - 1];
            }
            return 0;
        }
    }

    return 0;
}