#include <bits/stdc++.h>
using namespace std;
const int maxn = 3e3 + 15, maxk = 55;
const int INF = 2e9 + 44;
int n, k;
map<long long, int> ID;
struct A {
  long long s, t;
  int c;
  int ode;
} a[maxn];
struct Edge {
  int from, to, cap, flow, cost;
  Edge(int u, int v, int c, int f, int w)
      : from(u), to(v), cap(c), flow(f), cost(w) {}
};
struct MCMF {
  int n, m;
  vector<Edge> edges;
  vector<int> G[maxn];
  int inq[maxn], d[maxn], p[maxn], a[maxn];
  void init(int n) {
    this->n = n;
    for (int i = 0; i < n; i++) G[i].clear();
    edges.clear();
  }
  int AddEdge(int from, int to, int cap, int cost) {
    edges.push_back(Edge(from, to, cap, 0, cost));
    edges.push_back(Edge(to, from, 0, 0, -cost));
    m = edges.size();
    G[from].push_back(m - 2);
    G[to].push_back(m - 1);
    return m - 2;
  }
  bool BellmanFord(int s, int t, int &flow, long long &cost) {
    for (int i = 0; i < n; i++) d[i] = INF;
    memset(inq, 0, sizeof(inq));
    d[s] = 0;
    inq[s] = 1;
    p[s] = 0;
    a[s] = INF;
    queue<int> Q;
    Q.push(s);
    while (!Q.empty()) {
      int u = Q.front();
      Q.pop();
      inq[u] = 0;
      for (int i = 0; i < G[u].size(); i++) {
        Edge &e = edges[G[u][i]];
        if (e.cap > e.flow && d[e.to] > d[u] + e.cost) {
          d[e.to] = d[u] + e.cost;
          p[e.to] = G[u][i];
          a[e.to] = min(a[u], e.cap - e.flow);
          if (!inq[e.to]) {
            Q.push(e.to);
            inq[e.to] = 1;
          }
        }
      }
    }
    if (d[t] == INF) return false;
    flow += a[t];
    cost += (long long)d[t] * (long long)a[t];
    for (int u = t; u != s; u = edges[p[u]].from) {
      edges[p[u]].flow += a[t];
      edges[p[u] ^ 1].flow -= a[t];
    }
    return true;
  }
  int MincostMaxflow(int s, int t, long long &cost) {
    int flow = 0;
    while (BellmanFord(s, t, flow, cost))
      ;
    for (int i = 0; i < m; i++) {
      Edge e = edges[i];
    }
    return flow;
  }
};
int main() {
  cin >> n >> k;
  MCMF solve;
  solve.n = maxn;
  solve.init(maxn);
  long long ode[2 * maxn];
  for (int i = 0; i < n; i++) {
    cin >> a[i].s >> a[i].t >> a[i].c;
    ode[2 * i] = a[i].s, ode[2 * i + 1] = a[i].s + a[i].t;
  }
  sort(ode, ode + 2 * n);
  int cnt = 0;
  for (int i = 0; i < 2 * n; i++) {
    if (ID.count(ode[i]) == 0) ID[ode[i]] = cnt++;
  }
  for (int i = 0; i < cnt - 1; i++) solve.AddEdge(i, i + 1, INF, 0);
  for (int i = 0; i < n; i++) {
    int id1 = ID[a[i].s], id2 = ID[a[i].t + a[i].s];
    a[i].ode = solve.AddEdge(id1, id2, 1, -a[i].c);
  }
  solve.AddEdge(cnt, 0, k, 0);
  solve.AddEdge(cnt - 1, cnt + 1, k, 0);
  long long cost = 0;
  int ans = solve.MincostMaxflow(cnt, cnt + 1, cost);
  for (int i = 0; i < n; i++) {
    int j = a[i].ode;
    Edge e = solve.edges[j];
    if (e.flow == 1)
      printf("1 ");
    else
      printf("0 ");
  }
}
