#include <bits/stdc++.h>
using namespace std;
const int maxN = 100005;
struct Time {
  int val, id;
} tim[2 * maxN];
struct Wall {
  int h, L, r;
} w[maxN];
int n, t, tims, trees;
struct Tnode {
  int id;
  Tnode *son[2], *f;
} tree[maxN], *nul, *root;
struct Tedge {
  int v, next;
} edge[2 * maxN];
int edges, dad[maxN], nex[maxN];
int in[maxN], f[maxN];
bool vis[maxN];
void insertedge(int u, int v) {
  edges++;
  edge[edges].v = v;
  edge[edges].next = dad[u];
  in[v]++;
  dad[u] = edges;
}
Tnode *newnode(int id) {
  trees++;
  tree[trees].id = id;
  tree[trees].son[0] = tree[trees].son[1] = tree[trees].f = nul;
  return tree + trees;
}
void Readln() {
  scanf("%d%d\n", &n, &t);
  for (int i = 1; i <= n; i++) {
    scanf("%d%d%d\n", &w[i].h, &w[i].L, &w[i].r);
    tim[++tims].val = w[i].L;
    tim[tims].id = tims;
    tim[++tims].val = w[i].r;
    tim[tims].id = tims;
  }
}
bool cmp(Time a, Time b) {
  return a.val < b.val || a.val == b.val && a.id % 2 < b.id % 2;
}
void rot(Tnode *u, int t) {
  Tnode *v = u->f;
  Tnode *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;
}
void splay(Tnode *u, Tnode *fa) {
  while (u->f != fa && u->f != nul) {
    Tnode *v = u->f;
    Tnode *w = v->f;
    if (v->f == 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);
    }
  }
  if (fa == nul) root = u;
}
Tnode *findpred(int h) {
  Tnode *ret = nul, *now = root;
  while (now != nul) {
    if (w[now->id].h >= h) {
      ret = now;
      now = now->son[1];
    } else
      now = now->son[0];
  }
  return ret;
}
Tnode *findsucc(int h) {
  Tnode *ret = nul, *now = root;
  while (now != nul) {
    if (w[now->id].h <= h) {
      ret = now;
      now = now->son[0];
    } else
      now = now->son[1];
  }
  return ret;
}
void inserttree(int h, int id) {
  if (root == nul) {
    root = newnode(id);
    return;
  }
  Tnode *pre = findpred(h);
  Tnode *suc = findsucc(h);
  if (pre != nul) nex[pre->id] = id;
  if (suc != nul) nex[id] = suc->id;
  if (pre == nul) {
    splay(suc, nul);
    suc->son[0] = newnode(id);
    suc->son[0]->f = suc;
    return;
  }
  if (suc == nul) {
    splay(pre, nul);
    pre->son[1] = newnode(id);
    pre->son[1]->f = pre;
    return;
  }
  splay(pre, nul);
  splay(suc, pre);
  root->son[1]->son[0] = newnode(id);
  root->son[1]->son[0]->f = root->son[1];
}
void deletetree(int h, int id) {
  Tnode *pre = findpred(h + 1);
  Tnode *suc = findsucc(h - 1);
  if (pre != nul)
    if (nex[pre->id] == id) insertedge(pre->id, id);
  if (suc != nul)
    if (nex[id] == suc->id) insertedge(id, suc->id);
  if (pre == nul && suc == nul) {
    root = nul;
    return;
  }
  if (pre == nul) {
    splay(suc, nul);
    root->son[0] = nul;
    return;
  }
  if (suc == nul) {
    splay(pre, nul);
    root->son[1] = nul;
    return;
  }
  splay(pre, nul);
  splay(suc, pre);
  root->son[1]->son[0] = nul;
}
void dfs(int now) {
  vis[now] = true;
  for (int i = dad[now]; i != 0; i = edge[i].next) {
    if (!vis[edge[i].v]) dfs(edge[i].v);
    int a = now, b = edge[i].v;
    int tmp = min(w[a].r, w[b].r) - max(w[a].L, w[b].L);
    f[now] = max(f[now], min(tmp, f[b]));
  }
}
void Solve() {
  nul = newnode(0);
  root = nul;
  sort(tim + 1, tim + 1 + tims, cmp);
  for (int i = 1; i <= 2 * n; i++) {
    int now = (tim[i].id + 1) / 2;
    if (tim[i].id % 2 == 1)
      inserttree(w[now].h, now);
    else
      deletetree(w[now].h, now);
  }
  for (int i = 1; i <= n; i++)
    if (dad[i] == 0) {
      f[i] = w[i].r - w[i].L;
      vis[i] = true;
    }
  for (int i = 1; i <= n; i++)
    if (!vis[i]) dfs(i);
  int ans = 0;
  for (int i = 1; i <= n; i++)
    if (in[i] == 0) ans = max(ans, f[i]);
  printf("%d\n", ans);
}
int main() {
  Readln();
  Solve();
  return 0;
}
