#include <bits/stdc++.h>
using namespace std;
namespace {
using Integer = long long;
template <class T, class S>
istream& operator>>(istream& is, pair<T, S>& p) {
  return is >> p.first >> p.second;
}
template <class T>
istream& operator>>(istream& is, vector<T>& vec) {
  for (T& val : vec) is >> val;
  return is;
}
template <class T>
istream& operator,(istream& is, T& val) {
  return is >> val;
}
template <class T, class S>
ostream& operator<<(ostream& os, const pair<T, S>& p) {
  return os << p.first << " " << p.second;
}
template <class T>
ostream& operator<<(ostream& os, const vector<T>& vec) {
  for (size_t i = 0; i < vec.size(); i++)
    os << vec[i] << (i == vec.size() - 1 ? "" : " ");
  return os;
}
template <class T>
ostream& operator,(ostream& os, const T& val) {
  return os << " " << val;
}
template <class H>
void print(const H& head) {
  cout << head;
}
template <class H, class... T>
void print(const H& head, const T&... tail) {
  cout << head << " ";
  print(tail...);
}
template <class... T>
void println(const T&... values) {
  print(values...);
  cout << endl;
}
template <class H>
void eprint(const H& head) {
  cerr << head;
}
template <class H, class... T>
void eprint(const H& head, const T&... tail) {
  cerr << head << " ";
  eprint(tail...);
}
template <class... T>
void eprintln(const T&... values) {
  eprint(values...);
  cerr << endl;
}
class range {
  Integer start_, end_, step_;

 public:
  struct range_iterator {
    Integer val, step_;
    range_iterator(Integer v, Integer step) : val(v), step_(step) {}
    Integer operator*() { return val; }
    void operator++() { val += step_; }
    bool operator!=(range_iterator& x) {
      return step_ > 0 ? val < x.val : val > x.val;
    }
  };
  range(Integer len) : start_(0), end_(len), step_(1) {}
  range(Integer start, Integer end) : start_(start), end_(end), step_(1) {}
  range(Integer start, Integer end, Integer step)
      : start_(start), end_(end), step_(step) {}
  range_iterator begin() { return range_iterator(start_, step_); }
  range_iterator end() { return range_iterator(end_, step_); }
};
inline string operator"" _s(const char* str, size_t size) {
  return move(string(str));
}
constexpr Integer my_pow(Integer x, Integer k, Integer z = 1) {
  return k == 0    ? z
         : k == 1  ? z * x
         : (k & 1) ? my_pow(x * x, k >> 1, z * x)
                   : my_pow(x * x, k >> 1, z);
}
constexpr Integer my_pow_mod(Integer x, Integer k, Integer M, Integer z = 1) {
  return k == 0    ? z % M
         : k == 1  ? z * x % M
         : (k & 1) ? my_pow_mod(x * x % M, k >> 1, M, z * x % M)
                   : my_pow_mod(x * x % M, k >> 1, M, z);
}
constexpr unsigned long long operator"" _ten(unsigned long long value) {
  return my_pow(10, value);
}
inline int k_bit(Integer x, int k) { return (x >> k) & 1; }
mt19937 mt(chrono::duration_cast<chrono::nanoseconds>(
               chrono::steady_clock::now().time_since_epoch())
               .count());
template <class T>
string join(const vector<T>& v, const string& sep) {
  stringstream ss;
  for (size_t i = 0; i < v.size(); i++) {
    if (i > 0) ss << sep;
    ss << v[i];
  }
  return ss.str();
}
inline string operator*(string s, int k) {
  string ret;
  while (k) {
    if (k & 1) ret += s;
    s += s;
    k >>= 1;
  }
  return ret;
}
}  // namespace
constexpr long long mod = 9_ten + 7;
typedef struct {
  int to;
  int cap;
  int rev;
} edge;
void bfs(vector<vector<edge>>& G, vector<int>& level, int s) {
  fill(level.begin(), level.end(), -1);
  queue<int> q;
  q.push(s);
  level[s] = 0;
  while (!q.empty()) {
    int e = q.front();
    q.pop();
    for (int i = 0; i < G[e].size(); i++) {
      if (G[e][i].cap > 0 && level[G[e][i].to] < 0) {
        level[G[e][i].to] = level[e] + 1;
        q.push(G[e][i].to);
      }
    }
  }
}
int dfs(vector<vector<edge>>& G, vector<int>& level, vector<bool>& used,
        vector<int>& iter, int s, int f, int t) {
  if (s == t)
    return f;
  else {
    for (int& i = iter[s]; i < G[s].size(); i++) {
      if (G[s][i].cap > 0 && level[s] < level[G[s][i].to]) {
        int d = dfs(G, level, used, iter, G[s][i].to, min(f, G[s][i].cap), t);
        if (d > 0) {
          G[s][i].cap -= d;
          G[G[s][i].to][G[s][i].rev].cap += d;
          return d;
        }
      }
    }
    return 0;
  }
}
int dinic_maxflow(vector<vector<edge>>& G, int s, int t) {
  const int INF = 100000000;
  int flow = 0;
  while (true) {
    vector<int> level(G.size(), -1);
    vector<int> iter(G.size(), 0);
    vector<bool> used(G.size(), false);
    bfs(G, level, s);
    if (level[t] < 0) return flow;
    while (true) {
      int f = dfs(G, level, used, iter, s, INF, t);
      if (f == 0)
        break;
      else
        flow += f;
    }
  }
}
void add_edge(vector<vector<edge>>& G, int from, int to, int cap) {
  G[from].push_back((edge){to, cap, (int)G[to].size()});
  G[to].push_back((edge){from, 0, (int)G[from].size() - 1});
}
int n, m;
vector<vector<edge>> G;
int source, sink;
void func(int lb, int ub, int k) {
  if (ub - lb == 1) {
    if (1 <= lb && lb <= m - 2) add_edge(G, n + k, sink, 1);
    return;
  }
  static int inf = 100000;
  add_edge(G, n + k, n + k * 2 + 1, inf);
  func(lb, (ub + lb) / 2, k * 2 + 1);
  add_edge(G, n + k, n + k * 2 + 2, inf);
  func((ub + lb) / 2, ub, k * 2 + 2);
}
void add(int lb, int ub, int k, int id, int ll, int rr) {
  if (ll <= lb && ub <= rr) {
    add_edge(G, id, n + k, 1);
    return;
  }
  if (ub <= ll || rr <= lb) return;
  add(lb, (ub + lb) / 2, k * 2 + 1, id, ll, rr);
  add((ub + lb) / 2, ub, k * 2 + 2, id, ll, rr);
}
int main() {
  cin >> n, m;
  vector<int> l(n), r(n);
  for (int i = 0; i < n; i++) {
    scanf("%d%d", &l[i], &r[i]);
  }
  m += 2;
  int kk = 1;
  while (kk < m) kk <<= 1;
  G.resize(n + 2 * kk + 2);
  source = n + 2 * kk + 0;
  sink = n + 2 * kk + 1;
  func(0, kk, 0);
  for (int i = 0; i < n; i++) {
    add_edge(G, source, i, 1);
    add(0, kk, 0, i, 0, l[i] + 1);
    add(0, kk, 0, i, r[i], m - 1);
  }
  int f = dinic_maxflow(G, source, sink);
  int ans = n - f;
  println(ans);
  return 0;
}
