Problem:
Score : 1700 points

Problem Statement

There is a railroad in Takahashi Kingdom.
The railroad consists of N sections, numbered 1, 2, ..., N, and N+1 stations, numbered 0, 1, ..., N. Section i directly connects the stations i-1 and i.
A train takes exactly A_i minutes to run through section i, regardless of direction.
Each of the N sections is either single-tracked over the whole length, or double-tracked over the whole length.
If B_i = 1, section i is single-tracked; if B_i = 2, section i is double-tracked.
Two trains running in opposite directions can cross each other on a double-tracked section, but not on a single-tracked section.
Trains can also cross each other at a station.

Snuke is creating the timetable for this railroad. In this timetable, the trains on the railroad run every K minutes, as shown in the following figure. Here, bold lines represent the positions of trains running on the railroad. (See Sample 1 for clarification.)

When creating such a timetable, find the minimum sum of the amount of time required for a train to depart station 0 and reach station N, and the amount of time required for a train to depart station N and reach station 0.
It can be proved that, if there exists a timetable satisfying the conditions in this problem, this minimum sum is always an integer.

Formally, the times at which trains arrive and depart must satisfy the following:

Each train either departs station 0 and is bound for station N, or departs station N and is bound for station 0.

Each train takes exactly A_i minutes to run through section i. For example, if a train bound for station N departs station i-1 at time t, the train arrives at station i exactly at time t+A_i.

Assume that a train bound for station N arrives at a station at time s, and departs the station at time t. Then, the next train bound for station N arrives at the station at time s+K, and departs the station at time t+K. Additionally, the previous train bound for station N arrives at the station at time s-K, and departs the station at time t-K. This must also be true for trains bound for station 0.

Trains running in opposite directions must not be running on the same single-tracked section (except the stations at both ends) at the same time.

Constraints

1 \leq N \leq 100000

1 \leq K \leq 10^9

1 \leq A_i \leq 10^9

A_i is an integer.

B_i is either 1 or 2.

Partial Score

In the test set worth 500 points, all the sections are single-tracked. That is, B_i = 1.

In the test set worth another 500 points, N \leq 200.

Input

The input is given from Standard Input in the following format:

N K
A_1 B_1
A_2 B_2
:
A_N B_N

Output

Print an integer representing the minimum sum of the amount of time required for a train to depart station 0 and reach station N, and the amount of time required for a train to depart station N and reach station 0.
If it is impossible to create a timetable satisfying the conditions, print -1 instead.

Sample Input 1

3 10
4 1
3 1
4 1

Sample Output 1

26

For example, the sum of the amount of time in question will be 26 minutes in the following timetable:

In this timetable, the train represented by the red line departs station 0 at time 0, arrives at station 1 at time 4, departs station 1 at time 5, arrives at station 2 at time 8, and so on.

Sample Input 2

1 10
10 1

Sample Output 2

-1

Sample Input 3

6 4
1 1
1 1
1 1
1 1
1 1
1 1

Sample Output 3

12

Sample Input 4

20 987654321
129662684 2
162021979 1
458437539 1
319670097 2
202863355 1
112218745 1
348732033 1
323036578 1
382398703 1
55854389 1
283445191 1
151300613 1
693338042 2
191178308 2
386707193 1
204580036 1
335134457 1
122253639 1
824646518 2
902554792 2

Sample Output 4

14829091348

Solution in C++14 (GCC 5.4.1) (judge verdict: Accepted)

