import std.algorithm;
import std.array;
import std.container;
import std.conv;
import std.math;
import std.numeric;
import std.range;
import std.stdio;
import std.string;
import std.typecons;

alias Monster = Tuple!(long, "x", long, "h");

long calc(long d, long a, Monster[] ms) {
    int n = cast(int)ms.length;
    ms.sort!"a.x < b.x";
    auto xs = ms.map!"a.x".assumeSorted;

    auto bit = new BIT2!long(ms.length);

    foreach (i; 0..n) bit.add(i+1, i+1, ms[i].h);
    long ans = 0;
    foreach (i; 0..n) {
        auto s = bit.sum(i+1) - bit.sum(i);
        if (s <= 0) continue; // 生きているモンスターはいない

        // モンスターを倒すのに必要な爆弾の数
        long cnt = (s + a - 1) / a;

        // 左端から爆弾がとどく範囲
        auto len = cast(int)xs.lowerBound(ms[i].x + 2 * d + 1).length;
        bit.add(i+1, len, -a * cnt);
        ans += cnt;
    }
    return ans;
}

void main() {
    long n, d, a; scan(n, d, a);
    Monster[] ms;
    foreach (_; 0..n) {
        long x, h; scan(x, h);
        ms ~= Monster(x, h);
    }
    writeln(calc(d, a, ms));
}

void scan(T...)(ref T a) {
    string[] ss = readln.split;
    foreach (i, t; T) a[i] = ss[i].to!t;
}
T read(T=string)() { return readln.chomp.to!T; }
T[] reads(T)() { return readln.split.to!(T[]); }
alias readints = reads!int;

class BIT2(T) {
    private T[] _data0;
    private T[] _data1;

    T __sum(const T[] data, int p) const {
        T s = 0;
        while (p > 0) {
            s += data[p];
            p -= p & -p;
        }
        return s;
    }

    void __add(T[] data, int p, T x) {
        while (p < data.length) {
            data[p] += x;
            p += p & -p;
        }
    }

    /// [1, n]
    this(size_t n) {
        _data0 = new T[n + 10];
        _data1 = new T[n + 10];
    }

    /// [1, ind] の和(1 based)
    T sum(int ind) const {
        return __sum(_data0, ind) + __sum(_data1, ind) * ind;
    }

    /// 区間 [l, r] に x を加える(1 based)
    void add(int l, int r, T x) {
        __add(_data0, l, -x * (l - 1));
        __add(_data0, r + 1, x * r);
        __add(_data1, l, x);
        __add(_data1, r + 1, -x);
    }
}
