#include<bits/stdc++.h>
#define rep(i,a,b) for(int i=a;i<b;i++)
#pragma GCC optimize ("-O3")
using namespace std; void _main(); int main() { cin.tie(0); ios::sync_with_stdio(false); _main(); }
//---------------------------------------------------------------------------------------------------
#define INF INT_MAX/2
struct segtree {
    const int SIZE = 1 << 20;
    //seg:区間の最小値 lazy:区間に対して、加える値でまだ遅延しているもの
    vector<int> seg, lazy;//segは欲しい情報 lazyは区間に対する一様な処理を示すもの
    segtree() :seg(SIZE * 2), lazy(SIZE * 2) {}
    void lazy_evaluate(int k, int l, int r) {//遅延情報の適用方法
        if (lazy[k] != 0) {
            seg[k] += lazy[k];//区間[l,r)にすべて同じ値を追加することになっていて、segには最小値が入っているので、加える値を足す
            if (r - l > 1) {
                lazy[k * 2 + 1] += lazy[k];//遅延を左の子に伝搬
                lazy[k * 2 + 2] += lazy[k];//遅延を右の子に伝搬
            }
            lazy[k] = 0;//ノードkは伝搬完了
        }
    }
    void update(int a, int b, int k, int l, int r, int x) {
        lazy_evaluate(k, l, r);
        if (r <= a || b <= l) return;
        if (a <= l && r <= b) {
            lazy[k] += x; //加える
            lazy_evaluate(k, l, r);
        }
        else {
            update(a, b, k * 2 + 1, l, (l + r) / 2, x);
            update(a, b, k * 2 + 2, (l + r) / 2, r, x);
            seg[k] = max(seg[k * 2 + 1], seg[k * 2 + 2]); //区間のmin
        }
    }
    int query(int a, int b, int k, int l, int r) {
        lazy_evaluate(k, l, r);
        if (r <= a || b <= l) return 0;//minの影響のないもの
        if (a <= l && r <= b) return seg[k];
        int x = query(a, b, k * 2 + 1, l, (l + r) / 2);
        int y = query(a, b, k * 2 + 2, (l + r) / 2, r);
        return max(x, y); //左右のminを
    }
    //update(a,b,x) := [a,b)を全てxを加える
    void update(int a, int b, int x) { update(a, b, 0, 0, SIZE, x); }
    //query(a,b) := [a,b)に対する最小値を求める
    int query(int a, int b) { return query(a, b, 0, 0, SIZE); }
};
/*---------------------------------------------------------------------------------------------------
　　　　　　　　　　　 ∧＿∧  
　　　　　 ∧＿∧ 　（´<_｀ ）　 Welcome to My Coding Space!
　　　　 （ ´_ゝ`）　/　 ⌒i     
　　　　／　　　＼　 　  |　|     
　　　 /　　 /￣￣￣￣/　　|  
　 ＿_(__ﾆつ/　    ＿/ .| .|＿＿＿＿  
　 　　　＼/＿＿＿＿/　（u　⊃  
---------------------------------------------------------------------------------------------------*/



int N, M, L[201010], R[201010];
//---------------------------------------------------------------------------------------------------
int solveOM2N() { // O(M^2N)
    int ans = max(0, N - M);
    rep(LL, 0, M + 2) rep(RR, LL + 1, M + 2) {
        int chair = LL + M + 1 - RR;
        int human = 0;
        rep(i, 0, N) if (L[i] <= LL && RR <= R[i]) human++;

        ans = max(ans, human - chair);
    }
    return ans;
}
//---------------------------------------------------------------------------------------------------
pair<int, int> LR[201010];
segtree st;
int solveONlogM() { // O(NlogM)
    rep(i, 0, N) LR[i] = { L[i], R[i] };
    sort(LR, LR + N);

    rep(i, 1, M + 2) st.update(i, i + 1, i);


    int ans = max(0, N - M);
    rep(i, 0, N) {
        st.update(0, LR[i].second + 1, 1);

        // human - (LL + M + 1 - RR) = human + RR - (LL + M + 1)
        ans = max(ans, st.query(0, M + 2) - (LR[i].first + M + 1));
    }
    return ans;
}
//---------------------------------------------------------------------------------------------------
void _main() {
    cin >> N >> M;
    rep(i, 0, N) cin >> L[i] >> R[i];

    //cout << solveOM2N() << endl;
    cout << solveONlogM() << endl;
}

Measured memory_bytes: 19840