传送门：点我

A plane is flying at a constant height of hh meters above the ground surface. Let's consider that it is flying from the point (−10^9,h)(−10^9,h) to the point (10^9,h)(10^9,h) parallel with Ox axis.

A glider is inside the plane, ready to start his flight at any moment (for the sake of simplicity let's consider that he may start only when the plane's coordinates are integers). After jumping from the plane, he will fly in the same direction as the plane, parallel to Ox axis, covering a unit of distance every second. Naturally, he will also descend; thus his second coordinate will decrease by one unit every second.

There are ascending air flows on certain segments, each such segment is characterized by two numbers x1 x1 and x2 x2 (x1<x2x1<x2) representing its endpoints. No two segments share any common points. When the glider is inside one of such segments, he doesn't descend, so his second coordinate stays the same each second. The glider still flies along Ox axis, covering one unit of distance every second.

If the glider jumps out at 11, he will stop at 1010. Otherwise, if he jumps out at 22, he will stop at 1212.

Determine the maximum distance along OxOx axis from the point where the glider's flight starts to the point where his flight ends if the glider can choose any integer coordinate to jump from the plane and start his flight. After touching the ground the glider stops altogether, so he cannot glide through an ascending airflow segment if his second coordinate is 00.

Input

The first line contains two integers nn and hh (1≤n≤2⋅10^5,1≤h≤10^9)(1≤n≤2⋅10^5,1≤h≤10^9) — the number of ascending air flow segments and the altitude at which the plane is flying, respectively.

Each of the next nn lines contains two integers xi1xi1 and xi2xi2 (1≤xi1<xi2≤10^9)(1≤xi1<xi2≤10^9) — the endpoints of the ii-th ascending air flow segment. No two segments intersect, and they are given in ascending order.

Output

Print one integer — the maximum distance along OxOx axis that the glider can fly from the point where he jumps off the plane to the point where he lands if he can start his flight at any integer coordinate.

Examples

3 42 57 910 11

10

5 105 711 1216 2025 2630 33

18

1 10000000001 1000000000

1999999999

NOTE

思路：看到题目给2秒，大暴力二分找✔。算了下复杂度是O（NlogN），n是2e5，也可以接受。

首先，要明确的一点是，起点肯定是某个加速带的起点，因为这样才能保证有更多的空间，留给后面经过更多的加速带（简单的贪心）

　　　其次，既然是二分，那么肯定要是有序的，在这题我二分的是从我选定的起点，最远到能到的终点，中间可以经过多少加速带。因为距离是递增的，所以可以二分。

　　   即，把每个加速带中间的间隔，抽取出来作为一个数组，对这个数组进行二分，然后同时维护一个本身加速带的长度的一个前缀和，用来快速计算，经过加速带的距离。

　　   最后答案肯定是 ：能经过的加速带的距离+m   这个值的最大值

不知道还有没有更好的办法呀，还想学习一下。

暂时先这样子吧。

最后是代码：

#include<stdio.h>
#include<string.h>
#include<string>
#include<math.h>
#include<vector>
#include<queue>
#include<stack>
#include<map>
#include<set>
#include<iostream>
#include<algorithm>
using namespace std;
typedef long long LL;
struct note{int x,y;
}p[200010];
int a[200010];
int main()
{vector<int>v;int sum = 0,cnt = 0,n,m;a[cnt++] = 0;//a数组维护加速带的前缀和 scanf("%d %d",&n,&m);for(int i = 0 ; i < n ; i ++){scanf("%d %d",&p[i].x,&p[i].y);a[cnt] = a[cnt-1] + p[i].y - p[i].x;cnt++;if(i > 0){sum += p[i].x-p[i-1].y;v.push_back(sum);}//v向量用来保存加速带的前缀和
    }int ans = 0;for(int i = 0 ;i <= v.size(); i++){int  pos = lower_bound(v.begin(),v.end(),(i==0?0:v[i-1])+m)-v.begin();sum = a[pos+1]-a[i] + m;//加速带的长度+m ，即要更新的答案 ans = max(sum,ans);}printf("%d\n",ans);
}
/*
3 4
2 5
7 9
10 115 10
5 7
11 12
16 20
25 26
30 331 1000000000
1 1000000000
*/