A restaurant received n orders for the rental. Each rental order reserve the restaurant for a continuous period of time, the i-th order is characterized by two time values — the start time li and the finish time ri (li ≤ ri).

Restaurant management can accept and reject orders. What is the maximal number of orders the restaurant can accept?

No two accepted orders can intersect, i.e. they can't share even a moment of time. If one order ends in the moment other starts, they can't be accepted both.

Input

The first line contains integer number n (1 ≤ n ≤ 5·105) — number of orders. The following n lines contain integer values li and ri each (1 ≤ li ≤ ri ≤ 109).

Output

Print the maximal number of orders that can be accepted.

Examples

Input

2
7 11
4 7


Output

1


Input

5
1 2
2 3
3 4
4 5
5 6


Output

3


Input

6
4 8
1 5
4 7
2 5
1 3
6 8


Output

2
import java.io.*;
import java.util.*;

public class Main implements Runnable
{
    class A
    {
        int l, r;
        A( int l, int r )
        {
            this.l = l;
            this.r = r;
        }
    }

    void solve() throws Exception
    {
        int n = nextInt();
        A[] a = new A[ n ];
        TreeSet<Integer> ts = new TreeSet<>();
        for( int i = 0; i < n; i++ )
        {
            a[ i ] = new A( nextInt(), nextInt() );
            ts.add( a[ i ].l ); ts.add( a[ i ].r );
        }
        TreeMap<Integer, Integer> map = new TreeMap<>();
        int ind = 1;
        while( !ts.isEmpty() )
        {
            map.put( ts.pollFirst(), ind++ );
        }
        for( A q : a )
        {
            q.l = map.get( q.l );
            q.r = map.get( q.r );
        }
        int[] dp = new int[ 1000001 ];
        Arrays.sort( a, new Comparator<A>() {
            @Override
            public int compare( A o1, A o2 )
            {
                return o1.r - o2.r;
            }
        });
        ind = 0;
        for( int i = 1; i < 1000001; i++ )
        {
            dp[ i ] = dp[ i - 1 ];
            while( ind < a.length && a[ ind ].r == i )
            {
                dp[ i ] = Math.max( dp[ i ], dp[ a[ ind++ ].l - 1 ] + 1 );
            }
        }
        out.println( dp[ 1000000 ] );
    }

    public static void main( String[] args )
    {
        new Thread( null, new Main(), "1", ( 1 << 27 ) ).start();
    }

    public void run()
    {
        try
        {
            Locale.setDefault( Locale.US );
            in = new BufferedReader( new InputStreamReader( System.in ) );
            out = new PrintWriter( System.out );
            st = null;
            solve();
        }
        catch( Exception e )
        {
            e.printStackTrace();
            System.exit( 1 );
        }
        finally
        {
            out.close();
        }
    }

    String nextToken() throws IOException
    {
        while( st == null || !st.hasMoreTokens() ) st = new StringTokenizer( in.readLine() );
        return st.nextToken();
    }

    int nextInt() throws IOException
    {
        return Integer.parseInt( nextToken() );
    }

    long nextLong() throws IOException
    {
        return Long.parseLong( nextToken() );
    }

    BufferedReader in;
    PrintWriter out;
    StringTokenizer st;
}