#include <bits/stdc++.h>
using namespace std;
const int N = 200000 + 7, INF = 1000000000;
int n, t, B[N], Sz, Dp[N];
struct YYZ {
  int l, r, h;
} A[N];
int W[N << 2], Sign[N << 2];
inline void Build(int u, int l, int r) {
  W[u] = Sign[u] = -1;
  if (l == r) return;
  int Mid = (l + r) >> 1;
  Build((u << 1), l, Mid), Build((u << 1 | 1), Mid + 1, r);
}
inline void Pushdown(int u) {
  if (~Sign[u]) {
    Sign[(u << 1)] = Sign[(u << 1 | 1)] = Sign[u];
    W[(u << 1)] = W[(u << 1 | 1)] = Sign[u];
    Sign[u] = -1;
  }
}
inline void Update(int u, int l, int r, int L, int R, int id) {
  if (L <= l && R >= r) {
    W[u] = id, Sign[u] = id;
    return;
  }
  Pushdown(u);
  int Mid = (l + r) >> 1;
  if (L <= Mid) Update((u << 1), l, Mid, L, R, id);
  if (R > Mid) Update((u << 1 | 1), Mid + 1, r, L, R, id);
  W[u] = max(W[(u << 1)], W[(u << 1 | 1)]);
}
inline int Query(int u, int l, int r, int L, int R) {
  if (L <= l && R >= r) return W[u];
  Pushdown(u);
  int Mid = (l + r) >> 1, Ans = -1;
  if (L <= Mid) Ans = Query((u << 1), l, Mid, L, R);
  if (R > Mid) Ans = max(Ans, Query((u << 1 | 1), Mid + 1, r, L, R));
  return Ans;
}
inline void Insert(int l, int r, int id, bool flag1, bool flag2) {
  if (l > r) return;
  int Id = Query(1, 1, Sz, l, r);
  if (Id == -1) {
    Dp[id] = max(Dp[id], B[r + 1] - B[l]);
    return;
  }
  if ((!flag1 || A[Id].l >= l) && (!flag2 || A[Id].r <= r))
    Dp[id] =
        max(Dp[id], min(Dp[Id], B[min(r, A[Id].r) + 1] - B[max(l, A[Id].l)]));
  if (A[Id].l > l) Insert(l, A[Id].l - 1, id, flag1, 1);
  if (A[Id].r < r) Insert(A[Id].r + 1, r, id, 1, flag2);
}
int main() {
  scanf("%d%d", &n, &t);
  for (int i = (1), iLimit = (n); i <= iLimit; (++(i)))
    scanf("%d%d%d", &A[i].h, &A[i].l, &A[i].r), B[(++(Sz))] = A[i].l,
                                                B[(++(Sz))] = A[i].r;
  B[(++(Sz))] = INF, B[(++(Sz))] = -INF;
  A[(++(n))] = (YYZ){-INF, INF, 0}, A[(++(n))] = (YYZ){-INF, INF, t};
  sort(B + 1, B + 1 + Sz);
  Sz = unique(B + 1, B + 1 + Sz) - B - 1;
  for (int i = (1), iLimit = (n); i <= iLimit; (++(i)))
    A[i].l = lower_bound(B + 1, B + 1 + Sz, A[i].l) - B,
    A[i].r = lower_bound(B + 1, B + 1 + Sz, A[i].r) - B - 1;
  sort(A + 1, A + 1 + n, [](YYZ A, YYZ B) { return A.h < B.h; });
  Build(1, 1, Sz);
  for (int i = (1), iLimit = (n); i <= iLimit; (++(i))) {
    Insert(A[i].l, A[i].r, i, 0, 0);
    Update(1, 1, Sz, A[i].l, A[i].r, i);
  }
  printf("%d", Dp[n]);
  return 0;
}
