#include <bits/stdc++.h>
using namespace std;
template <typename T1, typename T2>
void Max(T1& a, T2 b) {
  a = max(a, (T1)b);
}
template <typename T1, typename T2>
void Min(T1& a, T2 b) {
  a = min(a, (T1)b);
}
struct node {
  int prior, key;
  int add = 0;
  int sz = 1;
  node* l = 0;
  node* r = 0;
  node(int k) : prior(rand()), key(k) {}
  void push() {
    if (!add) return;
    key += add;
    if (l) l->add += add;
    if (r) r->add += add;
    add = 0;
  }
  void update() {
    sz = 1;
    if (l) sz += l->sz;
    if (r) sz += r->sz;
  }
};
typedef node* pnode;
void merge(pnode& p, pnode l, pnode r) {
  if (!l)
    p = r;
  else if (!r)
    p = l;
  else {
    if (l->prior > r->prior) {
      p = l;
      l->push();
      merge(l->r, l->r, r);
    } else {
      p = r;
      r->push();
      merge(r->l, l, r->l);
    }
    p->update();
  }
}
void split(pnode p, pnode& l, pnode& r, int k) {
  if (!p) {
    l = r = 0;
    return;
  }
  p->push();
  if (k <= p->key) {
    r = p;
    split(p->l, l, p->l, k);
  } else {
    l = p;
    split(p->r, p->r, r, k);
  }
  p->update();
}
void splitn(pnode p, pnode& l, pnode& r, int n) {
  if (!p) {
    l = r = 0;
    return;
  }
  p->push();
  int lsz = (p->l) ? p->l->sz : 0;
  if (lsz >= n) {
    r = p;
    splitn(p->l, l, p->l, n);
  } else {
    l = p;
    splitn(p->r, p->r, r, n - lsz - 1);
  }
  p->update();
}
void insert(pnode& p, pnode n) {
  if (!p) {
    p = n;
    return;
  }
  if (n->prior > p->prior) {
    split(p, n->l, n->r, n->key);
    p = n;
  } else {
    p->push();
    if (n->key < p->key) {
      insert(p->l, n);
    } else {
      insert(p->r, n);
    }
  }
  p->update();
}
void erase(pnode& p, int k) {
  if (!p) return;
  p->push();
  if (p->key == k) {
    merge(p, p->l, p->r);
  } else {
    if (k < p->key)
      erase(p->l, k);
    else
      erase(p->r, k);
    p->update();
  }
}
void sliceleft(pnode& p) {
  if (!p) return;
  if (!p->l)
    p = p->r;
  else {
    sliceleft(p->l);
  }
}
int sz(pnode p) {
  if (!p) return 0;
  return sz(p->l) + sz(p->r) + 1;
}
void solve() {
  int n;
  cin >> n;
  pnode p = 0;
  while (n--) {
    int l, r;
    cin >> l >> r;
    pnode a, b, c, d;
    split(p, a, b, l);
    split(b, b, c, r);
    merge(a, a, new node(l));
    if (b) b->add++;
    sliceleft(c);
    merge(p, a, b);
    merge(p, p, c);
  }
  cout << sz(p) << endl;
}
void init() {}
int main(void) {
  ios::sync_with_stdio(false);
  cout.setf(ios::fixed);
  cout.precision(20);
  init();
  solve();
  return 0;
}
