#include <bits/stdc++.h>
using namespace std;
template <class T>
using reversed_priority_queue = priority_queue<T, vector<T>, greater<T> >;
template <class T>
class StarrySkyTree {
 private:
  int n;
  vector<T> node_acc, node_min;
  const T INF = numeric_limits<T>::max() / 2;
  void _add(int a, int b, T x, int k, int l, int r) {
    if (r <= a || b <= l) return;
    if (a <= l && r <= b) {
      node_acc[k] += x;
    } else {
      _add(a, b, x, 2 * k + 1, l, (l + r) / 2);
      _add(a, b, x, 2 * k + 2, (l + r) / 2, r);
      T l_val = node_min[2 * k + 1] + node_acc[2 * k + 1];
      T r_val = node_min[2 * k + 2] + node_acc[2 * k + 2];
      node_min[k] = min(l_val, r_val);
    }
  }
  T _get_min(int a, int b, int k, int l, int r) {
    if (r <= a || b <= l) return INF;
    if (a <= l && r <= b) return node_min[k] + node_acc[k];
    T l_val = _get_min(a, b, 2 * k + 1, l, (l + r) / 2);
    T r_val = _get_min(a, b, 2 * k + 2, (l + r) / 2, r);
    return min(l_val, r_val) + node_acc[k];
  }

 public:
  StarrySkyTree(int _n) : n(1) {
    while (n < _n) n <<= 1;
    node_acc.resize(2 * n, 0);
    node_min.resize(2 * n, 0);
  }
  void add(int l, int r, T val) { _add(l, r, val, 0, 0, n); }
  T get_min(int l, int r) { return _get_min(l, r, 0, 0, n); }
};
int n, m;
int L[100010];
int R[100010];
vector<int> G[100010];
StarrySkyTree<int> inst(100010);
int main() {
  cin >> n >> m;
  for (int i = 0; i < n; i++) cin >> L[i] >> R[i];
  for (int i = 0; i < n; i++) G[L[i]].push_back(R[i]);
  for (int i = 1; i < m + 1; i++) {
    int cur = m + 1 - i;
    inst.add(i, i + 1, cur);
  }
  int ans = max(0, n - m);
  for (int l = 0; l < m + 1; l++) {
    for (int i = 0; i < G[l].size(); i++) {
      int r = G[l][i];
      inst.add(0, r + 1, -1);
    }
    ans = max(ans, -inst.get_min(l + 1, m + 2) - l);
  }
  cout << ans << endl;
  return 0;
}
