#include <bits/stdc++.h>
using namespace std;
const int maxN = 100100;
struct Tnode {
  int id, h, t, size;
  Tnode *son[2], *f;
} tree[2 * maxN], *root, *nul;
struct Person {
  int t, s, f, id;
} p[maxN];
long long ans[maxN];
int trees, n, m;
Tnode *newnode(int id, int h, int t) {
  trees++;
  tree[trees].id = id;
  tree[trees].h = h;
  tree[trees].t = t;
  tree[trees].son[0] = tree[trees].son[1] = tree[trees].f = nul;
  tree[trees].size = 1;
  return tree + trees;
}
bool cmp(Person a, Person b) { return a.t < b.t; }
void Readln() {
  scanf("%d%d\n", &n, &m);
  for (int i = 1; i <= n; i++) {
    scanf("%d%d%d\n", &p[i].t, &p[i].s, &p[i].f);
    p[i].id = i;
  }
  sort(p + 1, p + 1 + n, cmp);
}
void updata(Tnode *u) {
  u->size = 1;
  if (u->son[0] != nul) u->size += u->son[0]->size;
  if (u->son[1] != nul) u->size += u->son[1]->size;
}
void rot(Tnode *u, int t) {
  Tnode *v = u->f, *w = v->f;
  if (w != nul) {
    if (w->son[0] == v) w->son[0] = u;
    if (w->son[1] == v) w->son[1] = u;
  }
  u->f = w;
  v->son[t ^ 1] = u->son[t];
  if (u->son[t] != nul) u->son[t]->f = v;
  u->son[t] = v;
  v->f = u;
  updata(v);
}
void splay(Tnode *u, Tnode *fa) {
  while (u->f != fa && u->f != nul) {
    Tnode *v = u->f;
    Tnode *w = v->f;
    if (w == fa) {
      rot(u, v->son[0] == u);
      break;
    }
    bool p = (v->son[0] == u), q = (w->son[0] == v);
    if (p ^ q) {
      rot(u, p);
      rot(u, q);
    } else {
      rot(v, q);
      rot(u, p);
    }
  }
  updata(u);
  if (fa == nul) root = u;
}
Tnode *findpred(int h) {
  Tnode *now = root, *ret = nul;
  while (now != nul) {
    if (now->h <= h) {
      ret = now;
      now = now->son[1];
    } else
      now = now->son[0];
  }
  return ret;
}
Tnode *findsucc(int h) {
  Tnode *now = root, *ret = nul;
  while (now != nul) {
    if (now->h >= h) {
      ret = now;
      now = now->son[0];
    } else
      now = now->son[1];
  }
  return ret;
}
void inserttree(int id, int h, int t) {
  if (root == nul) {
    root = newnode(id, h, t);
    return;
  }
  Tnode *pre = findpred(h);
  Tnode *suc = findsucc(h + 1);
  if (pre == nul) {
    splay(suc, nul);
    root->son[0] = newnode(id, h, t);
    root->son[0]->f = root;
    updata(root);
    return;
  }
  if (suc == nul) {
    splay(pre, nul);
    root->son[1] = newnode(id, h, t);
    root->son[1]->f = root;
    updata(root);
    return;
  }
  splay(pre, nul);
  splay(suc, pre);
  root->son[1]->son[0] = newnode(id, h, t);
  root->son[1]->son[0]->f = root->son[1];
  updata(root->son[1]);
  updata(root);
}
int asktree(int h) {
  if (root == nul) return 2;
  Tnode *pre = findpred(h);
  if (pre == nul) return 1;
  if (pre->h == h) return 1;
  splay(pre, nul);
  return (2 * root->son[1]->size - root->size >= 0);
}
void deletetree(Tnode *u) {
  splay(u, nul);
  Tnode *root1 = root->son[0];
  Tnode *root2 = root->son[1];
  if (root1 == nul && root2 == nul) {
    root = nul;
    return;
  }
  root1->f = root2->f = nul;
  if (root1 == nul) {
    root = root2;
    return;
  }
  if (root2 == nul) {
    root = root1;
    return;
  }
  root = root1;
  Tnode *tmp = findpred(m + 1);
  splay(tmp, nul);
  root->son[1] = root2;
  root2->f = root;
  updata(root);
}
void Solve() {
  int nowh = 1;
  nul = newnode(0, 0, 0);
  root = nul;
  nul->size = 0;
  for (int i = 1; i <= n; i++) {
    long long nowt = p[i].t;
    inserttree(i, p[i].s, 0);
    for (;;) {
      int t = asktree(nowh);
      if (t == 2) break;
      long long ttt = (long long)p[i + 1].t - nowt;
      if (t == 1) {
        Tnode *nex = findsucc(nowh);
        if (nex->h - nowh <= ttt || i == n) {
          deletetree(nex);
          nowt += nex->h - nowh;
          if (nex->t == 1)
            ans[p[nex->id].id] = nowt;
          else
            inserttree(nex->id, p[nex->id].f, 1);
          nowh = nex->h;
        } else {
          nowh += ttt;
          break;
        }
      } else {
        Tnode *nex = findpred(nowh);
        if (nowh - nex->h <= ttt || i == n) {
          deletetree(nex);
          nowt += nowh - nex->h;
          if (nex->t == 1)
            ans[p[nex->id].id] = nowt;
          else
            inserttree(nex->id, p[nex->id].f, 1);
          nowh = nex->h;
        } else {
          nowh -= ttt;
          break;
        }
      }
    }
  }
  for (int i = 1; i <= n; i++) printf("%I64d\n", ans[i]);
}
int main() {
  Readln();
  Solve();
  return 0;
}
