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.io.InputStreamReader;
import java.io.BufferedReader;
import java.io.StreamTokenizer;
import java.io.IOException;
import java.util.Arrays;

public class Too_Many_Intercepts {

	public static void main(String [] args) throws IOException {
		new Deleting().solve();
	}

}

class Deleting {
	
	int n, k;
	int [] l, r;
	int [] amount;
	final int SIZE = 251;
	
	Deleting() throws IOException {
		QuickInput in = new QuickInput();
		n = in.nextInt();
		k = in.nextInt();
		l = new int [n];
		r = new int [n];
		amount = new int [SIZE];
		Arrays.fill(amount, 0);
		for (int u = 0; u < n; u++){
			l[u] = in.nextInt();
			r[u] = in.nextInt();
			amount[l[u]]++;
			amount[r[u] + 1]--;
		}
		for (int y = 0; y < SIZE - 1; y++)
			amount[y + 1] += amount[y];
	}
	
	void solve(){
		int answer = 0;
		boolean [] used = new boolean [n];
		Arrays.fill(used, false);
		for (int i = 0; i < SIZE; i++)
			while(amount[i] > k){
				int place = -1;
				for (int j = 0; j < n; j++)
					if (!used[j] && (l[j] <= i && i <= r[j]) && (place == -1 || r[place] < r[j]))
						place = j;
				used[place] = true;
				answer++;
				for (int w = l[place]; w <= r[place]; w++)
					amount[w]--;
			}
		System.out.println(answer);
		for (int q = 0; q < n; q++)
			if (used[q])
				System.out.print((q + 1) + " ");
	}
	
}

class QuickInput {
	
	StreamTokenizer stk;
	
	QuickInput(){
		stk = new StreamTokenizer(new BufferedReader(new InputStreamReader(System.in)));
	}
	
	int nextInt() throws IOException {
		stk.nextToken();
		return (int) stk.nval;
	}
	
}