#include <bits/stdc++.h>
using namespace std;
const int N = 1e5 + 100;
const int INF = 1e9;
struct Node {
  int h, l, r;
  bool operator<(const Node &th) const {
    return h != th.h ? h < th.h : r < th.r;
  }
} node[N];
int clo[N * 8], mx[N * 8];
void up(int x, int &y) {
  if (y == -1) {
    y = x;
    return;
  }
  if (x == -1) return;
  if (node[x].h > node[y].h) y = x;
  if (node[x].h == node[y].h && node[x].r > node[y].r) y = x;
}
void pushdown(int l, int r, int o) {
  if (clo[o] != -1) {
    clo[o << 1] = clo[o << 1 | 1] = clo[o];
    mx[o << 1] = mx[o << 1 | 1] = mx[o];
    clo[o] = -1;
  }
}
void pushup(int l, int r, int o) {
  mx[o] = mx[o << 1];
  up(mx[o << 1 | 1], mx[o]);
}
int L, R, V;
void update(int l, int r, int o) {
  if (L <= l && r <= R) {
    clo[o] = V;
    mx[o] = V;
    return;
  }
  pushdown(l, r, o);
  if (L <= (l + r) / 2) update(l, (l + r) / 2, o << 1);
  if (R > (l + r) / 2) update((l + r) / 2 + 1, r, o << 1 | 1);
  pushup(l, r, o);
}
void query(int l, int r, int o) {
  if (L <= l && r <= R) {
    int x = mx[o];
    up(x, V);
    return;
  }
  pushdown(l, r, o);
  if (L <= (l + r) / 2) query(l, (l + r) / 2, o << 1);
  if (R > (l + r) / 2) query((l + r) / 2 + 1, r, o << 1 | 1);
}
int sta[2 * N], top, dp[N];
int dfs(int l, int r, int mask) {
  L = l, R = r, V = -1;
  query(0, top - 1, 1);
  if (V == -1) return -1;
  int x = max(l, node[V].l), y = min(r, node[V].r);
  int ans = 0;
  if ((mask & 2) && node[V].l < l || (mask & 1) && node[V].r > r)
    ;
  else {
    ans = min(dp[V], sta[y] - sta[x] + 1);
  }
  if (y < r) ans = max(ans, dfs(y + 1, r, mask | 2));
  if (x > l) ans = max(ans, dfs(l, x - 1, mask | 1));
  return ans;
}
int main() {
  int n, t;
  while (scanf("%d%d", &n, &t) != EOF) {
    top = 0;
    for (int i = 0; i < n; i++) {
      scanf("%d%d%d", &node[i].h, &node[i].l, &node[i].r);
      node[i].r--;
      sta[top++] = node[i].l, sta[top++] = node[i].r;
    }
    node[n].h = 0;
    node[n].l = -INF;
    node[n].r = INF;
    node[n + 1].h = t;
    node[n + 1].l = -INF;
    node[n + 1].r = INF;
    sta[top++] = -INF;
    sta[top++] = INF;
    n += 2;
    sort(sta, sta + top);
    top = unique(sta, sta + top) - sta;
    for (int i = 0; i < n; i++) {
      node[i].l = lower_bound(sta, sta + top, node[i].l) - sta;
      node[i].r = lower_bound(sta, sta + top, node[i].r) - sta;
    }
    sort(node, node + n);
    memset(mx, -1, sizeof(mx));
    memset(clo, -1, sizeof(clo));
    L = node[0].l, R = node[0].r, V = 0;
    update(0, top - 1, 1);
    dp[0] = 2 * INF;
    for (int i = 1; i < n; i++) {
      int j = i;
      while (j + 1 < n && node[j + 1].h == node[i].h) j++;
      for (int k = i; k <= j; k++) {
        dp[k] = dfs(node[k].l, node[k].r, 0);
      }
      for (int k = i; k <= j; k++) {
        L = node[k].l, R = node[k].r, V = k;
        update(0, top - 1, 1);
      }
      i = j;
    }
    printf("%d\n", dp[n - 1]);
  }
  return 0;
}
