#include <iostream>
#include <fstream>
#include <cstdio>
#include <algorithm>
#include <vector>
#include <utility>
#include <set>
#include <map>
#include <ctime>
#include <queue>
#include <cmath>
#include <list>
#include <assert.h>
 
using namespace std;
 
typedef long long ll;
typedef long double ld;
typedef unsigned long long ull;
 
#define f first
#define s second
#define pb push_back
#define mp make_pair
 
const int maxn = 300500;
const int inf = 1e9;
const double eps = 1e-8;
const int base = 1073676287;
 
struct node {
    int prior, sz, dp, add;
    node *l, *r;
    node ( int x ) {
        prior = ( rand() << 15 ) | rand();
        // sz = 1;
        dp = x;
        l = r = NULL;
        add = 0;
    }
};
 
typedef node * pnode;
 
// int getSize( pnode T ) {
//  return T ? T -> sz : 0;
// }
 
void push( pnode T ) {
    T -> dp += T -> add;
    if ( T -> l )
        T -> l -> add += T -> add;
    if ( T -> r )
        T -> r -> add += T -> add;
    T -> add = 0;
}
 
void merge( pnode &T, pnode L, pnode R ) {
    if ( !L ) {
        T = R;
        return;
    }
    if ( !R ) {
        T = L;
        return;
    }
    if ( L -> prior > R -> prior ) {
        push( L );
        merge( L -> r, L -> r, R );
        T = L;
        // T -> sz = getSize( T -> l ) + getSize( T -> r ) + 1;
        return;
    }
    push( R );
    merge( R -> l, L, R -> l );
    T = R;
    // T -> sz = getSize( T -> l ) + getSize( T -> r ) + 1;
}
 
void split( pnode T, int value, pnode &L, pnode &R ) {
    if ( !T ) {
        L = R = NULL;
        return;
    }
    push( T );
    if ( T -> dp >= value ) {
        split( T -> l, value, L, T -> l );
        R = T;
        // R -> sz = 1 + getSize( R -> l ) + getSize( R -> r );
        return;
    }
    split( T -> r, value, T -> r, R );
    L = T;
    // L -> sz = 1 + getSize( L -> l ) + getSize( T -> r );
}
 
int findBegin( pnode T ) {
    push( T );
    if ( !T -> l )
        return T -> dp;
    return findBegin( T -> l );
}
 
int findMax( pnode T, int n ) {
    if ( !T )
        return 0;
    push( T );
    return findMax( T -> l, n ) + findMax( T -> r, n ) + ( T -> dp <= inf ? 1 : 0 );
}
 
void printTree( pnode T ) {
    if ( !T )
        return;
    push( T );
    printTree( T -> l );
    printf ( "%d ", T -> dp );
    printTree( T -> r );
}
 
pair < int, int > a[maxn];
pnode T = new node( 0 );
pnode L = NULL;
pnode M = NULL;
pnode R = NULL;
pnode rubbish = NULL;
 
void solve() {
    int n;
    scanf ( "%d", &n );
    for ( int j = 1; j <= n; j++ )
        scanf ( "%d%d", &a[j].f, &a[j].s );
    for ( int j = 1; j <= n; j++ )
        merge( T, T, new node( inf + j ) );
    // printTree(T);
    for ( int j = 1; j <= n; j++ ) {
        split( T, a[j].f, L, R );
        split( R, a[j].s, M, R );
        // printTree(M);
        // exit(0);
        if ( M )
            M -> add += 1;
        // printTree();
        int cnt = findBegin( R );
        split( R, cnt + 1, rubbish, R );
        merge( T, L, new node( a[j].f ) );
        merge( T, T, M );
        merge( T, T, R );
    }
    printf ( "%d\n", findMax( T, n ) - 1 );
}
 
 
int main()
 
{
    srand( time( NULL ) );
    // ios_base::sync_with_stdio( false );
    solve();
    return 0;
}