#include <bits/stdc++.h>

#define debug(x)
#define ll long long
#define all(x) (x).begin(), (x).end()
#define rall(x) (x).rbegin(), (x).rend()
#define sq(x) ((x) * (x))
#define PRECISION 30

using namespace std;

template<class T> int check_mod(T a, T b) { return (a % b) ? 1 : 0; }
template<class T> void maxi(T &a, T b) { a = max(a, b); return; }
template<class T> void mini(T &a, T b) { a = min(a, b); return; }

bool is_prime(int a) { if (a == 2) return true; if (!(a & 1) || a == 1) return false; for (int i = 3; i * i <= a; i += 2) if (!(a % i)) return false; return true; }
bool is_prime(ll a) { if (a == 2) return true; if (!(a & 1) || a == 1) return false; for (ll i = 3; i * i <= a; i += 2) if (!(a % i)) return false; return true; }
bool is_palindrome(string s) { int len = (int)s.length(); int mid = len >> 1; for (int i = 0; i < mid; i++) if (s[i] != s[len - i - 1]) return false; return true; }
int gcd(int a, int b) { while (b) { int mod = a % b; a = b; b = mod; } return a; }
int lcm(int a, int b) { return a / gcd(a, b) * b; }
int binpow(int a, int b) { int res = 1; while (b) { if (b & 1) res *= a; a *= a; b >>= 1; } return res; }
int binpow(int a, int b, int MODULO) { int res = 1; while (b) { if (b & 1) { res *= a; res %= MODULO; } a *= a;  a %= MODULO; b >>= 1; } return res; }
ll gcd(ll a, ll b) { while (b) { ll mod = a % b; a = b; b = mod; } return a; }
ll lcm(ll a, ll b) { return a / gcd(a, b) * b; }
ll binpow(ll a, ll b) { ll res = 1; while (b) { if (b & 1) res *= a; a *= a; b >>= 1; } return res; }
ll binpow(ll a, ll b, ll MODULO) { ll res = 1; while (b) { if (b & 1) { res *= a; res %= MODULO; } a *= a;  a %= MODULO; b >>= 1; } return res; }
string binary(int N) { if (!N) return "0"; string bin = ""; while (N) { bin += '0' + (N & 1); N >>= 1; } reverse(all(bin)); return bin; }
string binary(ll N) { if (!N) return "0"; string bin = ""; while (N) { bin += '0' + (N & 1); N >>= 1; } reverse(all(bin)); return bin; }
           
const int INF = 2147483547;           // Max int value - 100 so it will not overflow
const int MODULO = 1000000007;
const int _MODULO = 998244353;
const ll INF64 = 9223372036854775707; // Max long long value - 100 so it will not overflow
const ll MODULO64 = 1000000007;
const ll _MODULO64 = 998244353;
const double epsilon = 10e-6;
const double PI = acos(-1);

struct monster {
	ll x, h;
};

bool cmp(monster a, monster b) {
	return a.x < b.x;	
}

int n;
vector<ll> tree, lazy, h;
 
void build(int node, int nl, int nr) {
	if (nl == nr) {
		tree[node] = h[nl];
		return;
	}
	int mid = (nl + nr) / 2;
	build(2 * node, nl, mid);
	build(2 * node + 1, mid + 1, nr);
	tree[node] = tree[2 * node] + tree[2 * node + 1];
	return;
}
 
void update(int node, int nl, int nr, int l, int r, ll v) {
	if (r < nl || nr < l)
		return;
	if (l <= nl && nr <= r) {
		tree[node] += v;
		lazy[node] += v;
		return;
	}
	tree[2 * node] += lazy[node];
	tree[2 * node + 1] += lazy[node];
	lazy[2 * node] += lazy[node];
	lazy[2 * node + 1] += lazy[node];
	lazy[node] = 0;
	int mid = (nl + nr) / 2;
	update(2 * node, nl, mid, l, r, v);
	update(2 * node + 1, mid + 1, nr, l, r, v);
	tree[node] = tree[2 * node] + tree[2 * node + 1];
	return;
}
 
ll query(int node, int nl, int nr, int l, int r) {
	if (r < nl || nr < l)
		return 0;
	if (l <= nl && nr <= r)
		return tree[node];
	tree[2 * node] += lazy[node];
	tree[2 * node + 1] += lazy[node];
	lazy[2 * node] += lazy[node];
	lazy[2 * node + 1] += lazy[node];
	lazy[node] = 0;
	int mid = (nl + nr) / 2;
	return query(2 * node, nl, mid, l, r) + query(2 * node + 1, mid + 1, nr, l, r);
}

int main() {
#ifdef LOCAL
	freopen("input.txt", "r", stdin);
	auto t1 = chrono::high_resolution_clock::now();
    #define debug(x) cerr << #x << " = " << x << "\n";                        
#endif
	ios_base::sync_with_stdio(false);
	cin.tie(NULL);
	ll radius, damage;
	cin >> n >> radius >> damage;
	vector<monster> m(n);
	h.resize(n);
	tree.resize(n << 2);
	lazy.resize(n << 2);
	for (int i = 0; i < n; ++i) {
		cin >> m[i].x >> m[i].h;
	}
	sort(all(m), cmp);
	vector<ll> x(n);
	for (int i = 0; i < n; ++i) {
		h[i] = m[i].h;
		x[i] = m[i].x;
	}
	build(1, 0, n - 1);
	vector<ll> l(n);
	for (int i = 1; i < n; ++i)
		l[i] = lower_bound(x.begin(), x.end(), x[i] - 2 * radius) - x.begin();
	ll ans = 0;
	for (int r = n - 1; r + 1; --r) {
		ll H = query(1, 0, n - 1, r, r);
		if (H <= 0) continue;
		ll cnt = (H + damage - 1) / damage;
		ans += cnt;
		update(1, 0, n - 1, l[r], r, -cnt * damage);		
	}
	cout << ans << '\n';
#ifdef LOCAL
	auto t2 = chrono::high_resolution_clock::now();
	cerr << "Running time " << chrono::duration_cast<chrono::nanoseconds>(t2 - t1).count() << " nanoseconds" << endl;
#endif
	return 0;
}

Measured memory_bytes: 20608