OI XXXIII - des

// https://szkopul.edu.pl/problemset/problem/a0qKqyZmbnu2gCu_P8LSmKtV/site/?key=statement

#include <bits/stdc++.h>

// #define GARY_DBG
#define GARY_LIB

constexpr int sizik = 1000 * 1001;

#define ar std::array

typedef std::vector<std::vector<int>> _kra;

int ans[sizik];

namespace seg_tree {

int d[4 * sizik];
std::pair<int, int> lazy[4 * sizik];

void push(int v, int tl, int tr) {
    if (lazy[v].first == 0 && lazy[v].second == 0) return;

    if (lazy[v].second) {
        d[2 * v] = lazy[v].first;
        lazy[2 * v].first = lazy[v].first;
        lazy[2 * v].second = 1;

        d[2 * v + 1] = lazy[v].first;
        lazy[2 * v + 1].first = lazy[v].first;
        lazy[2 * v + 1].second = 1;
    } else {
        d[2 * v] += lazy[v].first;
        if (lazy[2 * v].second) {
            lazy[2 * v].first += lazy[v].first;
        } else {
            lazy[2 * v].first += lazy[v].first;
        }

        d[2 * v + 1] += lazy[v].first;
        if (lazy[2 * v + 1].second) {
            lazy[2 * v + 1].first += lazy[v].first;
        } else {
            lazy[2 * v + 1].first += lazy[v].first;
        }
    }

    lazy[v] = {0, 0};
}

void update_add(int v, int tl, int tr, int l, int r) {
    if (l > r) return;
    if (l == tl && r == tr) {
        d[v]++;
        lazy[v].first++;
        return;
    }
    push(v, tl, tr);
    int tm = (tl + tr) / 2;
    update_add(2 * v, tl, tm, l, std::min(tm, r));
    update_add(2 * v + 1, tm + 1, tr, std::max(l, tm + 1), r);
    d[v] = std::max(d[2 * v], d[2 * v + 1]);
}

void update_set(int v, int tl, int tr, int l, int r) {
    if (l > r) return;
    if (l == tl && r == tr) {
        d[v] = 0;
        lazy[v].first = 0;
        lazy[v].second = 1;
        return;
    }
    push(v, tl, tr);
    int tm = (tl + tr) / 2;
    update_set(2 * v, tl, tm, l, std::min(tm, r));
    update_set(2 * v + 1, tm + 1, tr, std::max(l, tm + 1), r);
    d[v] = std::max(d[2 * v], d[2 * v + 1]);
}

int query(int v, int tl, int tr, int l, int r) {
    if (l > r) return 0;
    if (tl == l && r == tr) return d[v];
    push(v, tl, tr);
    int tm = (tl + tr) / 2;
    return std::max(query(2 * v, tl, tm, l, std::min(r, tm)), query(2 * v + 1, tm + 1, tr, std::max(l, tm + 1), r));
}

void print(int l, int r) {
    for (int i = l; i <= r; i++) {
        std::cout << d[i] << " ";
    }
    std::cout << '\n';
}

} // namespace seg_tree

void solve() {
    int n, m;
    std::cin >> n >> m;

    std::set<int> s;

    std::vector<ar<int, 3>> queries(m);

    std::vector<std::vector<std::pair<int, int>>> p(n);

    for (auto& [d, a, b] : queries) {
        std::cin >> d >> a >> b;
        d--;
        b--;
        s.insert(a);
        s.insert(b);
    }

    int cnt = 2;
    std::map<int, int> mp;
    for (const auto& x : s) {
        mp[x] = cnt++;
    }
    cnt++;

    for (auto& [d, a, b] : queries) {
        a = mp[a], b = mp[b];
        p[d].push_back({a, b});
    }
    for (auto& v : p) {
        std::sort(v.begin(), v.end());
    }

    seg_tree::update_set(1, 1, cnt, 1, cnt);

    std::vector<int> ans(n);
    for (int i = n - 1; i >= 0; i--) {
        int R = 0;
        for (const auto& [l, r] : p[i]) {
            seg_tree::update_set(1, 1, cnt, R + 1, l - 1);
            seg_tree::update_add(1, 1, cnt, l, r);
            R = r;
        }
        seg_tree::update_set(1, 1, cnt, R + 1, cnt);

        ans[i] = seg_tree::query(1, 1, cnt, 1, cnt);
    }

    for (int i = 0; i < n; i++) {
        std::cout << ans[i] << "\n";
    }
}

int32_t main() {
#ifndef GARY_DBG
    std::ios_base::sync_with_stdio(0);
    std::cin.tie(0);
    std::cout.tie(0);
#endif

    int t = 1;
    // std::cin >> t;

    for (; t > 0; t--) {
        solve();
    }

    return 0;
}