import java.io.*
import java.util.*
import java.lang.*
import java.lang.Math.*

fun bsIdxLte(A: LongArray, X: Long, includeEqual:Boolean = false): Int {
    val N = A.size
    if (N == 0) return -1
    val xLess: (Long)->Boolean = if (includeEqual) {
        { Y:Long -> X < Y }
    } else {
        { Y:Long -> X <= Y }
    }
    if (xLess(A[0])) return -1
    var l = 0; var r = N
    while (l < r - 1) {
        val m = (l + r) / 2
        if (xLess(A[m])) {
            r = m
        } else {
            l = m
        }
    }
    return l
}
fun bsIdxGte(A: LongArray, X: Long, includeEqual:Boolean = false): Int {
    val N = A.size
    if (N == 0) return N
    val xGreater: (Long)->Boolean = if (includeEqual) {
        { Y:Long -> X > Y }
    } else {
        { Y:Long -> X >= Y }
    }
    if (xGreater(A[N-1])) return N
    val xLess: (Long)->Boolean = if (includeEqual) {
        { Y:Long -> X <= Y }
    } else {
        { Y:Long -> X < Y }
    }
    var l = -1; var r = N - 1
    while (l + 1 < r) {
        val m = (l + r) / 2
        if (xLess(A[m])) {
            r = m
        } else {
            l = m
        }
    }
    return r
}
data class IntLongPair(val first: Int, val second: Long)
class SegTreeSumP(val P: ArrayList<IntLongPair>) {
    private var sg = LongArray(0)
    private var sg2 = LongArray(0)
    private var pos = LongArray(P.size){0}
    var size = 0
        private set
    init {
        val N = P.size
        //P.sortBy { it.first }
        for (i in 0 until N) {
            pos[i] = P[i].first.toLong()
        }
        var sz = 1
        while (sz < N) {
            sz = sz shl 1
        }
        this.size = sz
        sg = LongArray(sz shl 1){0}
        sg2 = LongArray(sz shl 1){0}
    }

    private fun add(i: Int, j: Int, X: Long, v: Int = 0, l: Int = 0, r:Int = this.size) {
        if (r <= i || j <= l) {
            return
        }
        if (i <= l && r <= j) {
            this.sg2[v] += X
        } else {
            sg[v] += (min(j, r) - max(i, l)) * X
            val m = (l + r) / 2
            add(i, j, X, v * 2 + 1, l, m)
            add(i, j, X, v * 2 + 2, m, r)
        }
    }
    fun addPos(ix: Int, jx: Int, X: Long) {
        val i = max(bsIdxLte(pos, ix.toLong(), true), 0)
        val j = min(bsIdxGte(pos, jx.toLong(), true), pos.size)

        if (i == j) this.add(i, X)
        else this.add(i,j,X)
    }

    private fun add(i: Int, X: Long) {
        add(i, i+1, X)
    }

    fun addPos(ix: Int, X: Long) {
        val i = max(bsIdxLte(pos, ix.toLong(), true), 0)
        this.add(i, X)
    }

    private fun sum(i: Int, j: Int, v: Int = 0, l: Int = 0, r: Int = this.size): Long {
        if (r <= i || j <= l) {
            return 0L
        } else if (i <= l && r <= j) {
            return sg[v] + (r - l) * sg2[v]
        } else {
            val base = (min(j, r) - max(i, l)) * sg2[v]
            val m = (l + r) / 2
            val vl = sum(i, j, 2 * v + 1, l, m)
            val vr = sum(i, j, 2 * v + 2, m, r)
            return base + vl + vr
        }
    }
    fun sumPos(ix: Int, jx: Int): Long {
        val i = max(bsIdxLte(pos, ix.toLong(), true), 0)
        val j = min(bsIdxGte(pos, jx.toLong(), true), pos.size)
        return this.sum(i, j)
    }

    fun getPos(ix: Int): Long {
        val i = max(bsIdxLte(pos, ix.toLong(), true), 0)
        return this.sum(i, i+1)
    }
}

fun greedy(XH: ArrayList<IntLongPair>, D: Int, A: Long): Long {
    val N = XH.size
    val sgt = SegTreeSumP(XH)
    for (i in 0 until N) {
        val (x, h) = XH[i]
        sgt.addPos(x, h)
    }

    var cnt = 0L
    for (i in 0 until N) {
        val x = XH[i].first
        val h = sgt.getPos(x)

        if (h <= 0) continue
        val ct = (h+A-1)/A
        val xr = min(x+2L*D, 1e9.toLong()).toInt()
        val xl = max(0, xr - 2*D)
        sgt.addPos(xl, xr + 1, -A*ct)

        cnt += ct
    }

    return cnt
}


fun solve() {
    val (N, D, A) = rd.readIntArray()
    val XH = ArrayList<IntLongPair>(N)
    for (i in 0 until N) {
        val (x, h) = rd.readIntArray()
        XH.add(IntLongPair(x,h.toLong()))
    }
    XH.sortBy { it.first }

    val ans = greedy(XH, D, A.toLong())

    println(ans)
}


//val rd = debug.Reader("abc", "153", "f", "sample-1")
val rd = Reader()


fun main(args: Array<String>) {
    try {
        var exception: Throwable? = null
        val sth = Thread(null, SolveThread(), "solveThread", 128 * 1024 * 1024)
        sth.setUncaughtExceptionHandler { _, e -> exception = e }
        sth.start(); sth.join()
        if (exception != null) throw exception!!
    } catch (e: Exception) { throw e }
}
const val MOD = 1_000_000_007L; const val INF = Int.MAX_VALUE/2; const val LINF = Long.MAX_VALUE/2
const val EPS = 1e-9; fun DBLEQ(a: Double, b: Double): Boolean {return abs(a - b) < EPS}
data class IntPair(val first: Int, val second: Int)
data class To(val idx: Int, val cost: Long, val col: Int)
fun <T>edge(V: Int): Array<ArrayList<T>> { return Array(V){ArrayList<T>()} }
val errPrintln: (Any) -> Unit = { msg -> System.err.println(msg) }
fun rAssert(exp: Boolean, lazyMsg: () -> String = {""}) {
    if (!exp) { val msg = lazyMsg(); errPrintln("EAssert Error: $msg"); throw Error(msg) }
}
fun tAssert(exp: Boolean, lazyMsg: () -> String = {""}) {
    if (!exp) { val msg = lazyMsg(); errPrintln("TAssert Error: $msg"); Thread.sleep(3000) }
}
class SolveThread : Runnable {
    override fun run() { solve() }
}
class Reader {
    private val br = BufferedReader(InputStreamReader(System.`in`))
    val readString: () -> String = { br.readLine() }
    val readInt: () -> Int = { br.readLine().toInt() }
    val readLong: () -> Long = { br.readLine().toLong() }
    val readIntArray: () -> IntArray = { br.readLine().split(' ').map { it.toInt() }.toIntArray() }
    val readLongArray: () -> LongArray = { br.readLine().split(' ').map { it.toLong() }.toLongArray() }
    val readListInt: () -> List<Int> = { br.readLine().split(' ').map { it.toInt() } }
    val readListLong: () -> List<Long> = { br.readLine().split(' ').map { it.toLong() } }
}


Measured memory_bytes: 77988