object Main extends App{
    def readLine() = io.StdIn.readLine()
    
    val n = readLine().toInt
    val robots = Iterator.continually(readLine()).take(n).map(_.split(' ').map(_.toLong)).toArray.sortBy(_(0)).map {
        case Array(x, l) => Array(x - l, x + l)
    }.toArray
    
    def interference(robots: Array[Array[Long]], index: Int) = {
        val Array(left, right, _*) = robots(index)
        
        def findLeft(leftIndex: Int): Int = if (leftIndex == -1)
            0
        else if (robots(leftIndex)(1) <= left)
            leftIndex + 1
        else
            findLeft(leftIndex - 1)
        
        def findRight(rightIndex: Int): Int = if (rightIndex == robots.length)
            robots.length - 1
        else if (robots(rightIndex)(0) >= right)
            rightIndex - 1
        else
            findRight(rightIndex + 1)
        
        findRight(index) - findLeft(index)
    }
    
    def removeRobots(robots: Array[Array[Long]]): Array[Array[Long]] = if (robots.forall(_(2) == 0))
        robots
    else {
        robots.find(_(2) == 1) match {
            case Some(elem) =>
                val next = robots.filter(_ != elem)
                val recalc = (0 until next.length).map { i =>
                    val r = next(i)
                    if (r(2) == 0)
                        r
                    else
                        Array(r(0), r(1), interference(next, i))
                }.toArray
                removeRobots(recalc)
            case _ => throw new Exception("想定外")
        }
    }
    
    val filtered = (0 until n).map { i =>
        val r = robots(i)
        val in = interference(robots, i)
        Array(r(0), r(1), in)
    }.filter(_(2) <= 1).toArray
    
    val recalc = (0 until filtered.length).map { i =>
        val r = filtered(i)
        if (r(2) == 0)
            r
        else
            Array(r(0), r(1), interference(filtered, i))
    }.toArray
    
    val answer = removeRobots(recalc)
    
    println(answer.length)
}
