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.util.*;

public class Solution
{
    static int dp[];
   static int upper(int arr[] , int key)
   {
       int l = 0 , r = arr.length - 1;
       while(l <= r)
       {
           int mid = (l + r)/2;
           if(key < arr[mid])
           r = mid - 1;
           
           else
           l = mid + 1;
       }
       return l;
   }

    static int max(int left[] , int right[]  , int pos , int n)
    {
        if(pos >= n)
        return 0;
        
        if(dp[pos] != -1)
        return dp[pos];
        
        int p = upper(left , right[pos]);
        
        dp[pos] = Math.max(max(left , right , pos + 1 , n) , 1 + max(left , right , p , n));
        return dp[pos];
    }
    public static void main(String []args)
    {
        Scanner sc = new Scanner(System.in);
        int q = sc.nextInt();
        int []left = new int[q];
        int []right = new int[q];
        for(int i = 0 ; i < q ; i++)
        {
            int l  = sc.nextInt();
            int r = sc.nextInt();
            
            left[i] = l;
            right[i] = r;
            
        }
         dp = new int[q];
        Integer []index = new Integer[q];
        for(int i = 0 ; i < q ; i++)
        {
            index[i] = i;
            dp[i] = -1;
        }
        IndexSort comp = new IndexSort(left , right);
        Arrays.sort(index , comp);
        
        int lleft[] = new int[q];
        int rright[] = new int[q];
        for(int i = 0 ; i < q ; i++)
        {
            lleft[i] = left[index[i]];
            rright[i] = right[index[i]];
        }
        System.out.println(max(lleft , rright , 0 , q));
        
    }
}
    
    class IndexSort implements Comparator<Integer>
    {
        int left[];
        int right[];
        public IndexSort(int left[] , int right[])
        {
            this.left = left;
            this.right = right;
        }
        
        public int compare(Integer index1 , Integer index2)
        {
            if(left[index1] - left[index2] != 0)
            return left[index1] - left[index2];
            
            return right[index1] - right[index2];
        }
    }
