#include <bits/stdc++.h>
using namespace std;
struct pairhash {
 public:
  template <typename T, typename U>
  size_t operator()(const pair<T, U>& x) const {
    size_t seed = hash<T>()(x.first);
    return hash<U>()(x.second) + 0x9e3779b9 + (seed << 6) + (seed >> 2);
  }
};
const int inf = 1e9 + 9;
const long long mod = 1e9 + 7;
const double eps = 1e-8;
const double pi = acos(-1);
int n, m;
pair<int, int> lr[200100];
template <typename T>
class SegmentTree {
  class Node {
   public:
    long long l, r;
    T data;
    T lazy;
    Node* child_L;
    Node* child_R;
    Node(long long l, long long r, T data) {
      this->l = l;
      this->r = r;
      this->data = data;
      this->lazy = 0;
      this->child_L = nullptr;
      this->child_R = nullptr;
    }
    void lazy_evaluate() {
      this->data += this->lazy;
      if (this->r - this->l > 1) {
        if (this->child_L == nullptr) {
          long long mid = (this->l + this->r) / 2;
          this->child_L = new Node(this->l, mid, init);
          this->child_R = new Node(mid, this->r, init);
        }
        this->child_L->lazy += this->lazy;
        this->child_R->lazy += this->lazy;
      }
      this->lazy = 0;
    }
  };
  Node* root;
  long long N;
  static const T init = -1000000000;
  T op(const T& a, const T& b) { return max(a, b); }

 public:
  SegmentTree(long long n) {
    this->N = n;
    this->root = new Node(0, n, init);
  }
  void update(Node* node, long long k, T a) {
    if (node->l <= k && k < node->r) {
      if (node->l == k && node->r == k + 1) {
        node->data = a;
      } else {
        node->lazy_evaluate();
        update(node->child_L, k, a);
        update(node->child_R, k, a);
        node->data = op(node->child_L->data, node->child_R->data);
      }
    } else {
      node->lazy_evaluate();
    }
  }
  void update(long long k, T a) { update(this->root, k, a); }
  void add(Node* node, long long k, T a) {
    if (node->l <= k && k < node->r) {
      if (node->l == k && node->r == k + 1) {
        node->lazy_evaluate();
        node->data += a;
      } else {
        node->lazy_evaluate();
        add(node->child_L, k, a);
        add(node->child_R, k, a);
        node->data = op(node->child_L->data, node->child_R->data);
      }
    } else {
      node->lazy_evaluate();
    }
  }
  void add(long long k, T a) { add(this->root, k, a); }
  void add_range(Node* node, long long l, long long r, T a) {
    if (node->r <= l || r <= node->l) {
      node->lazy_evaluate();
      return;
    }
    if (l <= node->l && node->r <= r) {
      node->lazy += a;
      node->lazy_evaluate();
    } else {
      node->lazy_evaluate();
      add_range(node->child_L, l, r, a);
      add_range(node->child_R, l, r, a);
      node->data = op(node->child_L->data, node->child_R->data);
    }
  }
  void add_range(long long l, long long r, T a) {
    if (l < r) add_range(this->root, l, r, a);
  }
  T query(Node* node, long long l, long long r) {
    if (node == nullptr || node->r <= l || r <= node->l) return init;
    node->lazy_evaluate();
    if (l <= node->l && node->r <= r) return node->data;
    return op(query(node->child_L, l, r), query(node->child_R, l, r));
  }
  T query(long long l, long long r) { return query(this->root, l, r); }
  T get(long long i) { return query(this->root, i, i + 1); }
};
int solve() {
  SegmentTree<int> sgt(m + 3);
  for (int i = m + 1; i >= 0; i--) {
    sgt.update(i, i - m - 1);
  }
  sort(lr, lr + n);
  int res = n - m;
  for (int i = 0; i < n; i++) {
    sgt.add_range(0, lr[i].second + 1, 1);
    res = max(res, sgt.query(0, m + 2) - lr[i].first);
  }
  return res;
}
void input() {
  cin >> n >> m;
  int l, r;
  for (int i = 0; i < n; i++) {
    cin >> l >> r;
    lr[i] = pair<int, int>(l, r);
  }
}
int main() {
  ios::sync_with_stdio(false);
  cin.tie(0);
  cout << fixed << setprecision(15);
  input();
  cout << solve() << '\n';
}
