#include <fstream>
#include <algorithm>
#include <cstring>
#include <vector>

using namespace std;

ifstream fin("magazin.in");
ofstream fout("magazin.out");

class MyInt {

public:

	int x;

	MyInt(void) { x = 0x3f3f3f3f; }
	MyInt(int val) : x(val) {}

	MyInt operator = (const MyInt& a) {
		x = a.x;
		return (*this);
	}

	MyInt operator + (const MyInt& a) {
		MyInt ret(x + a.x);
		return ret;
	}

	MyInt operator * (const MyInt& a) {
		MyInt ret(x * a.x);
		return ret;
	}

	bool operator < (const MyInt& a) {
		return x < a.x;
	}

	bool operator == (const MyInt& a) {
		return x == a.x;
	}

	void min(const MyInt& a) {
		x = std::min(x, a.x);
	}

	void max(const MyInt& a) {
		x = std::max(x, a.x);
	}

};

const int dim = 30005;
const int inf = 0x3f3f3f3f;

int objCount, n, m, d;
int up[dim], dn[dim], both[dim];

vector<int> obj[dim];

void precalc(void) {

	for (int i = 1; i <= n; ++i) {

		if (obj[i].empty())
			continue;

		sort(obj[i].begin(), obj[i].end());

		dn[i] = 2 * obj[i].back();
		up[i] = 2 * (m + 1 - obj[i].front());

		both[i] = min(up[i], dn[i]);

		for (int it = 0; it < (int)obj[i].size() - 1; ++it)
			both[i] = min(both[i], 2 * (m - (obj[i][it + 1] - obj[i][it] - 1)));

	}

}

MyInt dp[dim][6];

void solve(void) {
	
	dp[1][0] = inf;
	dp[1][1] = m + 1;
	dp[1][2] = inf;
	dp[1][3] = both[1];
	dp[1][4] = 2 * (m + 1);
	dp[1][5] = dn[1];

	for (int i = 2; i <= n; ++i) {

		dp[i][0].min(dp[i - 1][0] + 3 * d + min(both[i], dn[i]));
		dp[i][0].min(dp[i - 1][1] + min(both[i], dn[i]) + d);
		dp[i][0].min(dp[i - 1][2] + min(both[i], dn[i]) + d);
		dp[i][0].min(dp[i - 1][4] + m + 1 + d + min(both[i], dn[i]));
		dp[i][0].min(dp[i - 1][3] + m + 1 + d + min(both[i], dn[i]));
		dp[i][0].min(dp[i - 1][5] + m + 1 + d + min(both[i], dn[i]));

		dp[i][1].min(dp[i - 1][0] + 3 * d + 2 * (m + 1));
		dp[i][1].min(dp[i - 1][1] + 3 * d + both[i]);
		dp[i][1].min(dp[i - 1][2] + d + 2 * (m + 1));
		dp[i][1].min(dp[i - 1][3] + 3 * d + m + 1);
		dp[i][1].min(dp[i - 1][4] + d + m + 1);
		dp[i][1].min(dp[i - 1][5] + d + m + 1);

		dp[i][2].min(dp[i - 1][0] + 2 * (m + 1) + up[i] + d);
		dp[i][2].min(dp[i - 1][1] + up[i] + d);
		dp[i][2].min(dp[i - 1][2] + up[i] + d);
		dp[i][2].min(dp[i - 1][3] + m + 1 + d + up[i]);
		dp[i][2].min(dp[i - 1][4] + m + 1 + d + up[i]);
		dp[i][2].min(dp[i - 1][5] + m + 1 + d + up[i]);

		dp[i][3].min(dp[i - 1][0] + m + 1 + d + min(both[i], up[i]));
		dp[i][3].min(dp[i - 1][1] + m + 1 + d + min(both[i], up[i]));
		dp[i][3].min(dp[i - 1][2] + m + 1 + d + min(both[i], up[i]));
		dp[i][3].min(dp[i - 1][3] + 3 * d + min(both[i], up[i]));
		dp[i][3].min(dp[i - 1][4] + min(both[i], up[i]) + d);
		dp[i][3].min(dp[i - 1][5] + min(both[i], up[i]) + d);

		dp[i][4].min(dp[i - 1][0] + 3 * d + m + 1);
		dp[i][4].min(dp[i - 1][1] + d + m + 1);
		dp[i][4].min(dp[i - 1][2] + d + m + 1);
		dp[i][4].min(dp[i - 1][3] + 3 * d + 2 * (m + 1));
		dp[i][4].min(dp[i - 1][4] + 3 * d + both[i]);
		dp[i][4].min(dp[i - 1][5] + d + 2 * (m + 1));

		dp[i][5].min(dp[i - 1][0] + m + 1 + d + dn[i]);
		dp[i][5].min(dp[i - 1][1] + m + 1 + d + dn[i]);
		dp[i][5].min(dp[i - 1][2] + m + 1 + d + dn[i]);
		dp[i][5].min(dp[i - 1][3] + 2 * (m + 1) + dn[i] + d);
		dp[i][5].min(dp[i - 1][4] + dn[i] + d);
		dp[i][5].min(dp[i - 1][5] + dn[i] + d);

	}


	dp[n][5].min(dp[n][4]);
	fout << dp[n][5].x << '\n';

}

int main() {

	fin >> objCount >> n >> m >> d;

	for (int i = 1; i <= objCount; ++i) {

		int x, y; fin >> x >> y;
		obj[x].push_back(y);

	}

	precalc();

	solve();

	return 0;

}

//Trust me, I'm the doctor!