Problem: 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 

Solution (in JAVA):

Solution:
import java.util.ArrayList;
import java.util.HashMap;
import java.util.HashSet;
import java.util.List;
import java.util.Map;
import java.util.Scanner;
import java.util.Set;
import javafx.util.Pair;

public class TooManySegments {

    private static List<Pair<Integer, Integer>> getOverlaps(int val, List<Pair<Integer, Integer>> input) {
        List<Pair<Integer, Integer>> overlaps = new ArrayList<>();
        for (Pair<Integer, Integer> pair : input) {
            if (val >= pair.getKey() && val <= pair.getValue()) {
                overlaps.add(pair);
            }
        }
        return overlaps;
    }
    public static void main(String[] args) {
        Scanner in = new Scanner(System.in);
        int n = in.nextInt();
        int k = in.nextInt();
        int minVal = Integer.MAX_VALUE, maxVal = Integer.MIN_VALUE;
        List<Pair<Integer, Integer>> inputArray = new ArrayList<>();
        Map<Pair<Integer, Integer>, Set<Integer>> originalInputMapping = new HashMap<>();
        for (int i = 0 ; i < n ; i++) {
            Pair<Integer, Integer> pair = new Pair<Integer, Integer>(in.nextInt(), in.nextInt());
            inputArray.add(pair);
            originalInputMapping.putIfAbsent(pair, new HashSet<>());
            originalInputMapping.get(pair).add(i+1);
            minVal = Math.min(pair.getKey(), minVal);
            maxVal = Math.max(pair.getValue(), maxVal);
        }
        inputArray.sort((o1, o2) -> {
//            if ((o2.getValue()-o2.getKey()) == (o1.getValue()-o1.getKey()))
                return o2.getValue().compareTo(o1.getValue());
//            return Integer.compare((o2.getValue() - o2.getKey()), (o1.getValue() - o1.getKey()));
        });
        int removals = 0;
        List<Integer> removalIndices = new ArrayList<>();
        for (int i = minVal ; i <= maxVal ; i++) {
            List<Pair<Integer, Integer>> overlaps = getOverlaps(i, inputArray);
            while (overlaps.size() > k) {
                removals++;
                int index = originalInputMapping.get(overlaps.get(0)).iterator().next();
                originalInputMapping.get(overlaps.get(0)).remove(index);
                removalIndices.add(index);
                inputArray.remove(overlaps.get(0));
                overlaps.remove(0);
            }
        }
        System.out.println(removals);
        for (Integer idx : removalIndices) {
            System.out.print(idx + " ");
        }

    }
}