#include <bits/stdc++.h>
using namespace std;
struct xy {
  int h, l, r;
} wall[100010];
struct node {
  int l, r, val, mark;
} T[100010 << 3];
int a[100010 << 1], dp[100010];
int n, t, cnt;
int cmp(xy i, xy j) { return i.h < j.h; }
void build(int k, int l, int r) {
  T[k].l = l;
  T[k].r = r;
  T[k].val = T[k].mark = -1;
  if (l == r) return;
  int m = l + r >> 1;
  build(k * 2, l, m);
  build(k * 2 + 1, m + 1, r);
}
void push_down(int k) {
  if (T[k].mark != -1) {
    T[k * 2].mark = T[k * 2 + 1].mark = T[k].mark;
    T[k * 2].val = T[k * 2 + 1].val = T[k].mark;
    T[k].mark = -1;
  }
}
void push_up(int k) { T[k].val = max(T[k * 2].val, T[k * 2 + 1].val); }
int query(int k, int l, int r) {
  if (T[k].l == l && T[k].r == r) return T[k].val;
  int m = T[k].l + T[k].r >> 1;
  push_down(k);
  if (r <= m)
    return query(k * 2, l, r);
  else if (l > m)
    return query(k * 2 + 1, l, r);
  else
    return max(query(k * 2, l, m), query(k * 2 + 1, m + 1, r));
}
void update(int k, int l, int r, int i) {
  if (T[k].l == l && T[k].r == r) {
    T[k].mark = T[k].val = i;
    return;
  }
  push_down(k);
  int m = T[k].l + T[k].r >> 1;
  if (r <= m)
    update(k * 2, l, r, i);
  else if (l > m)
    update(k * 2 + 1, l, r, i);
  else {
    update(k * 2, l, m, i);
    update(k * 2 + 1, m + 1, r, i);
  }
  push_up(k);
}
void solve(int l, int r, int k, int canl, int canr) {
  if (l > r) return;
  int id = query(1, l, r);
  if (id == -1) {
    update(1, l, r, k);
    dp[k] = a[r + 1] - a[l];
    return;
  }
  int ll = wall[id].l, rr = wall[id].r;
  if ((ll >= l || canl) && (rr <= r || canr)) {
    dp[k] = max(dp[k], min(dp[id], a[min(rr, r) + 1] - a[max(ll, l)]));
  }
  if (l < ll) solve(l, ll - 1, k, canl, 0);
  if (r > rr) solve(rr + 1, r, k, 0, canr);
}
int main() {
  scanf("%d%d", &n, &t);
  for (int i = 1; i <= n; i++) {
    scanf("%d%d%d", &wall[i].h, &wall[i].l, &wall[i].r);
    a[++cnt] = wall[i].l;
    a[++cnt] = wall[i].r;
  }
  wall[++n].h = t, wall[n].l = -1000000000, wall[n].r = 1000000000;
  a[++cnt] = -1000000000, a[++cnt] = 1000000000;
  wall[++n].h = 0, wall[n].l = -1000000000, wall[n].r = 1000000000;
  sort(wall + 1, wall + 1 + n, cmp);
  sort(a + 1, a + 1 + cnt);
  cnt = unique(a + 1, a + 1 + cnt) - a - 1;
  for (int i = 1; i <= n; i++) {
    wall[i].l = lower_bound(a + 1, a + 1 + cnt, wall[i].l) - a;
    wall[i].r = lower_bound(a + 1, a + 1 + cnt, wall[i].r) - a - 1;
  }
  build(1, 1, cnt);
  for (int i = 1; i <= n; i++) {
    solve(wall[i].l, wall[i].r, i, 1, 1);
    update(1, wall[i].l, wall[i].r, i);
  }
  printf("%d\n", dp[n]);
  return 0;
}
