The clique problem is one of the most well-known NP-complete problems. Under some simplification it can be formulated as follows. Consider an undirected graph G. It is required to find a subset of vertices C of the maximum size such that any two of them are connected by an edge in graph G. Sounds simple, doesn't it? Nobody yet knows an algorithm that finds a solution to this problem in polynomial time of the size of the graph. However, as with many other NP-complete problems, the clique problem is easier if you consider a specific type of a graph.

Consider n distinct points on a line. Let the i-th point have the coordinate xi and weight wi. Let's form graph G, whose vertices are these points and edges connect exactly the pairs of points (i, j), such that the distance between them is not less than the sum of their weights, or more formally: |xi - xj| ≥ wi + wj.

Find the size of the maximum clique in such graph.

Input

The first line contains the integer n (1 ≤ n ≤ 200 000) — the number of points.

Each of the next n lines contains two numbers xi, wi (0 ≤ xi ≤ 109, 1 ≤ wi ≤ 109) — the coordinate and the weight of a point. All xi are different.

Output

Print a single number — the number of vertexes in the maximum clique of the given graph.

Examples

Input

4
2 3
3 1
6 1
0 2


Output

3

Note

If you happen to know how to solve this problem without using the specific properties of the graph formulated in the problem statement, then you are able to get a prize of one million dollars!

The picture for the sample test.

<image>
import java.util.Arrays;
import java.io.InputStream;
import java.io.InputStreamReader;
import java.io.BufferedReader;
import java.util.List;
import java.math.BigInteger;
import java.io.PrintStream;
import java.io.OutputStream;
import java.io.PrintWriter;
import java.util.Comparator;
import java.io.IOException;
import java.util.StringTokenizer;

/**
 * Built using CHelper plug-in
 * Actual solution is at the top
 * @author shu_mj @ http://shu-mj.com
 */
public class Main {
	public static void main(String[] args) {
		InputStream inputStream = System.in;
		OutputStream outputStream = System.out;
		Scanner in = new Scanner(inputStream);
		PrintWriter out = new PrintWriter(outputStream);
		TaskB solver = new TaskB();
		solver.solve(1, in, out);
		out.close();
	}
}

class TaskB {
    Scanner in;
    PrintWriter out;

    public void solve(int testNumber, Scanner in, PrintWriter out) {
        this.in = in;
        this.out = out;
        run();
    }

    void run() {
        int n = in.nextInt();
        PII[] ps = new PII[n];
        for (int i = 0; i < n; i++) {
            ps[i] = new PII(in.nextInt(), in.nextInt());
        }
        Algo.sort(ps);
        int[] dp = new int[n + 1];
        T t = NULL;
        for (int i = 0; i < n; i++) {
            PII p = ps[i];
            T[] ts = splitKey(t, p.x - p.y);
            dp[i + 1] = ts[0].max + 1;
            t = merge(ts[0], ts[1]);
            ts = splitKey(t, p.x + p.y);
            T[] ss0 = splitKey(ts[0], p.x + p.y - 1);
            if (ss0[1].val < dp[i + 1]) ss0[1] = new T(p.x + p.y, dp[i + 1]);
            t = merge(merge(ss0[0], ss0[1]), ts[1]);
        }
        out.println(Algo.max(dp));
    }


    class T {
        int key, val, max, size;
        double p;
        T left, right;

        T(int key, int val, int max, int size, double p, T left, T right) {
            this.key = key;
            this.val = val;
            this.max = max;
            this.size = size;
            this.p = p;
            this.left = left;
            this.right = right;
        }

        T(int key, int val) {
            this(key, val, val, 1, Math.random(), NULL, NULL);
        }

        T change(T left, T right) {
            size = left.size + right.size + 1;
            max = Math.max(Math.max(left.max, right.max), val);
            this.left = left;
            this.right = right;
            return this;
        }
        T push() {
            if (this != NULL) {

            }
            return this;
        }
    }

    T NULL = new T(0, 0, 0, 0, 0, null, null);

    T[] splitKey(T t, int key) {
        T[] res;
        if (t == NULL) {
            res = new T[] { NULL, NULL };
        } else if (key < t.push().key) {
            res = splitKey(t.left, key);
            res[1] = t.change(res[1], t.right);
        } else {
            res = splitKey(t.right, key);
            res[0] = t.change(t.left, res[0]);
        }
        return res;
    }

    T merge(T t1, T t2) {
        if (t1 == NULL) return t2;
        if (t2 == NULL) return t1;
        if (t1.p < t2.p) return t1.push().change(t1.left, merge(t1.right, t2));
        return t2.push().change(merge(t1, t2.left), t2.right);
    }


}

class Scanner {
    BufferedReader br;
    StringTokenizer st;

    public Scanner(InputStream in) {
        br = new BufferedReader(new InputStreamReader(in));
        eat("");
    }

    private void eat(String s) {
        st = new StringTokenizer(s);
    }

    public String nextLine() {
        try {
            return br.readLine();
        } catch (IOException e) {
            return null;
        }
    }

    public boolean hasNext() {
        while (!st.hasMoreTokens()) {
            String s = nextLine();
            if (s == null)
                return false;
            eat(s);
        }
        return true;
    }

    public String next() {
        hasNext();
        return st.nextToken();
    }

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

}

class PII implements Comparable<PII> {
    public int x;
    public int y;

    public PII(int x, int y) {
        this.x = x;
        this.y = y;
    }

    public int compareTo(PII o) {
        if (x != o.x) return x - o.x;
        return y - o.y;
    }

    public boolean equals(Object o) {
        if (this == o) return true;
        if (!(o instanceof PII)) return false;

        PII pii = (PII) o;

        if (x != pii.x) return false;
        if (y != pii.y) return false;

        return true;
    }

    public int hashCode() {
        int result = x;
        result = 31 * result + y;
        return result;
    }

    public String toString() {
        return "(" + x + ", " + y + ")";
    }
}

class Algo {


    public static int max(int[] is) {
        int res = Integer.MIN_VALUE;
        for (int i = 0; i < is.length; i++) {
            res = Math.max(res, is[i]);
        }
        return res;
    }

    public static <T extends Comparable<T>> void sort(T[] ts) {
        sort(ts, 0, ts.length);
    }

    public static <T extends Comparable<T>> void sort(T[] ts, int b, int e) {
        sort(ts, ts.clone(), b, e);
    }

    private static <T extends Comparable<T>> void sort(T[] ts, T[] cs, int b, int e) {
        if (e - b > 1) {
            int m = (b + e) / 2;
            sort(ts, cs, b, m);
            sort(ts, cs, m, e);
            for (int i = b, j = m, k = b; k < e; ) {
                if (j >= e || i < m && ts[i].compareTo(ts[j]) < 0) cs[k++] = ts[i++];
                else cs[k++] = ts[j++];
            }
            System.arraycopy(cs, b, ts, b, e - b);
        }
    }

}

