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.BufferedReader;
import java.io.IOException;
import java.io.InputStreamReader;
import java.util.Arrays;
import java.util.StringTokenizer;
import java.util.TreeMap;


public class Restaurant {

    
    static int n;
    static Timing[] ts;
    static int dp2[];
    public static void main(String[] args) throws NumberFormatException, IOException {
        BufferedReader br = new BufferedReader(new InputStreamReader(System.in));

        n = Integer.parseInt(br.readLine());
        ts = new Timing[n];
        dp2 = new int[n];
        Arrays.fill(dp2, -1);
        for(int i=0; i<n; i++){
            StringTokenizer st = new StringTokenizer(br.readLine());
            ts[i] = new Timing(Integer.parseInt(st.nextToken()),Integer.parseInt(st.nextToken()));
        }
        Arrays.sort(ts);

        int accept = getAccepted(0);
        System.out.println(accept);
        

    }
    private static int getAccepted(int i) {
        if(i == n)
            return 0;
        if(dp2[i] != -1)
            return dp2[i];
        int start = i+1;
        int end = n-1;
        int ans = -1;
        while(start<=end){
            int mid = (start+end)/2;
            ans = mid;
            if(ts[mid].s>ts[i].e)
                end = mid-1;
            else if(ts[mid].s <= ts[i].e)
                start = mid+1;
            
        }
        //System.out.println(i+" "+ans);
        int way1 = 1;
        if(ans == -1)
            way1 = 1;
        else if(ts[i].e<ts[ans].s)
            way1 = 1 + getAccepted(ans);
        else{
            while(ans<n && ts[ans].s<=ts[i].e)
                ans++;
            way1 = 1 + getAccepted(ans);
        }
        
        
        int way2 = getAccepted(i+1);
        return dp2[i] =  Math.max(way1, way2);
    }
    static class Timing implements Comparable<Timing>{
        int s;
        int e;
        public Timing(int x, int y){
            s = x;
            e = y;
        }
        @Override
        public int compareTo(Timing o) {
            return this.s - o.s;
        }
    }


}
