Problem: 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.)

<image>

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.

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.

Examples

Input

3 10
4 1
3 1
4 1


Output

26


Input

1 10
10 1


Output

-1


Input

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


Output

12


Input

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


Output

14829091348

Solution (in CPP):

Solution:
#include <cstdio>
#include <cctype>
#include <algorithm>
#define repu(i,x,y) for (int i=x; i<=y; ++i)
#define repd(i,x,y) for (int i=x; i>=y; --i)
#define mid ((l+r)>>1)
using namespace std;

typedef long long LL;
int n,k,b[100100],m,l[100100],r[100100];
LL f[100100],a[100100];
struct node
{
    int minw;
    node *lc,*rc;
    node();
} *tp,*root;

int getint()
{
    char ch;
    while (!isdigit(ch=getchar()));
    int x=ch-'0';
    for (; isdigit(ch=getchar()); x=x*10+ch-'0');
    return x;
}

node::node()
{
    lc=tp,tp=this;
}

node *newnode()
{
    if (!tp)
        new node[50000];
    node *t=tp;
    tp=t->lc,t->lc=t->rc=0,t->minw=1<<30;
    return t;
}

void cover(node *&x,int l,int r,int ql,int qr,int w)
{
    if (qr<l || ql>r)
        return;
    if (!x)
        x=newnode();
    if (ql<=l && qr>=r)
    {
        x->minw=min(x->minw,w);
        return;
    }
    cover(x->lc,l,mid,ql,qr,w);
    cover(x->rc,mid+1,r,ql,qr,w);
}

int query(int p)
{
    node *x=root;
    int l=0,r=k-1,ret=1<<30;
    while (x)
    {
        ret=min(ret,x->minw);
        if (p<=mid)
            x=x->lc,r=mid;
        else
            x=x->rc,l=mid+1;
    }
    return ret;
}

LL calc(int x)
{
    int t=query(x);
    if (t==1<<30)
        return 0;
    return f[t]+(l[t]+k-x)%k;
}

int main()
{
    scanf("%d%d",&n,&k);
    repu(i,1,n)
    {
        a[i]=getint(),b[i]=getint();
        if (b[i]==1 && a[i]*2>k)
        {
            puts("-1");
            return 0;
        }
        a[i]+=a[i-1];
        if (b[i]==1)
        {
            l[++m]=(-a[i-1]*2%k+k)%k;
            r[m]=(-a[i]*2%k+k)%k;
        }
    }
    repd(i,m,1)
    {
        int t=query(l[i]);
        if (t<1<<30)
            f[i]=f[t]+(l[t]+k-l[i])%k;
        if (l[i]<=r[i])
        {
            cover(root,0,k-1,0,l[i]-1,i);
            cover(root,0,k-1,r[i]+1,k-1,i);
        }
        else
            cover(root,0,k-1,r[i]+1,l[i]-1,i);
    }
    LL ans=m?1LL<<60:0;
    repu(i,1,m)
        ans=min(ans,min(calc(l[i]),calc(r[i])));
    printf("%lld\n",ans+a[n]*2);
    return 0;
}