#include <bits/stdc++.h>
using namespace std;
class MinCostMaxFlowLongLong {
 public:
  class MinCostMaxFlowEdge {
   private:
    int destination_;
    long long capacity_;
    long long cost_;
    long long flow_;

   public:
    MinCostMaxFlowEdge(int destination, long long capacity, long long cost) {
      this->destination_ = destination;
      this->capacity_ = capacity;
      this->cost_ = cost;
      this->flow_ = 0L;
    }
    MinCostMaxFlowEdge(MinCostMaxFlowEdge& ref) {
      this->destination_ = ref.destination();
      this->capacity_ = ref.capacity();
      this->cost_ = ref.cost();
      this->flow_ = ref.flow();
    }
    int destination() { return destination_; }
    long long capacity() { return capacity_; }
    long long cost() { return cost_; }
    long long flow() { return flow_; }
    void setFlow(long long flow) { flow_ = flow; }
  };
  vector<vector<MinCostMaxFlowEdge*> > adj_;
  vector<long long> supply_;
  MinCostMaxFlowLongLong(int node_count) {
    supply_ = vector<long long>(node_count, 0LL);
    adj_ = vector<vector<MinCostMaxFlowEdge*> >(node_count,
                                                vector<MinCostMaxFlowEdge*>());
  }
  void addEdge(int from, int to, long long capacity, long long cost) {
    adj_[from].push_back(new MinCostMaxFlowEdge(to, capacity, cost));
  }
  void setSupply(int node, long long amount) { supply_[node] = amount; }
  long long solve(long long fail_value, long long kHuge = 2120120123LL) {
    int n = ((int)(supply_).size());
    vector<vector<MinCostMaxFlowEdge*> > adjcopy = adj_;
    for (int i = 0; i < ((int)(adj_).size()); ++i) {
      for (int j = 0; j < ((int)(adj_[i]).size()); ++j) {
        adjcopy[i][j] = new MinCostMaxFlowEdge(*(adj_[i][j]));
      }
    }
    vector<long long> supplycopy = supply_;
    for (int i = 0; i < n; ++i) {
      if (i > 0) {
        adjcopy[0].push_back(new MinCostMaxFlowEdge(i, kHuge, kHuge));
        adjcopy[i].push_back(new MinCostMaxFlowEdge(0, kHuge, kHuge));
      }
    }
    vector<vector<MinCostMaxFlowEdge*> > reverse_adj(
        n, vector<MinCostMaxFlowEdge*>());
    for (int i = 0; i < n; ++i) {
      for (int j = 0; j < ((int)(adjcopy[i]).size()); ++j) {
        reverse_adj[i].push_back(NULL);
      }
    }
    for (int i = 0; i < n; ++i) {
      for (int j = 0; j < ((int)(adjcopy[i]).size()); ++j) {
        if (reverse_adj[i][j] == NULL) {
          int destination = adjcopy[i][j]->destination();
          long long cost = adjcopy[i][j]->cost();
          MinCostMaxFlowEdge* new_edge = new MinCostMaxFlowEdge(i, 0, -cost);
          adjcopy[destination].push_back(new_edge);
          reverse_adj[destination].push_back(adjcopy[i][j]);
          reverse_adj[i][j] = new_edge;
        }
      }
    }
    vector<long long> pi(n, 0LL);
    for (int i = 0; i < n; ++i) {
      for (int j = 0; j < ((int)(adjcopy[i]).size()); ++j) {
        adjcopy[i][j]->setFlow(0);
      }
    }
    long long maximum_flow_at_a_time = -1;
    for (int i = 0; i < n; ++i) {
      maximum_flow_at_a_time = max(maximum_flow_at_a_time, supplycopy[i]);
      for (int j = 0; j < ((int)(adjcopy[i]).size()); ++j) {
        maximum_flow_at_a_time =
            max(maximum_flow_at_a_time, adjcopy[i][j]->capacity());
      }
    }
    long long delta = 1LL;
    while (delta < maximum_flow_at_a_time) delta *= 2LL;
    vector<int> pred(n, 0), pred_adj(n, 0);
    vector<long long> shortest(n, 0LL);
    set<pair<long long, int> > pq;
    while (delta >= 1LL) {
      for (int i = 0; i < n; ++i) {
        for (int j = 0; j < ((int)(adjcopy[i]).size()); ++j) {
          if (adjcopy[i][j]->capacity() - adjcopy[i][j]->flow() >= delta &&
              adjcopy[i][j]->cost() - pi[i] + pi[adjcopy[i][j]->destination()] <
                  0LL) {
            int destination = adjcopy[i][j]->destination();
            long long add_flow =
                adjcopy[i][j]->capacity() - adjcopy[i][j]->flow();
            supplycopy[i] -= add_flow;
            supplycopy[destination] += add_flow;
            adjcopy[i][j]->setFlow(adjcopy[i][j]->flow() + add_flow);
            reverse_adj[i][j]->setFlow(reverse_adj[i][j]->flow() - add_flow);
          }
        }
      }
      for (int i = 0; i < n; ++i) {
        while (supplycopy[i] >= delta) {
          for (int j = 0; j < n; ++j) {
            shortest[j] = -1LL;
          }
          shortest[i] = 0LL;
          pred[i] = -1;
          pq.insert(make_pair(0LL, i));
          while (!pq.empty()) {
            long long top_value = (*(pq.begin())).first;
            int node = (*(pq.begin())).second;
            pq.erase(pq.begin());
            if (shortest[node] < top_value) {
              continue;
            }
            for (int j = 0; j < ((int)(adjcopy[node]).size()); ++j) {
              if (adjcopy[node][j]->capacity() - adjcopy[node][j]->flow() >=
                  delta) {
                int destination = adjcopy[node][j]->destination();
                long long cost = top_value + adjcopy[node][j]->cost() -
                                 pi[node] + pi[destination];
                if (shortest[destination] == -1LL ||
                    shortest[destination] > cost) {
                  pred[destination] = node;
                  pred_adj[destination] = j;
                  shortest[destination] = cost;
                  pq.insert(make_pair(cost, destination));
                }
              }
            }
          }
          int def = -1;
          for (int j = 0; j < n; ++j) {
            if (supplycopy[j] < 0LL && shortest[j] != -1LL) {
              def = j;
              break;
            }
          }
          for (int j = 0; j < n; ++j) {
            if (shortest[j] != -1LL) {
              pi[j] = pi[j] - shortest[j] + shortest[def];
            }
          }
          supplycopy[def] += delta;
          supplycopy[i] -= delta;
          while (pred[def] != -1) {
            int previous = pred[def];
            adjcopy[previous][pred_adj[def]]->setFlow(
                adjcopy[previous][pred_adj[def]]->flow() + delta);
            reverse_adj[previous][pred_adj[def]]->setFlow(
                reverse_adj[previous][pred_adj[def]]->flow() - delta);
            def = previous;
          }
        }
      }
      delta /= 2LL;
    }
    bool feasible = true;
    for (int i = 0; i < n; ++i) {
      for (int j = ((int)(adj_[i]).size()); j < ((int)(adjcopy[i]).size());
           ++j) {
        if (adjcopy[i][j]->flow() > 0LL) {
          feasible = false;
        }
      }
    }
    if (!feasible) {
      return fail_value;
    }
    long long answer = 0;
    for (int i = 0; i < n; ++i) {
      for (int j = 0; j < ((int)(adjcopy[i]).size()); ++j) {
        if (adjcopy[i][j]->flow() > 0LL) {
          answer += adjcopy[i][j]->flow() * adjcopy[i][j]->cost();
        }
      }
    }
    for (int i = 0; i < n; ++i) {
      for (int j = 0; j < ((int)(adj_[i]).size()); ++j) {
        adj_[i][j]->setFlow(adjcopy[i][j]->flow());
      }
    }
    return answer;
  }
};
int stat[1200];
int en[1200];
int pro[1200];
int ret[1200];
int sid[1200];
int sen[1200];
map<int, int> waktu;
int id = 1;
void Put(int w) {
  if (waktu.count(w)) return;
  waktu[w] = id;
  ++id;
}
int main() {
  int n, k;
  cin >> n >> k;
  for (int(i) = 0; (i) < (n); ++(i)) {
    cin >> stat[i] >> en[i] >> pro[i];
    en[i] = stat[i] + en[i];
    Put(stat[i]);
    Put(en[i]);
    sid[i] = waktu[stat[i]];
    sen[i] = waktu[en[i]];
  }
  MinCostMaxFlowLongLong mcmf(((int)(waktu).size()) + 2);
  int sink = ((int)(waktu).size()) + 1;
  assert(id == sink);
  int tap = 0;
  vector<pair<int, int> > ws;
  ws.push_back(make_pair(-1, tap));
  ws.push_back(make_pair(2012012012, sink));
  for (typeof((waktu).begin()) it = (waktu).begin(); it != (waktu).end();
       it++) {
    ws.push_back(make_pair(it->first, it->second));
  }
  sort(ws.begin(), ws.end());
  for (int(i) = 0; (i) < (((int)(ws).size()) - 1); ++(i))
    mcmf.addEdge(ws[i].second, ws[i + 1].second, 55, 0);
  for (int(i) = 0; (i) < (n); ++(i)) {
    int ids = waktu[stat[i]];
    int ide = waktu[en[i]];
    mcmf.addEdge(ids, ide, 1, -pro[i]);
  }
  mcmf.setSupply(tap, k);
  mcmf.setSupply(sink, -k);
  bool f = 0;
  mcmf.solve(-2023123123);
  assert(!f);
  for (int(i) = 0; (i) < (((int)(waktu).size()) + 2); ++(i))
    for (int(j) = 0; (j) < (((int)(mcmf.adj_[i]).size())); ++(j)) {
      if (mcmf.adj_[i][j]->cost() < 0LL && mcmf.adj_[i][j]->flow()) {
        int a = i;
        int b = mcmf.adj_[i][j]->destination();
        int cos = mcmf.adj_[i][j]->cost() * -1;
        for (int(kk) = 0; (kk) < (n); ++(kk))
          if (!ret[kk] && sid[kk] == a && sen[kk] == b && pro[kk] == cos) {
            ret[kk] = 1;
            break;
          }
      }
    }
  for (int(i) = 0; (i) < (n); ++(i)) {
    if (i) cout << " ";
    cout << ret[i];
  }
  cout << endl;
}
