#include <bits/stdc++.h>
using namespace std;
using ll = long long;
using ld = long double;
using VI = vector<int>;
using VL = vector<ll>;
using VS = vector<string>;
template<class T> using PQ = priority_queue<T, vector<T>, greater<T>>;
#define FOR(i,a,n) for(int i=(a);i<(n);++i)
#define eFOR(i,a,n) for(int i=(a);i<=(n);++i)
#define rFOR(i,a,n) for(int i=(n)-1;i>=(a);--i)
#define erFOR(i,a,n) for(int i=(n);i>=(a);--i)
#define each(i, a) for(auto &i : a)
#define SORT(a) sort(a.begin(),a.end())
#define rSORT(a) sort(a.rbegin(),a.rend())
#define fSORT(a,f) sort(a.begin(),a.end(),f)
#define all(a) a.begin(),a.end()
#define out(y,x) ((y)<0||h<=(y)||(x)<0||w<=(x))
#define tp(a,i) get<i>(a)
#define line cout << "-----------------------------\n" 
#define ENDL(i,n) ((i) == (n) - 1 ? "\n" : " ")
#define elif else if
#define stop system("pause")
constexpr ll INF = 1000000000;
constexpr ll LLINF = 1LL << 60;
constexpr ll mod = 1000000007;
constexpr ll MOD = 998244353;
constexpr ld eps = 1e-10;
constexpr ld pi = 3.1415926535897932;
template<class T>inline bool chmax(T& a, const T& b) { if (a < b) { a = b; return true; }return false; }
template<class T>inline bool chmin(T& a, const T& b) { if (a > b) { a = b; return true; }return false; }
inline void init() { cin.tie(nullptr); cout.tie(nullptr); ios::sync_with_stdio(false); cout << fixed << setprecision(15); }
template<class T>inline istream& operator>>(istream& is, vector<T>& v) { for (auto& a : v)is >> a; return is; }
template<class T>inline istream& operator>>(istream& is, deque<T>& v) { for (auto& a : v)is >> a; return is; }
template<class T, class U>inline istream& operator>>(istream& is, pair<T, U>& p) { is >> p.first >> p.second; return is; }
template<class T>inline vector<T> vec(size_t a) { return vector<T>(a); }
template<class T>inline vector<T> defvec(T def, size_t a) { return vector<T>(a, def); }
template<class T, class... Ts>inline auto vec(size_t a, Ts... ts) { return vector<decltype(vec<T>(ts...))>(a, vec<T>(ts...)); }
template<class T, class... Ts>inline auto defvec(T def, size_t a, Ts... ts) { return vector<decltype(defvec<T>(def, ts...))>(a, defvec<T>(def, ts...)); }
template<class T>inline void print(const T& a) { cout << a << "\n"; }
template<class T, class... Ts>inline void print(const T& a, const Ts&... ts) { cout << a << " "; print(ts...); }
template<class T>inline void print(const vector<T>& v) { for (int i = 0; i < v.size(); ++i)cout << v[i] << (i == v.size() - 1 ? "\n" : " "); }
template<class T>inline void print(const vector<vector<T>>& v) { for (auto& a : v)print(a); }
inline string reversed(const string& s) { string t = s; reverse(all(t)); return t; }

#define REP(i,n) FOR(i,0,n)
#define REPS(i,n) FOR(i,1,n+1)
#define RFOR(i,l,r) for(int i=(l);i>=(r);--i)
#define RREP(i,n) RFOR(i,n-1,0)
#define RREPS(i,n) RFOR(i,n,1)
#define SZ(x) ((int)(x).size())
template<class T = int>using V = vector<T>;
template <class Monoid, class E>
struct LazySegmentTree {
private:
	using F = function<Monoid(Monoid, Monoid)>;
	using G = function<Monoid(Monoid, E)>;
	using H = function<E(E, E)>;
	int n, height;
	V<Monoid> Node;
	V<E> Lazy;
	F f;
	G g;
	H h;
	Monoid Monoid_unit, init_data;
	E e_unit;

	void build(V<Monoid> vec) {
		Node.assign(2 * n, init_data);
		REP(i, n) Node[i + n] = vec[i];
		RREP(i, n) Node[i] = f(Node[i << 1], Node[i << 1 | 1]);
		Lazy.assign(2 * n, e_unit);
		height = 0;
		for (int i = 1; i <= n; i *= 2) height++;
	}

