#include <bits/stdc++.h>
using namespace std;
void addmod(int &a, long long b) {
  a = (a + b);
  if (a >= 1000000007) a -= 1000000007;
}
void mulmod(int &a, long long b) { a = (a * b) % 1000000007; }
template <class T>
bool domin(T &a, const T &b) {
  return a > b ? a = b, 1 : 0;
}
template <class T>
bool domax(T &a, const T &b) {
  return a < b ? a = b, 1 : 0;
}
int gi() {
  int a;
  scanf("%d", &a);
  return a;
}
long long gll() {
  long long a;
  scanf("%lld", &a);
  return a;
}
int n;
namespace treap {
struct treap {
  int val, size, lazy;
  long long rnd;
  treap *l, *r;
  treap()
      : val(0),
        size(0),
        lazy(0),
        rnd((((long long)rand()) << 32) | rand()),
        l(NULL),
        r(NULL) {}
  treap(int val)
      : val(val),
        size(1),
        lazy(0),
        rnd((((long long)rand()) << 32) | rand()),
        l(NULL),
        r(NULL) {}
  void push() {
    if (lazy == 0) return;
    val += lazy;
    if (l != NULL) l->lazy += lazy;
    if (r != NULL) r->lazy += lazy;
    lazy = 0;
  }
  void updateSz() {
    size = 1;
    if (l != NULL) size += l->size;
    if (r != NULL) size += r->size;
  }
};
typedef treap *ptreap;
ptreap root = NULL;
void split(ptreap tp, int key, ptreap &l, ptreap &r) {
  if (tp == NULL) {
    l = NULL, r = NULL;
    return;
  }
  tp->push();
  if (tp->val < key)
    l = tp, split(tp->r, key, tp->r, r);
  else
    r = tp, split(tp->l, key, l, tp->l);
  if (l != NULL) l->updateSz();
  if (r != NULL) r->updateSz();
}
pair<ptreap, ptreap> split(int v) {
  ptreap l, r;
  split(root, v, l, r);
  return {l, r};
}
pair<ptreap, ptreap> split(ptreap tp, int v) {
  ptreap l, r;
  split(tp, v, l, r);
  return {l, r};
}
void insert(ptreap &tp, ptreap v) {
  if (tp == NULL) {
    tp = v;
    return;
  }
  tp->push();
  if (v->rnd < tp->rnd)
    insert(v->val > tp->val ? tp->r : tp->l, v);
  else
    split(tp, v->val, v->l, v->r), tp = v;
  tp->updateSz();
}
void insert(int v) {
  ptreap tp = new treap(v);
  insert(root, tp);
}
void merge(ptreap &t, ptreap l, ptreap r) {
  if (l != NULL) l->push();
  if (r != NULL) r->push();
  if (l == NULL || r == NULL)
    t = (l == NULL ? r : l);
  else if (l->rnd > r->rnd)
    t = l, merge(t->r, l->r, r);
  else
    t = r, merge(t->l, l, r->l);
  if (t != NULL) t->updateSz();
}
void erase(ptreap &tp, int v) {
  if (tp == NULL) return;
  tp->push();
  if (v == tp->val) {
    merge(tp, tp->l, tp->r);
  } else {
    erase(v < tp->val ? tp->l : tp->r, v);
    tp->updateSz();
  }
}
int getmin(ptreap tp) {
  if (tp == NULL) return 0;
  tp->push();
  return tp->l == NULL ? tp->val : getmin(tp->l);
}
int getmax(ptreap tp) {
  if (tp == NULL) return 0;
  tp->push();
  return tp->r == NULL ? tp->val : getmax(tp->r);
}
void recalc(ptreap tp) {
  if (tp == NULL) return;
  tp->push();
  recalc(tp->l);
  recalc(tp->r);
  tp->updateSz();
}
void debug(ptreap &tp) {
  if (tp == NULL) return;
  tp->push();
  if (tp->l != NULL) debug(tp->l);
  cout << "    " << tp->val << ":" << tp->rnd << ":" << tp->size << endl;
  if (tp->r != NULL) debug(tp->r);
}
}  // namespace treap
int main() {
  n = gi();
  for (int i = 0; i < n; i++) {
    int l = gi(), r = gi();
    auto v = treap::split(l);
    auto v2 = treap::split(v.second, r);
    if (v2.first != NULL) v2.first->lazy++;
    if (v2.second != NULL) {
      auto v = treap::getmin(v2.second);
      treap::erase(v2.second, v);
    }
    treap::merge(treap::root, v.first, v2.first);
    treap::merge(treap::root, treap::root, v2.second);
    treap::insert(l);
  }
  cout << treap::root->size << endl;
  return 0;
}
