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.io.PrintWriter;
import java.util.ArrayList;
import java.util.Collections;
import java.util.List;

public class Solution {

    static int getMaxNumOfOrders(List<Order> ord) {
        Collections.sort(ord) ;
        int count = 1;
        int end = ord.get(0).end;
        for (int i=1; i<ord.size(); i++) {
            if (end < ord.get(i).start) {
                count++;
                end = ord.get(i).end;
            }
        }
        return count;
    }

    public static void main(String[] args) throws IOException {
        BufferedReader input = new BufferedReader(new InputStreamReader(System.in)) ;
        PrintWriter output = new PrintWriter(System.out);
        List<Order> orders = new ArrayList<>() ;

        int n = Integer.parseInt(input.readLine());
        for (int i=0; i<n; i++) {
            String[] values = input.readLine().split(" ");
            int l = Integer.parseInt(values[0]) ;
            int r = Integer.parseInt(values[1]) ;
            orders.add(new Order(l,r)) ;
        }
        input.close();

        output.println(getMaxNumOfOrders(orders));
        output.close();
    }
}

class Order implements Comparable<Order> {
    int start;
    int end;

    Order(int start, int end) {
        this.start = start;
        this.end = end ;
    }

    @Override
    public int compareTo(Order order) {
        return Integer.compare(this.end, order.end);
    }
}