	void eval(int left, int right) {
		left += n, right += n - 1;
		RREPS(i, height) {
			int l = left >> i, r = right >> i;
			Lazy[l << 1] = h(Lazy[l << 1], Lazy[l]);
			Lazy[l << 1 | 1] = h(Lazy[l << 1 | 1], Lazy[l]);
			Node[l] = g(Node[l], Lazy[l]);
			Lazy[l] = e_unit;
			Lazy[r << 1] = h(Lazy[r << 1], Lazy[r]);
			Lazy[r << 1 | 1] = h(Lazy[r << 1 | 1], Lazy[r]);
			Node[r] = g(Node[r], Lazy[r]);
			Lazy[r] = e_unit;
		}
	}

public:
	LazySegmentTree(V<Monoid> vec, F f_, G g_, H h_, Monoid Monoid_unit_, E e_unit_)
		:n(SZ(vec)), f(f_), g(g_), h(h_), Monoid_unit(Monoid_unit_), e_unit(e_unit_) {
		build(vec);
	}

	LazySegmentTree(int n_, F f_, G g_, H h_, Monoid Monoid_unit_, E e_unit_)
		:n(n_), f(f_), g(g_), h(h_), Monoid_unit(Monoid_unit_), e_unit(e_unit_), init_data(Monoid_unit_) {
		build(V<Monoid>(n, init_data));
	}

	LazySegmentTree(int n_, F f_, G g_, H h_, Monoid Monoid_unit_, E e_unit_, Monoid init_data_)
		:n(n_), f(f_), g(g_), h(h_), Monoid_unit(Monoid_unit_), e_unit(e_unit_), init_data(init_data_) {
		build(V<Monoid>(n, init_data));
	}

	void update(int left, int right, E operator_) {
		eval(left, right);
		left += n, right += n;
		int L0 = left / (left & -left);
		int R0 = right / (right & -right);
		while (left < right) {
			if (left & 1) Lazy[left] = h(Lazy[left], operator_);
			if (right & 1) Lazy[right - 1] = h(Lazy[right - 1], operator_);
			(left += 1) >>= 1;
			right >>= 1;
		}
		left = L0;
		right = R0;
		while (left > 1) {
			left >>= 1;
			Node[left] = f(g(Node[left << 1], Lazy[left << 1]), g(Node[left << 1 | 1], Lazy[left << 1 | 1]));
			Lazy[left] = e_unit;
		}
		while (right > 1) {
			right >>= 1;
			Node[right] = f(g(Node[right << 1], Lazy[right << 1]), g(Node[right << 1 | 1], Lazy[right << 1 | 1]));
			Lazy[right] = e_unit;
		}
	}

	//半開区間[a, b)の区間クエリ
	Monoid query(int left, int right) {
		eval(left, right);
		Monoid a = Monoid_unit, b = Monoid_unit;
		left += n, right += n;
		while (left < right) {
			if (left & 1) a = f(a, g(Node[left], Lazy[left]));
			if (right & 1) b = f(g(Node[right - 1], Lazy[right - 1]), b);
			(left += 1) >>= 1;
			right >>= 1;
		}
		return f(a, b);
	}

	Monoid operator[](int i) {
		return query(i, i + 1);
	}
};

int main() {
	init();

	int n; ll d, a; cin >> n >> d >> a;
	vector<pair<ll, ll>> xh(n); cin >> xh;
	SORT(xh);
	VL x(n), h(n);
	FOR(i, 0, n)tie(x[i], h[i]) = xh[i];
	auto f = [](ll x, ll y) {return x + y; };
	LazySegmentTree<ll, ll> seg(h, f, f, f, 0, 0);;
	ll ans = 0;
	FOR(i, 0, n) {
		if (seg[i] <= 0)continue;
		ans += (seg[i] + a - 1) / a;
		int j = upper_bound(all(x), x[i] + d * 2) - x.begin();
		seg.update(i, j, (seg[i] + a - 1) / a * -a);
	}
	print(ans);

	return 0;
}

Measured memory_bytes: 18780