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 Java8 (OpenJDK 1.8.0) (judge verdict: Wrong Answer)

import java.io.OutputStream;
import java.io.IOException;
import java.io.InputStream;
import java.io.PrintWriter;
import java.util.SortedSet;
import java.util.Set;
import java.util.NavigableSet;
import java.io.IOException;
import java.io.InputStreamReader;
import java.util.TreeSet;
import java.util.StringTokenizer;
import java.io.BufferedReader;
import java.io.InputStream;

/**
 * Built using CHelper plug-in
 * Actual solution is at the top
 */
public class Main {
    public static void main(String[] args) {
        InputStream inputStream = System.in;
        OutputStream outputStream = System.out;
        InputReader in = new InputReader(inputStream);
        PrintWriter out = new PrintWriter(outputStream);
        TaskF solver = new TaskF();
        solver.solve(1, in, out);
        out.close();
    }

    static class TaskF {
        int period;

        public void solve(int testNumber, InputReader in, PrintWriter out) {
            int n = in.nextInt();
            period = in.nextInt();
            int[] a = new int[n];
            int[] b = new int[n];
            for (int i = 0; i < n; ++i) {
                a[i] = in.nextInt();
                b[i] = in.nextInt();
            }
            TreeSet<TaskF.ControlPoint> points = new TreeSet<>();
            points.add(new TaskF.ControlPoint(0, 0));
            long offset = 0;
            for (int i = 0; i < n; ++i) {
                if (i > 0) {
                    offset = (offset - a[i - 1] - a[i] + 2 * period) % period;
                }
                if (b[i] == 1) {
                    if (2 * a[i] > period) {
                        out.println(-1);
                        return;
                    }
                    int left = (int) ((offset - a[i] + period) % period);
                    int right = (int) ((offset + a[i]) % period);
                    TaskF.ControlPoint pl = ensurePoint(points, left);
                    TaskF.ControlPoint pr = ensurePoint(points, right);
                    if (pl.when < pr.when) {
                        NavigableSet<TaskF.ControlPoint> after = points.tailSet(pl, false);
                        while (!after.isEmpty() && after.first().when < pr.when) {
                            points.remove(after.first());
                        }
                    } else {
                        NavigableSet<TaskF.ControlPoint> after = points.tailSet(pl, false);
                        while (!after.isEmpty()) {
                            points.remove(after.first());
                        }
                        NavigableSet<TaskF.ControlPoint> before = points.headSet(pr, false);
                        while (!before.isEmpty()) {
                            points.remove(before.last());
                        }
                    }
                    long mid = 2L * a[i] - 1;
                    points.add(new TaskF.ControlPoint((int) ((left + mid) % period), pl.value + mid));//) throw new RuntimeException();
                }
            }
            long res = Long.MAX_VALUE;
            for (TaskF.ControlPoint p : points) {
                res = Math.min(res, p.value);
            }
            for (int i = 0; i < n; ++i) res += 2L * a[i];
            out.println(res);
        }

        private TaskF.ControlPoint ensurePoint(TreeSet<TaskF.ControlPoint> points, int at) {
            TaskF.ControlPoint us = new TaskF.ControlPoint(at, 0);
            NavigableSet<TaskF.ControlPoint> tail = points.tailSet(us, true);
            TaskF.ControlPoint next = tail.isEmpty() ? points.first() : tail.first();
            if (next.when == us.when) return next;
            NavigableSet<TaskF.ControlPoint> head = points.headSet(us, true);
            TaskF.ControlPoint prev = head.isEmpty() ? points.last() : head.last();
            int dx = next.when - prev.when;
            if (dx < 0) dx += period;
            long dv = next.value - prev.value;
            if (dv != 0) {
                //if (Math.abs(dx) != Math.abs(dv)) throw new RuntimeException();
                long step = dv / dx;
                int odx = at - prev.when;
                if (odx < 0) odx += period;
                us.value = prev.value + odx * step;
            } else {
                us.value = prev.value;
            }
            points.add(us);
            return us;
        }

        static class ControlPoint implements Comparable<TaskF.ControlPoint> {
            int when;
            long value;

            public ControlPoint(int when, long value) {
                this.when = when;
                this.value = value;
            }


            public int compareTo(TaskF.ControlPoint o) {
                return when - o.when;
            }

        }

    }

    static class InputReader {
        public BufferedReader reader;
        public StringTokenizer tokenizer;

        public InputReader(InputStream stream) {
            reader = new BufferedReader(new InputStreamReader(stream), 32768);
            tokenizer = null;
        }

        public String next() {
            while (tokenizer == null || !tokenizer.hasMoreTokens()) {
                try {
                    tokenizer = new StringTokenizer(reader.readLine());
                } catch (IOException e) {
                    throw new RuntimeException(e);
                }
            }
            return tokenizer.nextToken();
        }

        public int nextInt() {
            return Integer.parseInt(next());
        }

    }
}