// Original C++ solution (slower):
#include <bits/stdc++.h>

using namespace std;

//Coded in Dongge Jifang 4



int n,k,N;

long long a[100005],b[100005];

long long qzh[100005];

long long liml[100005],limr[100005];

long long dp[100005],dp2[100005];

long long ans=0x3f3f3f3f3f3f3f3fLL;



struct Node{

	long long num;

	Node *l,*r;

	Node(){

		num=n+1;

		l=r=0;

	}

}*root,*root2;



struct segtree{

	void init(Node* &now){

		if(!now){

			return;

		}

		init(now->l);

		init(now->r);

		delete now;

		now=0;

	}

	void update(int l,int r,long long x,Node* &now,int nl=0,int nr=k-1){

		if(!now){

			now=new Node();

		}

		if(nl>=l&&nr<=r){

			now->num=min(now->num,x);

			return;

		}

		if(nl>r||nr<l){

			return;

		}

		int m=(nl+nr)>>1;

		update(l,r,x,now->l,nl,m);

		update(l,r,x,now->r,m+1,nr);

		//now->num=min(now->l->num,now->r->num);

	}

	void upd(int l,int r,long long x,Node* &now){

		l=(l%k+k)%k;

		r=(r%k+k)%k;

		if(l<=r){

			update(l,r,x,now);

		}else{

			update(l,k-1,x,now);

			update(0,r,x,now);

		}

	}

	long long qmin(int whr,Node* &now,int nl=0,int nr=k-1){

		if(!now){

			now=new Node();

		}

		if(nl==whr&&nr==whr){

			return now->num;

		}

		int m=(nl+nr)>>1;

		if(m>=whr){

			return min(now->num,qmin(whr,now->l,nl,m));

		}else{

			return min(now->num,qmin(whr,now->r,m+1,nr));

		}

	}

}seg1,seg2;



int main(){

	scanf("%d%d",&n,&k);

	for(int i=1;i<=n;i++){

		scanf("%lld%lld",a+i,b+i);

		if(b[i]==1&&a[i]*2>k){

			puts("-1");

			return 0;

		}

	}

	for(int i=1;i<=n;i++){

		qzh[i]=qzh[i-1]+a[i];

	}

	for(int i=1;i<=n;i++){

		if(b[i]==1){

			liml[N]=2*(k-qzh[i]%k)%k;

			limr[N]=2*(k-qzh[i-1]%k)%k;

			N++;

		}

	}

	seg1.init(root);

	seg2.init(root2);

	dp[N-1]=dp2[N-1]=0;

	seg1.upd(liml[N-1]+1,limr[N-1]-1,N-1,root);

	seg2.upd(liml[N-1]+1,limr[N-1]-1,N-1,root2);

	//cerr<<liml[N-1]<<' '<<limr[N-1]<<endl;

	for(int i=N-2;i>=0;i--){

		int x=seg1.qmin(liml[i],root);

		//cerr<<liml[i]<<' '<<' '<<x<<endl;

		if(x==n+1){

			dp[i]=0;

		}else{

			dp[i]=min(dp[x]+((liml[x]-liml[i])%k+k)%k,dp2[x]+((limr[x]-liml[i])%k+k)%k);

		}

		x=seg2.qmin(limr[i],root2);

		if(x==n+1){

			dp2[i]=0;

		}else{

			dp2[i]=min(dp2[x]+((limr[x]-limr[i])%k+k)%k,dp[x]+((liml[x]-limr[i])%k+k)%k);

		}

		seg1.upd(liml[i]+1,limr[i]-1,i,root);

		seg2.upd(liml[i]+1,limr[i]-1,i,root2);

	}

	seg1.init(root);

	seg2.init(root2);

	for(int i=0;i<N;i++){

		int x=seg1.qmin(liml[i],root);

		//cerr<<i<<' '<<x<<' '<<n<<' '<<dp[i]<<endl;

		if(x==n+1){

			ans=min(ans,dp[i]);

		}

		x=seg2.qmin(limr[i],root2);

		if(x==n+1){

			ans=min(ans,dp2[i]);

		}

		seg1.upd(liml[i]+1,limr[i]-1,i,root);

		seg2.upd(liml[i]+1,limr[i]-1,i,root2);

	}

	printf("%lld\n",ans+qzh[n]*2);

	return 0;

}


// Optimized solution to the same problem (faster):
#include<bits/stdc++.h>

using namespace std;



typedef long long ll;

const int N=3e5+10;

int n,K,cnt;

int a[N],b[N],c[N<<1],l[N],r[N];

ll ans,s[N],f[N];



int read()

{

	int ret=0;char c=getchar();

	while(!isdigit(c)) c=getchar();

	while(isdigit(c)) ret=ret*10+(c^48),c=getchar();

	return ret;

}



struct Segment

{

#define ls (x<<1)

#define rs (x<<1|1)

	int col[N<<2],tar[N<<2];

	void pushdown(int x)

	{

		if(!tar[x]) return;

		col[ls]=col[rs]=tar[ls]=tar[rs]=tar[x];tar[x]=0;

	}

	void update(int x,int l,int r,int L,int R,int v)

	{

		if(L>R) return;

		if(L<=l && r<=R){col[x]=tar[x]=v;return;}

		pushdown(x);

		int mid=(l+r)>>1;

		if(L<=mid) update(ls,l,mid,L,R,v);

		if(R>mid) update(rs,mid+1,r,L,R,v);

	}

	int querycol(int x,int l,int r,int p)

	{

		if(l==r) return col[x];

		pushdown(x);

		int mid=(l+r)>>1;

		if(p<=mid) return querycol(ls,l,mid,p);

		else return querycol(rs,mid+1,r,p);

	}

	ll query(int x)

	{

		int pos=querycol(1,1,cnt,x);

		return pos?f[pos]+(c[l[pos]]-c[x]+K)%K:0;

	}

#undef ls

#undef rs

}tr;



int main()

{

#ifdef Durant_Lee

	freopen("AGC011F.in","r",stdin);

	freopen("AGC011F.out","w",stdout);

#endif

	n=read();K=read();

	for(int i=1;i<=n;++i)

	{

		a[i]=read();b[i]=read();s[i]=s[i-1]+a[i];

		if(b[i]&1) l[i]=(K-s[i-1]*2%K)%K,r[i]=(K-s[i]*2%K)%K;

		else l[i]=0,r[i]=K-1;

		if(b[i]&1 && a[i]*2>K){puts("-1");return 0;}

		c[++cnt]=l[i];c[++cnt]=r[i];

	}

	sort(c+1,c+cnt+1);cnt=unique(c+1,c+cnt+1)-c-1;

	for(int i=1;i<=n;++i) l[i]=lower_bound(c+1,c+cnt+1,l[i])-c,r[i]=lower_bound(c+1,c+cnt+1,r[i])-c;

	for(int i=n;i;--i)

	{

		f[i]=tr.query(l[i]);

		if(l[i]>r[i]) tr.update(1,1,cnt,r[i]+1,l[i]-1,i);

		else tr.update(1,1,cnt,1,l[i]-1,i),tr.update(1,1,cnt,r[i]+1,cnt,i);

	}

	ans=f[1];

	for(int i=cnt;i;--i) ans=min(ans,tr.query(i));

	printf("%lld\n",ans+2*s[n]);

	return 0;

}

// Fastest known solution for this problem: