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.Arrays;
import java.util.StringTokenizer;


public class ProblemA {
    public static void main(String[] args) {
        int testMode = 0;
        String testInput = "6\n" +
                "4 8\n" +
                "1 5\n" +
                "4 7\n" +
                "2 5\n" +
                "1 3\n" +
                "6 8";
        /*-------------------------------------------------------------------------------------------------------*/
        FastReader in = new FastReader(testMode == 0 ? System.in : new ByteArrayInputStream(testInput.getBytes()));
        PrintWriter out = new PrintWriter(System.out);
        new ProblemSolver().solve(in, out);
        out.close();
    }
}

class ProblemSolver {
    int[] A;
    int[] B;
    Pair[] C;

    void solve(FastReader in, PrintWriter out) {
        int N = in.nextInt();
        C = new Pair[N];
        for (int i = 0; i < N; i++) {
            int a = in.nextInt();
            int b = in.nextInt();
            C[i] = new Pair(a, b);
        }
        Arrays.sort(C);
        int t = 0;
        int res = 0;
        for (int i = 0; i < N; i++) {
            if (C[i].a > t) {
                res += 1;
                t = C[i].b;
            }
        }
        out.println(res);
    }
}

class Pair implements Comparable<Pair> {
    public int a;
    public int b;

    public Pair(int a, int b) {
        this.a = a;
        this.b = b;
    }

    public int compareTo(Pair o) {
        if (this.b < o.b) return -1;
        if (this.b > o.b) return 1;
        return (this.a - o.a);
    }
}

class FastReader extends BufferedReader {
    private StringTokenizer st;

    public FastReader(InputStream is) {
        super(new InputStreamReader(is));
    }

    public String nextToken() {
        try {
            while (st == null || !st.hasMoreElements()) {
                st = new StringTokenizer(readLine());
            }
            return st.nextToken();
        } catch (IOException e) {
            return null;
        }
    }

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

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

    public int[] nextArrayInt(int size) {
        int[] ret = new int[size];
        for (int i = 0; i < size; i++) {
            ret[i] = nextInt();
        }
        return ret;
    }
}