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 restaurant{
	static int[] start, end, dp;
	static class order implements Comparable<order>{
		int s, e;
		order(int s, int e){
			this.s = s;
			this.e = e;
		}
		public int compareTo(order o) {
			return s-o.s;
		}
	}
	public static void main(String[] args) throws IOException {
		BufferedReader br = new BufferedReader(new InputStreamReader(System.in));
		int n = Integer.parseInt(br.readLine());
		start = new int[n];
		end = new int[n];
		dp = new int[n];
		Arrays.fill(dp, -1);
		PriorityQueue<order> sort = new PriorityQueue<order>();
		for (int i = 0; i < n; i++) {
			String[] line = br.readLine().split(" ");
			sort.add(new order(Integer.parseInt(line[0]), Integer.parseInt(line[1])));
		}
		for (int i = 0; i < n; i++) {
			start[i] = sort.peek().s;
			end[i] = sort.poll().e;
		}
		System.out.println(1+dp(0));
	}
	static int dp(int n) {
		if (n >= start.length) {
			return 0;
		}
		if (dp[n] != -1) {
			return dp[n];
		}
		int ans = 0;
		int search = search(end[n], n, start.length);
		if (search > n) {
				ans = dp(search)+1;
		}
		dp[n] = Integer.max(ans, dp(n+1));
		return dp[n];
	}
	static int search(int n, int l, int h) {
		if (l == h) {
			if (h == start.length) {
				return -1;
			}
			return l;
		}
		if (l+1 == h) {
			if (h == start.length) {
				return -1;
			}
			if (start[l] > n) {
				return l;
			}
			return h;
		}
		int mid = (h+l)/2;
		if (start[mid] <= n) {
			return search(n,mid,h);
		}
		return search(n,l,mid);
	}
}
