import java.io.BufferedReader;
import java.io.IOException;
import java.io.InputStreamReader;
import java.io.StreamTokenizer;
import java.util.ArrayList;
import java.util.Collections;
import java.util.Iterator;
import java.util.TreeSet;
import java.lang.Integer;

public class waterfall_kp {

    static StreamTokenizer st = new StreamTokenizer(new BufferedReader(new InputStreamReader(System.in)));

    static int nextInt() {
        try {
            st.nextToken();
            return (int) st.nval;
        } catch (IOException ex) {
            return 0;
        }
    }

    static class Segment implements Comparable<Segment> {

        int l, r, h;
        int max = 0;

        public Segment(int l, int r, int h) {
            this.l = l;
            this.r = r;
            this.h = h;

        }

        @Override
        public int compareTo(Segment o) {
            int cmp = -Integer.valueOf(h).compareTo(Integer.valueOf(o.h));
            return cmp == 0 ? Integer.valueOf(l).compareTo(Integer.valueOf(o.l)) : cmp;
        }

        boolean overlaps(Segment o) {
            return l < o.r && o.l < r;
        }
    }

    static class Part implements Comparable<Part> {

        int l, r;
        Segment s;

        public Part(int l, int r, Segment s) {
            this.l = l;
            this.r = r;
            this.s = s;
        }

        public Part(Segment s) {
            this.l = s.l;
            this.r = s.r;
            this.s = s;
        }

        @Override
        public int compareTo(Part o) {
            int cmp = Integer.valueOf(l).compareTo(Integer.valueOf(o.l));
            return cmp == 0 ? Integer.valueOf(r).compareTo(Integer.valueOf(o.r)) : cmp;
        }
        
        int overlap(Part o) {
            return Math.min(r,o.r)-Math.max(l,o.l);
        }

        private int length() {
            return r-l;
        }
    }

    public static void main(String[] args) {
        int n = nextInt();
        ArrayList<Segment> segments = new ArrayList<Segment>();
        Segment top = new Segment(Integer.MIN_VALUE, Integer.MAX_VALUE, nextInt());
        top.max = Integer.MAX_VALUE;
        Segment bottom = new Segment(Integer.MIN_VALUE+1, Integer.MAX_VALUE-1, 0);
        segments.add(top);
        segments.add(bottom);
        for (int i = 0; i < n; i++) {
            int h = nextInt();
            segments.add(new Segment(nextInt(), nextInt(), h));
        }
        Collections.sort(segments);

        TreeSet<Part> parts = new TreeSet<Part>();
        parts.add(new Part(top));
        for (int i = 1; i < segments.size(); i++) {
            Segment s = segments.get(i);
            Part p = new Part(s);
            Part first = parts.lower(new Part(s.l, s.l, null));
            if(first.r==p.l) {
                first=parts.higher(first);
            }
            Part last = parts.lower(new Part(s.r, s.r, null));
            TreeSet<Part> oParts = (TreeSet<Part>) parts.subSet(first, true, last, true);
            Iterator<Part> it = oParts.iterator();

            Part l = null;
            Part m = null;
            Part r = null;

            while (m == null) {
                m = r;
                if(it.hasNext()) {
                    r=it.next();
                    it.remove();
                } else {
                    r=null;
                }
            }
            while (m != null) {
                boolean use = true;
                if (l != null) {
                    if (l.s.overlaps(m.s)&&l.s.h<m.s.h) {
                        use = false;
                    }
                }
                if (r != null) {
                    if (r.s.overlaps(m.s)&&r.s.h<m.s.h) {
                        use = false;
                    }
                }
                if(use) {
                    s.max=Math.max(s.max,Math.min(m.s.max, p.overlap(m)));
                }
                l=m;
                m=r;
                if(it.hasNext()) {
                    r=it.next();
                    it.remove();
                } else {
                    r=null;
                }
            }
            
            parts.add(p);
            if(p.l>first.l) {
                parts.add(new Part(first.l,p.l,first.s));
            }
            if(p.r<last.r){
                parts.add(new Part(p.r,last.r,last.s));
            }
        }
        System.out.println(bottom.max);
    }
}