using System;
using System.Collections.Generic;

namespace AtCoder.ARC096
{
    public struct Sushi
    {
        public long Distance { get; set; }
        public int Calorie { get; set; }
    }

    public class ARC096D
    {
        private int SushiNum { get; set; }

        private long LengthOfCounter { get; set; }

        private Sushi[] Sushis { get; set; }

        private IDictionary<int, int> LeftMostEfficient = new Dictionary<int, int>();

        private IDictionary<int, int> RightMostEfficient = new Dictionary<int, int>();

        private IDictionary<int, long> LeftCalorieSum = new Dictionary<int, long>();

        private IDictionary<int, long> RightCalorieSum = new Dictionary<int, long>();

        private IDictionary<int, int> RightEfficient = new Dictionary<int, int>();

        public static void Main(string[] args)
        {
            string[] lineArgs = null;
            int sushiNum = 0;
            long lengthOfCounter = 0;
            Sushi[] sushis;

            lineArgs = Console.ReadLine().Split(' ');

            sushiNum = int.Parse(lineArgs[0]);
            lengthOfCounter = long.Parse(lineArgs[1]);
            sushis = new Sushi[sushiNum];

            for (int index = 0; index < sushiNum; index++)
            {
                lineArgs = Console.ReadLine().Split(' ');
                sushis[index] = new Sushi()
                {
                    Distance = long.Parse(lineArgs[0]),
                    Calorie = int.Parse(lineArgs[1]),
                };
            }

            Array.Sort(sushis, (Sushi x, Sushi y) => x.Distance.CompareTo(y.Distance));
            Console.WriteLine(new ARC096D(sushiNum, lengthOfCounter, sushis).GetMaxCal());
        }

        public ARC096D(int sushiNum, long lengthOfCounter, Sushi[] sushis)
        {
            this.SushiNum = sushiNum;
            this.LengthOfCounter = lengthOfCounter;
            this.Sushis = sushis;
            this.InitCalorieSum();
            this.InitMostEfficient();
        }

        public long GetMaxCal()
        {
            int rindex = 0;
            long maxCal = 0;
            long lc = 0;
            long rc = 0;
            for (int index = 0; index < this.SushiNum; index++)
            {
                int le = this.LeftMostEfficient[index];
                rindex = this.SushiNum <= le + 1 ? -1 : le + 1;
                int re = 0 <= rindex ? this.RightMostEfficient[rindex] : -1;

                lc = (0 <= le ? (this.LeftCalorieSum[le] - this.Sushis[le].Distance * 2) : 0) + (0 <= re ? (this.RightCalorieSum[re] - (this.LengthOfCounter - this.Sushis[re].Distance)) : 0);
                rc = (0 <= le ? (this.LeftCalorieSum[le] - this.Sushis[le].Distance) : 0) + (0 <= re ? (this.RightCalorieSum[re] - (this.LengthOfCounter - this.Sushis[re].Distance) * 2) : 0);

                maxCal = Math.Max(maxCal, lc);
                maxCal = Math.Max(maxCal, rc);

                this.DebugLog(string.Format("index: {0}, le: {1}, re: {2}, lc: {3}, rc: {4}", index, le, re, lc, rc));
            }
            return maxCal;
        }

        private void InitCalorieSum()
        {
            long cal = 0;

            this.DebugLog("Left sum");
            for (int index = 0; index < this.SushiNum; index++)
            {
                cal += this.Sushis[index].Calorie;
                this.LeftCalorieSum[index] = cal;
                this.DebugLog(string.Format("\t{0}={1}", index, cal));
            }

            this.DebugLog("Right sum");
            cal = 0;
            for (int index = this.SushiNum - 1; 0 <= index; index--)
            {
                cal += this.Sushis[index].Calorie;
                this.RightCalorieSum[index] = cal;
                this.DebugLog(string.Format("\t{0}={1}", index, cal));
            }
        }

        private void InitMostEfficient()
        {
            long cal = 0;
            long maxCal = 0;
            for (int mi = 0; mi < this.SushiNum; mi++)
            {
                maxCal = 0;
                this.LeftMostEfficient[mi] = -1;
                for (int ci = 0; ci <= mi; ci ++)
                {
                    cal = this.LeftCalorieSum[ci] - this.Sushis[ci].Distance;
                    if (maxCal < cal)
                    {
                        this.LeftMostEfficient[mi] = ci;
                        maxCal = cal;
                    }
                }
                this.DebugLog(string.Format("left most efficient max: {0}, eff: {1}, maxCal: {2}", mi, this.LeftMostEfficient[mi], maxCal));
            }
            for (int mi = this.SushiNum - 1; 0 <= mi; mi--)
            {
                maxCal = 0;
                this.RightMostEfficient[mi] = -1;
                for (int ci = mi; ci < this.SushiNum; ci++)
                {
                    cal = this.RightCalorieSum[ci] - (this.LengthOfCounter - this.Sushis[ci].Distance);
                    if (maxCal < cal)
                    {
                        this.RightMostEfficient[mi] = ci;
                        maxCal = cal;
                    }
                }
                this.DebugLog(string.Format("right most efficient max: {0}, eff: {1}, maxCal: {2}", mi, this.RightMostEfficient[mi], maxCal));
            }
        }

        private void DebugLog(string format, params object[] objects)
        {
#if DEBUG
            Console.Error.WriteLine(string.Format(format, objects));
#endif
        }
    }
}