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.*;
import java.lang.reflect.Array;
import java.util.*;

public class A
{

    public static void main(String[] args) throws Exception
    {
        Scanner sc = new Scanner() ;
        PrintWriter out  = new PrintWriter(System.out) ;
        int n = sc.nextInt() , k = sc.nextInt() ;
        int [] l = new int [n] ;
        int [] r = new int [n] ;
        int [] sum = new int [202] ;

        for(int i = 0 ; i < n ; i ++)
        {
            l[i] = sc.nextInt();
            r[i] = sc.nextInt();
            sum[l[i]]++ ;
            sum[r[i] + 1]-- ;
        }

        for(int i = 1 ; i < sum.length ; i ++)
            sum[i] += sum[i - 1] ;

        int N = 1 ;
        while (N < 201) N <<= 1 ;
        int [] in = new int [N + 1] ;
        for(int i = 1 ; i <= 200 ; i ++)
            in[i] = sum[i] ;
        ArrayList<Integer> list = new ArrayList<>() ;
        for(int j = 1 ; j <= 200 ; j++)
            while(in[j] > k)
            {
                int max = 0 ;
                int ll = 0 , rr = 0 ;
                int idx = 0 ;
                for(int i = 0 ; i < n ;i ++) // 200
                    if(l[i] != -1 && l[i] <= j && j <= r[i] && r[i] > max)
                    {
                        max = r[i];
                        ll = l[i] ;
                        rr = r[i] ;
                        idx=  i + 1 ;
                    }
                l[idx - 1] = -1;
                list.add(idx) ;
                for( ; ll <= rr ; ll++)
                    in[ll]-- ;

            }
        out.println(list.size());
        for(int x : list)
            out.print(x+" ");
        out.flush();
    }

    static class SegmentTree {

        int N , K;
        int[] array, sTree, lazy;

        SegmentTree(int[] in , int k) {
            array = in;
            N = in.length - 1;
            sTree = new int[N << 1];
            lazy = new int[N << 1];
            K = k ;
            build(1, 1, N);
        }

        void build(int node, int b, int e)
        {
            if (b == e)
                sTree[node] = array[b] > K ? 1 : 0;
            else {
                int mid = b + e >> 1;
                build(node << 1, b, mid);
                build(node << 1 | 1, mid + 1, e);
                sTree[node] = sTree[node << 1] + sTree[node << 1 | 1];
            }
        }
        int query(int i, int j) {
            return query(1, 1, N, i, j);
        }
        int query(int node, int b, int e, int i, int j)
        {
            if (i > e || j < b)
                return 0;
            if (b >= i && e <= j)
                return sTree[node];
            int mid = b + e >> 1;
            int q1 = query(node << 1, b, mid, i, j);
            int q2 = query(node << 1 | 1, mid + 1, e, i, j);
            return q1 + q2;

        }
    }
    static class Scanner
    {
        BufferedReader br = new BufferedReader(new InputStreamReader(System.in)) ;
        StringTokenizer st ;

        String next() throws Exception
        {
            while (st == null || !st.hasMoreTokens())
                st = new StringTokenizer(br.readLine()) ;
            return st.nextToken() ;
        }
        int nextInt() throws Exception
        {
            return Integer.parseInt(next()) ;
        }
        long nextLong() throws Exception
        {
            return Long.parseLong(next()) ;
        }

    }
}