The only difference between easy and hard versions is constraints.

You are given n segments on the coordinate axis OX. Segments can intersect, lie inside each other and even coincide. The i-th segment is [l_i; r_i] (l_i ≤ r_i) and it covers all integer points j such that l_i ≤ j ≤ r_i.

The integer point is called bad if it is covered by strictly more than k segments.

Your task is to remove the minimum number of segments so that there are no bad points at all.

Input

The first line of the input contains two integers n and k (1 ≤ k ≤ n ≤ 200) — the number of segments and the maximum number of segments by which each integer point can be covered.

The next n lines contain segments. The i-th line contains two integers l_i and r_i (1 ≤ l_i ≤ r_i ≤ 200) — the endpoints of the i-th segment.

Output

In the first line print one integer m (0 ≤ m ≤ n) — the minimum number of segments you need to remove so that there are no bad points.

In the second line print m distinct integers p_1, p_2, ..., p_m (1 ≤ p_i ≤ n) — indices of segments you remove in any order. If there are multiple answers, you can print any of them.

Examples

Input


7 2
11 11
9 11
7 8
8 9
7 8
9 11
7 9


Output


3
1 4 7 


Input


5 1
29 30
30 30
29 29
28 30
30 30


Output


3
1 2 4 


Input


6 1
2 3
3 3
2 3
2 2
2 3
2 3


Output


4
1 3 5 6 
import java.util.ArrayList;
import java.util.Collections;
import java.util.List;
import java.util.Scanner;

public class Main {
    private static int[] createHowBadSeg(List segment, int[] test, int[][] s, int min, int badNumCrit) {
        int[] howBadSeg = new int[s.length];
        for (int i = 0; i < howBadSeg.length; i++) {
            if (segment.contains(i + 1)) {
                howBadSeg[i] = 0;
                continue;
            }
            for (int j = s[i][0]; j <= s[i][1]; j++) {
                if (test[j - min] > badNumCrit)
                    howBadSeg[i]++;
            }
        }
        return howBadSeg;
    }

    private static int getMaxIndex(int[] howBadSeg, int[] test, int[][] s, int min, int badNumCrit) {
        int max = howBadSeg[0];
        int maxIndex = 0;
        for (int i = 1; i < howBadSeg.length; i++) {
            if (howBadSeg[i] == max) {
                int c1 = 0;
                for (int j = s[i][0]; j <= s[i][1]; j++) {
                    if (test[j - min] > badNumCrit)
                        c1 += test[j - min];
                }
                int c2 = 0;
                for (int j = s[maxIndex][0]; j <= s[maxIndex][1]; j++) {
                    if (test[j - min] > badNumCrit)
                        c2 += test[j - min];
                }
                if (c1 > c2) {
                    max = howBadSeg[i];
                    maxIndex = i;
                }
            }
            if (howBadSeg[i] > max) {
                max = howBadSeg[i];
                maxIndex = i;
            }
        }
        howBadSeg[maxIndex] = 0;
        return maxIndex;
    }

    private static boolean hasBadPoint(int[] howBadSeg) {
        for (int value : howBadSeg) {
            if (value != 0)
                return true;
        }
        return false;
    }

    public static void main(String[] args) {
        Scanner sc = new Scanner(System.in);
        int numSeg = sc.nextInt();
        int badNumCrit = sc.nextInt();
        int[][] s = new int[numSeg][2];
        s[0][0] = sc.nextInt();
        s[0][1] = sc.nextInt();
        sc.nextLine();
        int min = s[0][0];
        int max = s[0][1];
        for (int i = 1; i < numSeg; i++) {
            s[i][0] = sc.nextInt();
            s[i][1] = sc.nextInt();
            if (s[i][0] < min)
                min = s[i][0];
            if (s[i][1] > max)
                max = s[i][1];
            sc.nextLine();
        }
        int[] test = new int[max - min + 1];

        for (int i = 0; i < numSeg; i++) {
            for (int j = s[i][0]; j <= s[i][1]; j++) {
                test[j - min]++;
            }
        }
        int[] howBadSeg;
        int count = 0;
        List<Integer> segment = new ArrayList<>();
        howBadSeg = createHowBadSeg(segment, test, s, min, badNumCrit);
        while (hasBadPoint(howBadSeg)) {
            int maxIndex = getMaxIndex(howBadSeg, test, s, min, badNumCrit);
            for (int j = s[maxIndex][0] - min; j <= s[maxIndex][1] - min; j++)
                test[j]--;
            count++;
            segment.add(maxIndex + 1);
            howBadSeg = createHowBadSeg(segment, test, s, min, badNumCrit);
        }
        System.out.println(count);
        Collections.sort(segment);
        for (int n : segment)
            System.out.print(n + " ");
    }
}
