package main

import (
	"fmt"
	"io"
	"os"
	"sort"
)

type Edge struct {
	w   int64
	idx int
}

func find(parent []int, x int) int {
	r := x
	for parent[r] != r {
		r = parent[r]
	}
	for parent[x] != x {
		p := parent[x]
		parent[x] = r
		x = p
	}
	return r
}

func main() {
	data, _ := io.ReadAll(os.Stdin)
	pos := 0
	nextInt := func() int64 {
		for pos < len(data) && (data[pos] < '0' || data[pos] > '9') && data[pos] != '-' {
			pos++
		}
		sign := int64(1)
		if data[pos] == '-' {
			sign = -1
			pos++
		}
		var v int64
		for pos < len(data) && data[pos] >= '0' && data[pos] <= '9' {
			v = v*10 + int64(data[pos]-'0')
			pos++
		}
		return v * sign
	}

	n := int(nextInt())
	a := nextInt()

	edges := make([]Edge, max(0, n-1))
	weight := make([]int64, n)

	var prevD int64
	for i := 0; i < n; i++ {
		d := nextInt()
		c := nextInt()
		weight[i] = a - c
		if i > 0 {
			diff := d - prevD
			edges[i-1] = Edge{w: diff * diff, idx: i - 1}
		}
		prevD = d
	}

	sort.Slice(edges, func(i, j int) bool {
		if edges[i].w == edges[j].w {
			return edges[i].idx < edges[j].idx
		}
		return edges[i].w < edges[j].w
	})

	parent := make([]int, n)
	size := make([]int, n)
	left := make([]int, n)
	sum := make([]int64, n)
	pref := make([]int64, n)
	suf := make([]int64, n)
	best := make([]int64, n)

	ans := weight[0]
	for i := 0; i < n; i++ {
		parent[i] = i
		size[i] = 1
		left[i] = i
		sum[i] = weight[i]
		pref[i] = weight[i]
		suf[i] = weight[i]
		best[i] = weight[i]
		if weight[i] > ans {
			ans = weight[i]
		}
	}

	for _, e := range edges {
		rx := find(parent, e.idx)
		ry := find(parent, e.idx+1)

		lr, rr := rx, ry
		if left[lr] > left[rr] {
			lr, rr = rr, lr
		}

		mergedSum := sum[lr] + sum[rr]

		mergedPref := pref[lr]
		if sum[lr]+pref[rr] > mergedPref {
			mergedPref = sum[lr] + pref[rr]
		}

		mergedSuf := suf[rr]
		if sum[rr]+suf[lr] > mergedSuf {
			mergedSuf = sum[rr] + suf[lr]
		}

		mergedBest := best[lr]
		if best[rr] > mergedBest {
			mergedBest = best[rr]
		}
		if suf[lr]+pref[rr] > mergedBest {
			mergedBest = suf[lr] + pref[rr]
		}

		root, other := rx, ry
		if size[root] < size[other] {
			root, other = other, root
		}
		parent[other] = root
		size[root] += size[other]
		if left[other] < left[root] {
			left[root] = left[other]
		}
		sum[root] = mergedSum
		pref[root] = mergedPref
		suf[root] = mergedSuf
		best[root] = mergedBest

		cand := mergedBest - e.w
		if cand > ans {
			ans = cand
		}
	}

	fmt.Print(ans)
}

func max(a, b int) int {
	if a > b {
		return a
	}
	return b
}