#include <algorithm>
#include <cassert>
#include <iostream>
#include <vector>
#include <string>
#include <memory>
#include <iterator>
#include <queue>
#include <type_traits>
#include <fstream>
#include <unordered_map>
#include <unordered_set>
#include <iostream>
#include <stack>
#if defined (_MSC_VER)
#include <io.h>
// code specific to Visual Studio compiler
#else
#include "unistd.h"
#endif
#pragma warning(disable:4146)
using ull = unsigned long long;
using ll = long long;

class Input {
public:
    Input() { bufpos = bufend = buffer; eof = false; }
    bool Eof() { return eof; }
    char Peek() { if (bufpos == bufend) Grab(); return *bufpos; }
    unsigned char UPeek() { return static_cast<unsigned char>(Peek()); }
    void SkipWS();
    template<class T> T Get();
    void operator()() {}
    template<class Arg, class... Args> void operator()(Arg& arg, Args&... args) {
        arg = Get<Arg>();
        operator()(args...);
    }
private:
    static const int BUFSIZE = 1 << 16;
    char buffer[BUFSIZE];
    char* bufpos;
    char* bufend;
    bool eof;
    void Grab();
};

void Input::Grab() {
    if (eof) return;
    bufpos = buffer;
    bufend = buffer + read(0, buffer, BUFSIZE);
    if (bufend == bufpos) { eof = true; *bufpos = 0; }
}

template<> inline char Input::Get<char>() {
    char res = Peek();
    ++bufpos;
    return res;
}

void Input::SkipWS() {
    while (isspace(UPeek())) Get<char>();
}

template<> unsigned Input::Get<unsigned>() {
    SkipWS();
    unsigned x = 0;
    while (isdigit(UPeek())) {
        x = 10u * x + (Get<char>() - '0');
    }
    return x;
}

template<> int Input::Get<int>() {
    SkipWS();
    bool neg = false;
    if (Peek() == '-') { neg = true; Get<char>(); }
    unsigned x = Get<unsigned>();
    if (neg) x = -x;
    return static_cast<int>(x);
}

template<> ull Input::Get<ull>() {
    SkipWS();
    ull x = 0;
    while (isdigit(UPeek())) {
        x = 10ULL * x + (Get<char>() - '0');
    }
    return x;
}

template<> ll Input::Get<ll>() {
    SkipWS();
    bool neg = false;
    if (Peek() == '-') { neg = true; Get<char>(); }
    ull x = Get<ull>();
    if (neg) x = -x;
    return static_cast<ll>(x);
}

template<>
std::string Input::Get<std::string>() {
    SkipWS();
    std::string s;
    while (!Eof() && !isspace(UPeek())) s += Get<char>();
    return s;
}

class Output {
public:
    void Flush();
    Output() :bufpos(buffer), BUFLIMIT(buffer + BUFSIZE - 100) {}
    ~Output() { Flush(); }
    void Put(char c);
    void Put(unsigned x);
    void Put(int x);
    void Put(ull x);
    void Put(ll x);
    void Put(const char* s);
    void Put(const std::string& s);

    void operator()() {}
    template<class Arg, class... Args> void operator()(const Arg& arg, const Args&... args) {
        Put(arg);
        operator()(args...);
    }
private:
    static const int BUFSIZE = 1 << 16;
    char buffer[BUFSIZE];
    char* bufpos;
    char* BUFLIMIT;
};

void Output::Flush() {
    char* p = buffer;
    while (p < bufpos) {
        p += write(1, p, bufpos - p);
    }
    bufpos = buffer;
}

inline void Output::Put(char c) {
    *bufpos = c;
    ++bufpos;
    if (bufpos >= BUFLIMIT) Flush();
}

void Output::Put(unsigned x) {
    char* old = bufpos;
    do {
        *bufpos = char('0' + x % 10u);
        x /= 10u;
        ++bufpos;
    } while (x);
    std::reverse(old, bufpos);
    if (bufpos >= BUFLIMIT) Flush();
}

void Output::Put(int x) {
    if (x < 0) {
        Put('-'); Put(-static_cast<unsigned>(x));
    }
    else {
        Put(static_cast<unsigned>(x));
    }
}

void Output::Put(ull x) {
    char* old = bufpos;
    do {
        *bufpos = char('0' + x % 10u);
        x /= 10u;
        ++bufpos;
    } while (x);
    std::reverse(old, bufpos);
    if (bufpos >= BUFLIMIT) Flush();
}

void Output::Put(ll x) {
    if (x < 0) {
        Put('-'); Put(-static_cast<ull>(x));
    }
    else {
        Put(static_cast<ull>(x));
    }
}

void Output::Put(const char* s) {
    while (*s) Put(*s++);
}

