Little penguin Polo adores integer segments, that is, pairs of integers [l; r] (l ≤ r). 

He has a set that consists of n integer segments: [l1; r1], [l2; r2], ..., [ln; rn]. We know that no two segments of this set intersect. In one move Polo can either widen any segment of the set 1 unit to the left or 1 unit to the right, that is transform [l; r] to either segment [l - 1; r], or to segment [l; r + 1].

The value of a set of segments that consists of n segments [l1; r1], [l2; r2], ..., [ln; rn] is the number of integers x, such that there is integer j, for which the following inequality holds, lj ≤ x ≤ rj.

Find the minimum number of moves needed to make the value of the set of Polo's segments divisible by k.

Input

The first line contains two integers n and k (1 ≤ n, k ≤ 105). Each of the following n lines contain a segment as a pair of integers li and ri ( - 105 ≤ li ≤ ri ≤ 105), separated by a space.

It is guaranteed that no two segments intersect. In other words, for any two integers i, j (1 ≤ i < j ≤ n) the following inequality holds, min(ri, rj) < max(li, lj).

Output

In a single line print a single integer — the answer to the problem.

Examples

Input

2 3
1 2
3 4


Output

2


Input

3 7
1 2
3 3
4 7


Output

0
import java.io.*;
import java.util.*;

import static java.lang.Math.abs;
import static java.lang.Math.max;
import static java.lang.Math.min;


public class Java {

    private static final int INF = (int) 1e9 + 3;

    private static InputReader in;
    private static PrintWriter out;


    private static void test0() throws IOException {
        int n = in.nextInt();
        int k = in.nextInt();
        long init_number = 0;
        for (int i = 0; i < n; ++i) {
            int a = in.nextInt();
            int b = in.nextInt();
            init_number += b - a + 1;
        }

        int res = (int) ((k - init_number % k) % k);
        out.printf("%d\n", res);
    }

    public static void main(String[] args) throws IOException {
        init_io(args.length > 0 && Objects.equals(args[0], "MINE"));

        test0();

        out.flush();
    }

    private static long sqr(int x) {
        return (long) x * x;
    }

    private static void init_io(boolean myMachine) throws FileNotFoundException {
        in = new InputReader(myMachine ? new FileInputStream("input.txt") : System.in);
        out = new PrintWriter(System.out);
    }
}

class InputReader {
    private BufferedReader reader;
    private StringTokenizer tokenizer;

    InputReader(InputStream inputStream) {
        reader = new BufferedReader(new InputStreamReader(inputStream));
        tokenizer = new StringTokenizer("");

    }

    String nextLine() throws IOException {
        if (!tokenizer.hasMoreTokens()) {
            tokenizer = new StringTokenizer(reader.readLine());
        }
        return tokenizer.nextToken("");
    }

    String nextWord() throws IOException {
        while (!tokenizer.hasMoreTokens()) {
            tokenizer = new StringTokenizer(this.nextLine());
        }
        return tokenizer.nextToken();
    }

    int nextInt() throws IOException {
        return Integer.parseInt(this.nextWord());
    }

    double nextDouble() throws IOException {
        return Double.parseDouble(this.nextWord());
    }
}
