#include <bits/stdc++.h>
using namespace std;
using ll = long long;
const function<int(int, int)> minQ = [](int l, int r) { return min(l, r); };
template <typename T>
class LazySegmentTree {
  using func_t = function<T(T, T)>;
  const int n;
  const T id1, id2;
  func_t merge;
  func_t change;
  vector<T> data, lazy;
  int size(int n) {
    int res = 1;
    while (res < n) res <<= 1;
    return res;
  }
  void propa(int node) {
    if (lazy[node] == id2) return;
    if (node < n) {
      lazy[node * 2] = change(lazy[node * 2], lazy[node]);
      lazy[node * 2 + 1] = change(lazy[node * 2 + 1], lazy[node]);
    }
    data[node] = change(data[node], lazy[node]);
    lazy[node] = id2;
  }
  void suc(int l, int r, int node, int lb, int ub, T val) {
    if (ub <= l || r <= lb) return;
    propa(node);
    if (l <= lb && ub <= r) {
      lazy[node] = val;
      return;
    }
    int c = (lb + ub) / 2;
    suc(l, r, node * 2, lb, c, val);
    suc(l, r, node * 2 + 1, c, ub, val);
    data[node] = merge(change(data[node * 2], lazy[node * 2]),
                       change(data[node * 2 + 1], lazy[node * 2 + 1]));
  }
  T sub(int l, int r, int node, int lb, int ub) {
    if (ub <= l || r <= lb) return id1;
    propa(node);
    if (l <= lb && ub <= r) {
      return data[node];
    }
    int c = (lb + ub) / 2;
    return merge(sub(l, r, node * 2, lb, c), sub(l, r, node * 2 + 1, c, ub));
  }

 public:
  LazySegmentTree(int n_, T id1_, T id2_, func_t merge_, func_t change_)
      : n(size(n_)),
        id1(id1_),
        id2(id2_),
        merge(merge_),
        change(change_),
        data(n * 2, id1),
        lazy(n * 2, id2) {}
  void update(int l, int r, T val) { suc(l, r + 1, 1, 0, n, val); }
  T find(int l) {
    sub(l, l + 1, 1, 0, n);
    return data[l + n];
  }
};
template <typename T>
class SegmentTree {
  const int n;
  const T id;
  vector<T> data, data2;
  int size(int n) {
    int res = 1;
    while (res < n) res <<= 1;
    return res;
  }
  T sub(int l, int r, int node, int lb, int ub) {
    if (ub <= l || r <= lb) return id;
    if (l <= lb && ub <= r) {
      return data[node] + data2[node] * (ub - lb);
    }
    return data2[node] * (min(r, ub) - max(l, lb)) +
           sub(l, r, node * 2, lb, (lb + ub) / 2) +
           sub(l, r, node * 2 + 1, (lb + ub) / 2, ub);
  }
  void suc(int l, int r, int node, int lb, int ub, T val) {
    if (ub <= l || r <= lb) return;
    if (l <= lb && ub <= r) {
      data2[node] += val;
      return;
    }
    data[node] += val * (min(r, ub) - max(l, lb));
    suc(l, r, node * 2, lb, (lb + ub) / 2, val);
    suc(l, r, node * 2 + 1, (lb + ub) / 2, ub, val);
  }

 public:
  SegmentTree(int n_) : n(size(n_)), id(0), data(n * 2, id), data2(n * 2, id) {}
  void add(int l, int r, T val) { suc(l, r + 1, 1, 0, n, val); }
  T getSum(int l, int r) { return sub(l, r + 1, 1, 0, n); }
};
int main() {
  int N, K, T;
  cin >> N >> K >> T;
  LazySegmentTree<int> lst(N, 0, -2, minQ, [](int l, int r) {
    if (l == -2) return r;
    if (r == -2) return l;
    if (l == -1 || r == -1) return -1;
    return l < r ? r : -1;
  });
  SegmentTree<ll> st(N);
  for (int i = 0, l, r, x; i < T; i++) {
    cin >> l >> r >> x;
    l--;
    r--;
    lst.update(l, r, x);
    st.add(l, r, 1);
  }
  int res = 0;
  for (int i = 0; i < N; i++) {
    cout << ' ' << lst.find(i);
    if (lst.find(i) == K && st.getSum(i, i) == K) {
      res++;
    }
  }
  cout << endl;
  cout << res << endl;
  return 0;
}