void Output::Put(const std::string& s) {
    for (char c : s) Put(c);
}

Input IN;
Output OUT;
struct mine
{
	int id;
	ll pos = 0, range = 0;
	std::vector<int> explosion_sorted;
};

struct VectorHash {
    size_t operator()(const std::vector<int>* v) const {
	    const std::hash<int> hasher;
        size_t seed = 0;
        for (int i : *v) {
            seed ^= hasher(i) + 0x9e3779b9 + (seed<<6) + (seed>>2);
        }
        return seed;
    }
};
struct VectorEquals {
    bool operator()(const std::vector<int>* a, const std::vector<int>* b) const
    {
	    return *a == *b;
    }
};
using MySet = std::unordered_set<std::vector<int>*, VectorHash, VectorEquals>;
std::vector<mine> mines;
MySet explosions, explosions_tmp;

std::unordered_map<int, std::vector<int>*> cache;
std::vector<bool> processed;
std::vector<int> tmp_vec;
std::queue<mine*> tmp_queue;
std::pair<std::vector<int>*, bool> calc_explosion(mine& mine)
{
	auto it = cache.find(mine.id);
	if(it != cache.end())
		return {it->second, true};
	
	tmp_vec.clear();
	// go left
	tmp_vec.push_back(mine.id);
	const auto left_limit = mine.pos - mine.range;
	int pos = mine.id - 1;
	while(pos >= 0 && mines[pos].pos >= left_limit)
	{
		tmp_vec.push_back(mines[pos].id);
		--pos;
	}

	// go right
	const auto right_limit = mine.pos + mine.range;
	pos = mine.id + 1;
	while(pos < mines.size() && mines[pos].pos <= right_limit)
	{
		tmp_vec.push_back(mines[pos].id);
		++pos;
	}

	return {&tmp_vec, false};
}


void calc_explosion_root(mine& mine)
{
	std::fill(processed.begin(), processed.end(), false);
	tmp_queue.push(&mine);
	processed[mine.id] = true;
	mine.explosion_sorted.push_back(mine.id);
	
	while(!tmp_queue.empty())
	{
		const auto m = tmp_queue.front();
		tmp_queue.pop();

		const auto result = calc_explosion(*m);
		if(result.second)
		{
			for(auto exploded : *result.first)
			{
				if(!processed[exploded])
				{
					processed[exploded] = true;
					mine.explosion_sorted.push_back(exploded);
				}
			}
		}
		else
		{
			for(auto exploded : *result.first)
			{
				if(!processed[exploded])
				{
					tmp_queue.push(&mines[exploded]);
					processed[exploded] = true;
					mine.explosion_sorted.push_back(exploded);
				}
			}
		}
	}

	std::sort(mine.explosion_sorted.begin(), mine.explosion_sorted.end());
	explosions.insert(&mine.explosion_sorted);
	explosions_tmp.insert(&mine.explosion_sorted);
}

int main()
{
	//std::ifstream input("big1.in");
	int n;
	//input >> n;
	IN(n);
	mines.resize(n);
	processed.resize(n);
	tmp_vec.reserve(n);

	for(int i = 0; i < n; ++i)
	{
		//input >> mines[i].pos >> mines[i].range;
		IN(mines[i].pos, mines[i].range);
		mines[i].id = i;
	}

	std::vector<std::vector<int>*> new_explosions, new_explosions2;
	for(auto& mine : mines)
	{
		calc_explosion_root(mine);
		cache[mine.id] = &mine.explosion_sorted;
		new_explosions.push_back(&mine.explosion_sorted);
	}

	// do the magic
	tmp_vec.resize(n);
	auto tmp_ptr = new std::vector<int>();
	while(!new_explosions.empty())
	{
		for(auto explosion : explosions)
		{
			for(auto other_explosion : new_explosions)
			{
				if(explosion->front() == other_explosion->front() || explosion->back() == other_explosion->back())
                    continue;

				std::set_union(explosion->begin(), explosion->end(), 
				other_explosion->begin(), other_explosion->end(), 
                    std::inserter(*tmp_ptr, tmp_ptr->begin()));
				if(explosion->size() != tmp_ptr->size() || other_explosion->size() != tmp_ptr->size())
				{
					if(explosions_tmp.insert(tmp_ptr).second)
					{
						new_explosions2.push_back(tmp_ptr);
						tmp_ptr = new std::vector<int>();
					}
                    else
                    {
	                    tmp_ptr->clear();
                    }
				}
				else
                {
                    tmp_ptr->clear();
                }
			}
		}

		new_explosions.clear();
		std::swap(new_explosions, new_explosions2);
	}

	OUT(explosions_tmp.size() + 1);
	return 0;
}