#pragma GCC optimize("O3", "unroll-loops")
//#pragma GCC target("avx2")
#include <bits/stdc++.h>
#include <stdio.h>

using namespace std;
#define ull unsigned long long
#define si short int
#define ll long long
#define pb push_back
#define pii pair<int, int>
#define pil pair<int, ll>
#define pli pair<ll, int>
#define pll pair<ll, ll>
#define piii pair<pair<int, int>, int>
#define piiii pair<pair<int, int>, pair<int, int>>

/*-----------------------------------------------------MATH------------------------------------------------*/
inline ll gcd(ll a, ll b) {
    while (b) {
        a %= b;
        swap(a, b);
    }
    return a;
}

inline ll lcm(ll a, ll b) { return a / gcd(a, b) * b; }

inline ll pwm(ll xx, ll pow, ll MD) {
    if (pow < 0) { pow = pow % (MD - 1) + MD - 1; }
    ll mlt = 1;
    while (pow) {
        if (pow & 1) {
            mlt *= xx;
            mlt %= MD;
        }
        xx *= xx;
        pow >>= 1;
        xx %= MD;
    }
    return mlt;
}

inline ll gcdex(ll a, ll b, ll &x, ll &y) {
    if (b == 0) {
        x = 1;
        y = 0;
        return a;
    }
    ll xx, yy;
    ll gc = gcdex(b, a % b, yy, xx);
    x = xx;
    y = yy - (a / b) * xx;
    return gc;
}

inline int inv(ll r, int _mod) { return pwm(r % _mod, _mod - 2, _mod); }

inline int64_t hilbertOrder(int x, int y, int pow, int rotate) {
    if (pow == 0) {
        return 0;
    }
    int hpow = 1 << (pow - 1);
    int seg = (x < hpow) ? (
            (y < hpow) ? 0 : 3
    ) : (
                      (y < hpow) ? 1 : 2
              );
    seg = (seg + rotate) & 3;
    const int rotateDelta[4] = {3, 0, 0, 1};
    int nx = x & (x ^ hpow), ny = y & (y ^ hpow);
    int nrot = (rotate + rotateDelta[seg]) & 3;
    int64_t subSquareSize = int64_t(1) << (2 * pow - 2);
    int64_t ans = seg * subSquareSize;
    int64_t add = hilbertOrder(nx, ny, pow - 1, nrot);
    ans += (seg == 1 || seg == 2) ? add : (subSquareSize - add - 1);
    return ans;
}

/*-----------------------------------------------------MATH------------------------------------------------*/
ll mod = 998244353;
int mxn=2e5+1;
vector<ll> t(4*mxn+1, 0);
vector<ll> tAdd(4*mxn+1, 0);
vector<pll> arr(mxn, {0,0});
void build(int v, int vl, int vr){
    if(vl==vr) t[v]=arr[vl].second;
    else{
        int tmp=(vl+vr)>>1;
        build(2*v, vl, tmp);
        build(2*v+1,tmp+1, vr);
        t[v]=t[2*v]+t[2*v+1];
    }
}
void push(int v){
    tAdd[2*v]+=tAdd[v];
    tAdd[2*v+1]+=tAdd[v];
    t[v]+=tAdd[v];
    tAdd[v]=0;
}
ll get(int v, int vl, int vr, int l, int r){
    if(l>r) return 0;
    if(vl==l && vr==r){
        return t[v]+tAdd[v];
    }
    int tmp=(vl+vr)>>1;
    push(v);
    ll a=get(2*v, vl, tmp, l ,min(tmp, r));
    ll b=get(2*v+1, tmp+1, vr, max(tmp+1, l) , r);
    return a+b;
}

void update(int v, int vl, int vr, int l, int r, ll cnt){
    if(l>r) return;
    if(vl==l && vr==r){
        tAdd[v]+=cnt;
        return;
    }
    int tmp=(vl+vr)>>1;
    push(v);
    update(2*v, vl, tmp, l ,min(tmp, r), cnt);
    update(2*v+1, tmp+1, vr, max(tmp+1, l) , r, cnt);
    t[v]=t[2*v]+t[2*v+1]+tAdd[2*v]+tAdd[2*v+1];
}


void solve(){
    int n;
    cin>>n;
    ll d;
    cin>>d;
    ll a;
    cin>>a;
    for(int i=0;i<n;i++) cin>>arr[i].first>>arr[i].second;
    sort(arr.begin(), arr.begin()+n);    
    build(1, 0, n-1);
    ll ans=0;
    for(int i=0;i<n;i++){
        ll wht=get(1, 0, n-1, i,i);
        //cout<<wht<<" "<<i<<endl;
        if(wht<=0) continue;
        int l=i;
        int r=n;
        while(r-l>1){
            int m=(r+l)/2;
            if(arr[m].first>arr[i].first+(ll)(2*d)){
                r=m;
            }
            else l=m;
        }
        ll cn=(wht+a-1)/a;
        update(1, 0, n-1,i,l,-cn*a);
        ans+=cn;
    }
    cout<<ans<<endl;
}
int main() {
    ios::sync_with_stdio(false);
    cin.tie(nullptr);
    //freopen("C:\\Users\\Maximus\\CLionProjects\\Codeforces\\BestTeam\\output.txt", "r", stdin);
    //freopen("C:\\Users\\Maximus\\CLionProjects\\Codeforces\\BestTeam\\output.txt", "w", stdout);
    unsigned int beg_time = clock();

    int n = 1;
    for (int i = 0; i < n; i++) solve();


    unsigned int end_time = clock();
    //cout<<endl<<endl<<end_time-beg_time;

    return 0;
}

Measured memory_bytes: 15872