import std.stdio, std.algorithm, std.conv, std.array, std.string, std.math, std.typecons, std.numeric;
 
alias R = Tuple!(long, "x", long, "l");
 
void main()
{
    auto N = readln.chomp.to!int;
    R[] rs;
    foreach (_; 0..N) {
        auto xl = readln.split.to!(long[]);
        rs ~= R(xl[0], xl[1]);
    }
    sort(rs);
    auto NEXT = new int[](N);
    NEXT[N-1] = N;
    foreach (i; 0..N-1) {
        if (rs[i+1].x - rs[i].x>= rs[i+1].l + rs[i].l) {
            NEXT[i] = i+1;
        } else if (rs[N-1].x - rs[i].x < rs[N-1].l + rs[i].l) {
            NEXT[i] = N;
        } else {
            int l = i+1, r = N-1;
            while (l+1 < r) {
                auto m = (l+r)/2;
                if (rs[m].x - rs[i].x < rs[m].l + rs[i].l) {
                    l = m;
                } else {
                    r = m;
                }
            }
            NEXT[i] = r;
        }
    }
    auto DP = new int[](N);
    DP[] = -1;
 
    int solve(int i) {
        if (i == N) return 0;
        if (DP[i] == -1) {
            DP[i] = max(solve(i+1), solve(NEXT[i]) + 1);
        }
        return DP[i];
    }
 
    writeln(solve(0));
}