import scala.annotation.tailrec                                                                                                          
                                                                                                                                         
object StaticSushi3 extends App {                                                                                                        
  val N = MyPredef3.nextInt // 寿司の数                                                                                                      
  val C = MyPredef3.nextLong // 外周                                                                                                       
  val inputSushi :Stream[Stream[Long]] = Stream.fill(N, 2)(MyPredef3.nextLong) // 距離, calの配列                                             
                                                                                                                                         
  @tailrec                                                                                                                               
  def makeSushiStream(ind :Int, sumCal: Long, maxCal: Long, sushi :Stream[Stream[Long]] ,res :Stream[Sushi]): Stream[Sushi] = {          
    val target = sushi(ind)                                                                                                              
    val tCal = sumCal + target(1) - target(0)                                                                                            
    var tMaxCal = maxCal                                                                                                                 
    if (maxCal < tCal) {                                                                                                                 
      tMaxCal = tCal                                                                                                                     
    }                                                                                                                                    
    val tSushi = new Sushi(target(0), tMaxCal)                                                                                           
                                                                                                                                         
    if (ind < N - 1) {                                                                                                                   
      makeSushiStream(ind + 1, tCal + target(0), tMaxCal, sushi, res :+ tSushi)                                                          
    } else {                                                                                                                             
      res :+ tSushi                                                                                                                      
    }                                                                                                                                    
  }                                                                                                                                      
  val rSushi :Stream[Sushi] = makeSushiStream(0, 0, 0, inputSushi, Stream.empty[Sushi])                                                  
  val reverseSushi = inputSushi.reverse.map(x => Stream(C - x(0), x(1)))                                                                 
  val lSushi :Stream[Sushi] = makeSushiStream(0,0,0,reverseSushi, Stream.empty[Sushi])                                                   
                                                                                                                                         
  var rMax :Long = rSushi.maxBy(_.maxCal).maxCal                                                                                         
  for (i <- 0 until N - 1) {                                                                                                             
    val tMax = rSushi(i).maxCal - rSushi(i).dist + lSushi(N - 2 - i).maxCal                                                              
    if (tMax > rMax) rMax = tMax                                                                                                         
  }                                                                                                                                      
                                                                                                                                         
  var lMax :Long = lSushi.maxBy(_.maxCal).maxCal                                                                                         
  for (i <- 0 until N - 1) {                                                                                                             
    val tMax = lSushi(i).maxCal - lSushi(i).dist + rSushi(N - 2 - i).maxCal                                                              
    if (tMax > lMax) lMax = tMax                                                                                                         
  }                                                                                                                                      
                                                                                                                                         
  if (rMax > lMax) println(rMax)                                                                                                         
  else println(lMax)                                                                                                                     
}                                                                                                                                        
                                                                                                                                         
// 始点からの距離と、その時点での最大カロリーを持つ                                                                                                              
case class Sushi(dist: Long, maxCal: Long) {}                                                                                           
                                                                                                                                         
object MyPredef3 {                                                                                                                       
  @inline def rep(n: Int, f: => Unit): Unit = { var c = 0; while (c < n) { f; c += 1 } }                                                 
  @inline def rep(n: Int, f: Int => Unit): Unit = { var c = 0; while (c < n) { f(c); c += 1 } }                                          
                                                                                                                                         
  private val buf = new Array[Byte](1024); private var ptr = 0; private var len = 0                                                      
  @inline private def isPrintableChar(c: Int): Boolean = 33 <= c && c <= 126                                                             
  @inline private def hasNextByte(): Boolean =                                                                                           
    if (ptr >= len) { ptr = 0; len = System.in.read(buf); len > 0 } else { true }                                                        
  @inline private def hasNext(): Boolean = {                                                                                             
    while (hasNextByte() && !isPrintableChar(buf(ptr))) ptr += 1                                                                         
    hasNextByte()                                                                                                                        
  }                                                                                                                                      
  @inline private def readByte(): Byte =                                                                                                 
    if (hasNextByte()) { val res = buf(ptr); ptr += 1; res } else { -1 }                                                                 
  def next(): String = {                                                                                                                 
    if(!hasNext()) ???                                                                                                                   
    val sb = new StringBuilder; var b = readByte()                                                                                       
    while (isPrintableChar(b)) { sb.append(b.toChar); b = readByte() }                                                                   
    sb.toString                                                                                                                          
  }                                                                                                                                      
  def nextInt(): Int = {                                                                                                                 
    val n = nextLong()                                                                                                                   
    if (n < Int.MinValue || Int.MaxValue < n) ???                                                                                        
    n.toInt                                                                                                                              
  }                                                                                                                                      
  def nextLong(): Long = {                                                                                                               
    if(!hasNext()) ???                                                                                                                   
    var minus = false; var b = readByte()                                                                                                
    if (b == '-') { minus = true; b = readByte() }                                                                                       
    def go (b: Byte, n: Long = 0): Long =                                                                                                
      if ('0' <= b && b <= '9') { go(readByte(), n * 10 + b - '0') }                                                                     
      else if (minus) { -n } else { n }                                                                                                  
    go(b)                                                                                                                                
  }                                                                                                                                      
  def nextDouble(): Double = next.toDouble                                                                                               
}                                                                                                                                        
                                                                                                                                         