#include <cstdio>
#include <algorithm>

using namespace std;
typedef long long int LL;
const int Max_N(100050);

template<typename Type>
void Get_Val(Type &Ret)
{
	Ret = 0;
	char ch;
	while (ch = getchar(), ch > '9' || ch < '0')
		;
	do
	{
		(Ret *= 10) += ch - '0';
	}
	while (ch = getchar(), ch >= '0' && ch <= '9');
}

int N, B[Max_N];
LL K, A[Max_N], L[Max_N], R[Max_N];

bool init()
{
	Get_Val(N), Get_Val(K);
	for (int i = 1;i <= N;++i)
	{
		Get_Val(A[i]), Get_Val(B[i]);
		if (B[i] == 1 && 2LL * A[i] > K)
			return false;
	}
	LL SumA(0LL), l, r;
	for (int i = 1;i <= N;++i)
	{
		l = (-2LL * (SumA + A[i]) % K + K) % K, r = (-2LL * SumA % K + K) % K;
		SumA += A[i];
		if (B[i] == 1)
			L[i] = r, R[i] = l;
		else
			L[i] = 0LL, R[i] = K - 1LL;
	}
	return true;
}

#define TAG   (segt[cur].Tag)
#define LCH   (segt[cur].lch)
#define RCH   (segt[cur].rch)

struct node
{
	int Tag, lch, rch;
};
int tot, root;
node segt[Max_N * 120];

void insert(int &cur, const LL &l, const LL &r, const int &v, const LL &LEFT = 0LL, const LL &RIGHT = K - 1LL)
{
	if (!cur)
		segt[++tot] = segt[cur], cur = tot;
	if (LEFT == l && RIGHT == r)
	{
		TAG = v;
		return;
	}
	LL MID = LEFT + ((RIGHT - LEFT) >> 1LL);
	if (r <= MID)
		insert(LCH, l, r, v, LEFT, MID);
	else
		if (l > MID)
			insert(RCH, l, r, v, MID + 1LL, RIGHT);
		else
			insert(LCH, l, MID, v, LEFT, MID), insert(RCH, MID + 1LL, r, v, MID + 1LL, RIGHT);
}

int query(const int &cur, const LL &pos, const LL &LEFT = 0LL, const LL &RIGHT = K - 1LL)
{
	if (!cur)
		return N + 1;
	if (LEFT == RIGHT)
		return TAG;
	LL MID = LEFT + ((RIGHT - LEFT) >> 1LL);
	if (pos <= MID)
		return min(TAG, query(LCH, pos, LEFT, MID));
	else
		return min(TAG, query(RCH, pos, MID + 1LL, RIGHT));
}

/*
设车0（从0到N）在时刻P[0]出发，从i - 1到i的时间为A[i]，在第i个车站停留了P[i]的时间，最后在某个时刻达到N车站 
设车1（从N到0）在某个时刻出发，从i到i - 1的时间为A[i]，在第i个车站停留了Q[i]的时间，最后在-Q[0]时刻到达0车站
所有P[i]和Q[i]均为非负整数
那么车0在第x条铁轨（从x - 1走到x的铁轨）上的时间是：
(Sum{P[i]   |   0 <= i <= x - 1} + Sum{A[i]   |   1 <= i <= x - 1}, Sum{P[i]   |   0 <= i <= x - 1} + Sum{A[i]   |   1 <= i <= x})
那么车1在第x条铁轨（从x走到x - 1的铁轨）上的时间是：
(Sum{-Q[i]   |   0 <= i <= x - 1} + Sum{-A[i]   |   1 <= i <= x}, Sum{-Q[i]   |   0 <= i <= x - 1} + Sum{-A[i]   |   1 <= i <= x - 1})
对于第x条铁轨，当其是单轨铁路时，需要有任意两个不同向的车对应的时间区间不相交
当区间长度r - l = A[x] > K时，时间区间覆盖了整个mod K意义下的数轴，那么一定会存在相交的情况，不合法。所以只考虑r - l <= K的情况 
那么可以把区间只在mod K意义下考虑，因为第p辆发出的车的时间区间是(l + pk, r + pk)
注意到两个对应的时间区间长度是相等的，均有r - l = A[x]，所以两个区间不相交当且仅当第一个区间的左右端点均不在第二个区间中
进行一些移项和合并，可以得到该条件等价于：
Sum{P[i] + Q[i]   |   0 <= i <= x - 1}不在区间(-2 * Sum{A[i]   |   1 <= i <= x}, -2 * Sum{A[i]   |   1 <= i <= x - 1})中
当限制区间长度r - l = 2 * A[x] > K时，限制区间覆盖了整个mod K意义下的数轴，那么一定不合法 
目标是最小化Sum{P[i] + Q[i]   |   1 <= i <= N - 1} + 2 * Sum{A[i]   |   1 <= i <= N}
记S[x] = Sum{P[i] + Q[i]   |   0 <= i <= x}，记S是P + Q的前缀和
问题转化成最小化S[N - 1] - S[0]，同时每个S[x]在mod K意义下都满足其在一个区间[L[x], R[x]]中
假设确定了S[0]，那么可以直接贪心最小化S[N - 1]。具体而言就是，每走到一个x，若已经在区间中就不动，否则就一直增加、直到走到区间的左端点
考虑dp这个过程，记F[i]表示S[i] mod K = L[i]时S[N - 1] - S[i]的最小值。转移找到最近的满足S[i] mod K不在区间[L[j], R[j]]的j
最终S[0]的取值一定是某个L[i]或R[i]，类似dp的方法求出最优值
上面找j的过程可以用线段树优化 
*/

inline LL Dist(const LL &s, const LL &t)
{
	return s <= t ? t - s : K - s + t;
}

LL F[Max_N];
void work()
{
	segt[0].Tag = N + 1;
	for (int x = N, p;x >= 1;--x)
	{
		p = query(root, L[x]);
		if (p == N + 1)
			F[x] = 0LL;
		else
			F[x] = F[p] + Dist(L[x], L[p]);
		if (L[x] <= R[x])
		{
			if (R[x] + 1LL <= K - 1LL)
				insert(root, R[x] + 1LL, K - 1LL, x);
			if (0LL <= L[x] - 1LL)
				insert(root, 0LL, L[x] - 1LL, x);
		}
		else
			if (R[x] + 1LL <= L[x] - 1LL)
				insert(root, R[x] + 1LL, L[x] - 1LL, x);
	}
	LL Ans(0X3F3F3F3F3F3F3F3FLL);
	for (int x = 1, p;x <= N;++x)
	{
		p = query(root, L[x]);
		if (p == N + 1)
			Ans = min(Ans, 0LL);
		else
			Ans = min(Ans, F[p] + Dist(L[x], L[p]));
		p = query(root, R[x]);
		if (p == N + 1)
			Ans = min(Ans, 0LL);
		else
			Ans = min(Ans, F[p] + Dist(R[x], L[p]));
	}
	for (int i = 1;i <= N;++i)
		Ans += 2LL * A[i];
	printf("%lld", Ans);
}

int main()
{
	if (init())
		work();
	else
		printf("-1");
	return 0;
}

Measured memory_bytes: 35840