#include <iostream>
#define NMAX 2150

using namespace std;

struct carnat{
	long t, p;
};

carnat a[NMAX], b[NMAX];

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

long N, C, vector[NMAX], v[NMAX], diff[NMAX];

int swap(int a, int b)
{
	int aux = v[a];
	v[a] = v[b];
	v[b] = aux;

	return 0;
}
int addHeap(int k)
{
	v[k] = k;
	while (a[v[k]].p < a[v[(k - 1) / 2]].p)
	{
		swap(k, (k - 1) / 2);
		k = (k - 1) / 2;
	}

	return 0;
}

int delHeap(int k)
{
	b[k].p = a[v[0]].p;
	b[k].t = a[v[0]].t;

	v[0] = v[N - k - 1];
	int i = 0;
	while ((2 * i + 2 <= N - k - 2) && ((a[v[i]].p > a[v[2 * i + 1]].p) || (a[v[i]].p > a[v[2 * i + 2]].p)))
	{	
		if ((a[v[i]].p > a[v[2 * i + 1]].p) && (a[v[i]].p > a[v[2 * i + 2]].p))
		{	
			if (a[v[2 * i + 1]].p > a[v[2 * i + 2]].p)
			{
				swap(2 * i + 2, i);
				i = 2 * i + 2;
			}
			else
			{
				swap(2 * i + 1, i);
				i = 2 * i + 1;
			}
		}
		else
		{
			if (a[v[i]].p > a[v[2 * i + 1]].p)
			{
				swap(2 * i + 1, i);
				i = 2 * i + 1;
			}
			else
			{
				swap(2 * i + 2, i);
				i = 2 * i + 2;
			}
		}
	}
	if ((2 * i + 1 <= N - k - 2) && (a[v[i]].p > a[v[2 * i + 1]].p))
	{
		swap(2 * i + 1, i);
	}
	return 0;
}


int main()
{
	fscanf(f, "%ld %ld", &N, &C);
	for (int i = 0; i < N; ++i)
	{
		fscanf(f, "%ld %ld", &a[i].p, &a[i].t);
		addHeap(i);
	}
	fclose(f);

	for (int i = 0; i < N; ++i)
	{
		delHeap(i);
	}
	diff[0] = -1000;
	for (int i = 1; i < N; ++i)
	{
		diff[i] = (b[i].p - b[i - 1].p) * C;
	}

	long max = 0, old = 0, n = 0, G = 0;
	
	for (int i = 0; i < N; ++i)
	{
		//pretul stabilit este b[i].t
		if (b[i].t <= b[0].t)
		{
		    if (b[i].t - C > 0)
		    {
                old = b[i].t - C;
            }
            else
            {
                old = 0;
            }
		}
		else
		{
			old = 0;
		}
		if (old > max)
		{
            max = old;
        }
        
		for (int j = 1; j < N; ++j)
		{
			if (b[i].t <= b[j].t)
			{
				G = b[i].t;
			}
			else
			{
				G = 0;
			}
			
			if (old == 0)
			{
                 if (G - C > 0)
                 {
                     old = G - C;
                     if (old > max)
                     {
                        max = old;
                     }
                 }
                 else
                 {
                     old = 0;
                 }
            }
            else
			{
			if (G - C > old - diff[j] + G)
			{
                n = G - C;
            }
            else
            {
                n = old - diff[j] + G;
            }
            if (n > max)
            {
                max = n;
            }
            if (n > 0)
            {
               old = n;
            }
            else
            {
               old = 0;
            }
            }
		}
	}

	fprintf(g, "%ld", max);
	fclose(g);
	
	return 0;
}