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.*;
import java.io.*;

public class cf_33 {
    public static void main(String[] args) {
        new Solution().solve();
    }
}

class Solution {
    public void solve() {
        FastScanner fs = new FastScanner();
        int n = fs.nextInt();
        int[][] intervals = new int[n][2];
        for (int i=0; i < n; i++) {
            intervals[i][0] = fs.nextInt();
            intervals[i][1] = fs.nextInt();
        }
        // Sort Array based on start time
        Arrays.sort(intervals, (a,b) -> (new Integer(a[0])).compareTo(new Integer(b[0])));
        int previous = 0, overlaps = 0;
        for (int i=1; i <n; i++) {
            if (intervals[previous][1] >= intervals[i][0]) { // If previous end time >= current start time
                overlaps++;
                if (intervals[previous][1] >= intervals[i][1]) { // If previous end time >= current end time
                    previous = i;
                }
            } else { // No overlaps
                previous = i;
            }
        }
        System.out.println(n - overlaps); // Here we require number of non-overlapping intervals
    }
}

class FastScanner {
    private BufferedReader br = new BufferedReader(new InputStreamReader(System.in));
    private StringTokenizer st = new StringTokenizer("");
    
    // Below would return next string (delimited by space or new line)
    public String next() {
        while (!st.hasMoreTokens())
            try {
                st = new StringTokenizer(br.readLine());
            } catch (IOException e) {
                e.printStackTrace();
            }
        return st.nextToken();
    }

    // Below would return entire string in the line (including spaces)
    public String nextLineStr() {
        String str = "";
        try {
            str = br.readLine();
        } catch (IOException e) {
            e.printStackTrace();
        }
        return str;
    }
    
    public int[] readIntArray(int n) {
        int[] arr = new int[n];
        for (int i=0; i<n; i++) {
            arr[i] = nextInt();
        }
        return arr;
    }

    public int nextInt() {
        return Integer.parseInt(next());
    }    
    
    public long nextLong() {
        return Long.parseLong(next());
    }

    public double nextDouble() {
        return Double.parseDouble(next());
    }

    public float nextFloat() {
        return Float.parseFloat(next());
    }    
}