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

public class Problem implements Runnable {

    private static final boolean ONLINE_JUDGE = System.getProperty("ONLINE_JUDGE") != null;
    private BufferedReader in;
    private PrintWriter out;
    private StringTokenizer tok = new StringTokenizer("");

    private void init() throws FileNotFoundException {
        Locale.setDefault(Locale.US);
        String fileName = "file";
        if (ONLINE_JUDGE || fileName.isEmpty()) {
            in = new BufferedReader(new InputStreamReader(System.in));
            out = new PrintWriter(System.out);
        } else {
            in = new BufferedReader(new FileReader(fileName + ".in"));
            out = new PrintWriter(fileName + ".out");
        }
    }
    String readString() {
        while (!tok.hasMoreTokens()) {
            try {
                tok = new StringTokenizer(in.readLine());
            } catch (Exception e) {
                return null;
            }
        }
        return tok.nextToken();
    }

    int readInt() {
        return Integer.parseInt(readString());
    }

    int[] readArray(int N) {
        int[] a = new int[N];
        for (int i = 0; i < N; i++)
            a[i] = readInt();
        return a;
    }

    long[] readArrayL(int N) {
        long[] a = new long[N];
        for (int i = 0; i < N; i++)
            a[i] = readLong();
        return a;
    }

    long readLong() {
        return Long.parseLong(readString());
    }

    double readDouble() {
        return Double.parseDouble(readString());
    }

    long gcd(long a, long b) {
        return (b == 0 ? a : gcd(b, a % b));
    }

    int gcd(int a, int b) {
        return (b == 0 ? a : gcd(b, a % b));
    }

    public static void main(String[] args) {
        new Problem().run();
    }

    public void run() {
        try {
            init();
            solve();
            out.close();
        } catch (Exception e) {
            e.printStackTrace();
            System.exit(-1);
        }
    }
    private void solve() throws IOException {
        int n=readInt();
        Point[] z=new Point[n];
        for (int i=0;i<n;i++)
            z[i]=new Point(readInt(),readInt());
        Arrays.sort(z,(a,b)->Integer.compare(a.y,b.y));
        int time=0,ans=0;
        for (int i=0;i<n;i++)
            if (z[i].x>time){
                ans++; time=z[i].y;
            }
        out.println(ans);
    }
    
}