#include<cstdio>
#include<algorithm>
using namespace std;
typedef long long ll;
const int N=200200;
const ll oo=1000000000000000000ll;
int i,j,k,n,m,ch,ff,nls;
ll sum;
int Ls[N],a[N],b[N];
struct cc { int l,r;} A[N];
struct tree { int fg;ll mi;} T[N<<2];
void R(int &x) {
	x=0;ch=getchar();
	while (ch<'0' || '9'<ch) { if (ch=='-') ff=1;ch=getchar();}
	while ('0'<=ch && ch<='9') x=x*10+ch-'0',ch=getchar();
	if (ff) x=-x;
}
void W(ll x) {
	if (x<0) putchar('-'),x=-x;
	if (x>=10) W(x/10);
	putchar(x%10+'0');
}
int find(int x) {
	int l=1,r=nls,mid;
	while (l<r) {
		mid=(l+r)>>1;
		if (Ls[mid]==x) return mid;
		if (Ls[mid]<x) l=mid+1;
		else r=mid-1;
	}
	return l;
}
void down(int k) {
	if (T[k].fg) {
		T[k<<1].fg=T[k<<1|1].fg=1;
		T[k<<1].mi=T[k<<1|1].mi=oo;
		T[k].fg=0;
	}
}
void T_add(int L,int R,int x,ll y,int k) {
	T[k].mi=min(T[k].mi,y);
	if (L==R) return;
	down(k);
	int mid=(L+R)>>1;
	if (x<=mid) T_add(L,mid,x,y,k<<1);
	else T_add(mid+1,R,x,y,k<<1|1);
}
void T_clear(int L,int R,int l,int r,int k) {
	if (l>r) return;
	if (L==l && R==r) {
		T[k].fg=1;
		T[k].mi=oo;
		return;
	}
	int mid=(L+R)>>1;
	if (r<=mid) T_clear(L,mid,l,r,k<<1);
	else {
		if (l>mid) T_clear(mid+1,R,l,r,k<<1|1);
		else T_clear(L,mid,l,mid,k<<1),T_clear(mid+1,R,mid+1,r,k<<1|1);
	}
	T[k].mi=min(T[k<<1].mi,T[k<<1|1].mi);
}
ll T_min(int L,int R,int l,int r,int k) {
	if (l>r) return oo;
	if (L==l && R==r) return T[k].mi;
	down(k);
	int mid=(L+R)>>1;
	if (r<=mid) return T_min(L,mid,l,r,k<<1);
	if (l>mid) return T_min(mid+1,R,l,r,k<<1|1);
	return min(T_min(L,mid,l,mid,k<<1),T_min(mid+1,R,mid+1,r,k<<1|1));
}
void T_build(int L,int R,int k) {
	T[k].mi=Ls[L];
	if (L==R) return;
	int mid=(L+R)>>1;
	T_build(L,mid,k<<1);
	T_build(mid+1,R,k<<1|1);
}
ll T_bl(int L,int R,int k) {
	if (L==R) return T[k].mi-Ls[L];
	if (T[k].fg) return oo;
	int mid=(L+R)>>1;
	return min(T_bl(L,mid,k<<1),T_bl(mid+1,R,k<<1|1));
}
/*void T_BL(int L,int R,int k) {
	if (L==R) {
		printf("%d %lld\n",Ls[L],T[k].mi-Ls[L]+2ll*sum);
		return;
	}
	//if (T[k].fg) return oo;
	down(k);
	int mid=(L+R)>>1;
	T_BL(L,mid,k<<1),T_BL(mid+1,R,k<<1|1);
}*/
ll Query(int x) {
	return min(T_min(1,nls,x,nls,1)-x,T_min(1,nls,1,x,1)+m-x);
}
int main() {
	R(n);R(m);
	for (i=1;i<=n;i++) {
		R(a[i]);R(b[i]);
		sum+=a[i];
		if (b[i]==1 && 2*a[i]>m) return puts("-1"),0;
	}
	for (i=1;i<=n;i++) a[i]=(a[i]+a[i-1])%m;
	for (i=1;i<=n;i++) if (b[i]==1) A[i].l=2*(m-a[i])%m,A[i].r=2*(m-a[i-1])%m;
	for (i=1;i<=n;i++) Ls[++nls]=A[i].l,Ls[++nls]=A[i].r;
	sort(Ls+1,Ls+nls+1);
	int tmp=nls;nls=0;
	for (i=1;i<tmp;i++) if (Ls[i]!=Ls[i+1]) Ls[++nls]=Ls[i];
	if (tmp) Ls[++nls]=Ls[i];
	for (i=1;i<=n;i++) A[i].l=find(A[i].l),A[i].r=find(A[i].r);
	T_build(1,nls,1);
	for (i=n;i;i--) if (b[i]==1) {
		//printf("%d %d\n",Ls[A[i].l],Ls[A[i].r]);
		T_add(1,nls,A[i].l,A[i].l+Query(A[i].l),1);
		T_add(1,nls,A[i].r,A[i].r+Query(A[i].r),1);
		if (A[i].l<A[i].r) T_clear(1,nls,A[i].l+1,A[i].r-1,1);
		else T_clear(1,nls,A[i].l+1,nls,1),T_clear(1,nls,1,A[i].r-1,1);
		//T_BL(1,nls,1);
		//puts("========================");
	}
	W(T_bl(1,nls,1)+2ll*sum);puts("");
}