#include<stdio.h>
#include<vector>
#include<algorithm>

#define maxn 30005
#define inf (1<<29)

using namespace std;

FILE*f=fopen("magazin.in","r");
FILE*g=fopen("magazin.out","w");

int p,n,m,D,sol;
int dp[maxn][6],desus[maxn],dejos[maxn],combinat[maxn];
vector<int>P[maxn];

inline void solve () {
	
	dp[1][0] = dejos[1];
	dp[1][1] = 2*(m+1);
	dp[1][2] = combinat[1];
	dp[1][3] = inf;
	dp[1][4] = m+1;
	dp[1][5] = inf;
	
	for ( int i = 2 ; i <= n ; ++i ){
		
		dp[i][0] = dp[i-1][0]+dejos[i]+D;
		dp[i][0] = min(dp[i][0],dp[i-1][1]+dejos[i]+D);
		dp[i][0] = min(dp[i][0],dp[i-1][2]+2*(m+1)+dejos[i]+D);
		dp[i][0] = min(dp[i][0],dp[i-1][3]+m+1+D+dejos[i]);
		dp[i][0] = min(dp[i][0],dp[i-1][4]+m+1+D+dejos[i]);
		dp[i][0] = min(dp[i][0],dp[i-1][5]+m+1+D+dejos[i]);
		
		dp[i][1] = dp[i-1][0]+D+2*(m+1);
		dp[i][1] = min(dp[i][1],dp[i-1][1]+3*D+combinat[i]);
		dp[i][1] = min(dp[i][1],dp[i-1][2]+3*D+2*(m+1));
		dp[i][1] = min(dp[i][1],dp[i-1][3]+D+m+1);
		dp[i][1] = min(dp[i][1],dp[i-1][4]+D+m+1);
		dp[i][1] = min(dp[i][1],dp[i-1][5]+3*D+m+1);
		
		dp[i][2] = dp[i-1][0]+min(combinat[i],desus[i])+D;
		dp[i][2] = min(dp[i][2],dp[i-1][1]+min(combinat[i],desus[i])+D);
		dp[i][2] = min(dp[i][2],dp[i-1][2]+3*D+min(combinat[i],desus[i]));
		dp[i][2] = min(dp[i][2],dp[i-1][3]+m+1+D+min(combinat[i],desus[i]));
		dp[i][2] = min(dp[i][2],dp[i-1][4]+m+1+D+min(combinat[i],desus[i]));
		dp[i][2] = min(dp[i][2],dp[i-1][5]+m+1+D+min(combinat[i],desus[i]));
		
		dp[i][3] = dp[i-1][3]+desus[i]+D;
		dp[i][3] = min(dp[i][3],dp[i-1][4]+desus[i]+D);
		dp[i][3] = min(dp[i][3],dp[i-1][5]+2*(m+1)+desus[i]+D);
		dp[i][3] = min(dp[i][3],dp[i-1][0]+m+1+D+desus[i]);
		dp[i][3] = min(dp[i][3],dp[i-1][1]+m+1+D+desus[i]);
		dp[i][3] = min(dp[i][3],dp[i-1][2]+m+1+D+desus[i]);
		
		dp[i][4] = dp[i-1][3]+D+2*(m+1);
		dp[i][4] = min(dp[i][4],dp[i-1][4]+3*D+combinat[i]);
		dp[i][4] = min(dp[i][4],dp[i-1][5]+3*D+2*(m+1));
		dp[i][4] = min(dp[i][4],dp[i-1][0]+D+m+1);
		dp[i][4] = min(dp[i][4],dp[i-1][1]+D+m+1);
		dp[i][4] = min(dp[i][4],dp[i-1][2]+3*D+m+1);
		
		dp[i][5] = dp[i-1][3]+min(combinat[i],dejos[i])+D;
		dp[i][5] = min(dp[i][5],dp[i-1][4]+min(combinat[i],dejos[i])+D);
		dp[i][5] = min(dp[i][5],dp[i-1][5]+3*D+min(combinat[i],dejos[i]));
		dp[i][5] = min(dp[i][5],dp[i-1][0]+m+1+D+min(combinat[i],dejos[i]));
		dp[i][5] = min(dp[i][5],dp[i-1][1]+m+1+D+min(combinat[i],dejos[i]));
		dp[i][5] = min(dp[i][5],dp[i-1][2]+m+1+D+min(combinat[i],dejos[i]));
	}
	
	sol = min(dp[n][0],dp[n][1]);
}

int main () {
	
	fscanf(f,"%d %d %d %d",&p,&n,&m,&D);
	
	int x,y;
	for ( int i = 1 ; i <= p ; ++i ){
		fscanf(f,"%d %d",&x,&y);
		P[x].push_back(y);
	}
	
	for ( int i = 1 ; i <= n ; ++i ){
		sort(P[i].begin(),P[i].end());
		
		if ( !P[i].empty() ){
			dejos[i] = 2*P[i].back();
			desus[i] = 2*(m+1-P[i][0]);
			
			combinat[i] = min(dejos[i],desus[i]);
			for ( int j = 0 ; j < P[i].size()-1 ; ++j ){
				if ( combinat[i] > 2*(P[i][j]+m+1-P[i][j+1]) ){
					combinat[i] = 2*(P[i][j]+m+1-P[i][j+1]);
				}
			}
		}
	}
	
	solve();
	
	fprintf(g,"%d\n",sol);
	
	fclose(f);
	fclose(g);
	
	return 0;
}