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.util.*;
 
public class Main{
    
    public static void main(String[] args) throws IOException {
        Reader.init();
        int n=Reader.nextInt();
        int k=Reader.nextInt();
        
        ArrayList<Node> line[]=new ArrayList[200001];
        for(int i=0;i<200001;i++){
            line[i]=new ArrayList<Node>();
        }
        
        for(int i=0;i<n;i++){
            int l=Reader.nextInt();
            int r=Reader.nextInt();
            line[l].add(new Node(l, r, i+1));
        }
        
        // Stores all segments covering current point
        TreeSet<Node> set=new TreeSet();
        
        ArrayList<Integer> res=new ArrayList();
        for(int i=0;i<200001;i++){
            // Remove ended segments
            while(!set.isEmpty() && set.first().r<i){
                set.pollFirst();
            }
            
            // Add all segments starting at this point
            set.addAll(line[i]);
            
            while(set.size()>k){
                // Remove segment which ends later 
                Node node=set.pollLast();
                res.add(node.i);
            }
        }
        
        print(res.size());
        for(int i=0;i<res.size();i++){
            System.out.print(res.get(i)+" ");
        }
    
    }
    
    static int mod=1000000007;
    public static void read(int arr[], int N) throws IOException{ for(int i=0;i<N;i++){ arr[i]=Reader.nextInt(); } }
    public static void read(String arr[], int N) throws IOException{ for(int i=0;i<N;i++){ arr[i]=Reader.next(); } }
    public static void print(Object O){ System.out.println(O); }
    public static void display(int arr[]){ System.out.println(Arrays.toString(arr)); }
    public static void display(int arr[][], int N){ for(int i=0;i<N;i++){ System.out.println(Arrays.toString(arr[i])); } }
}

class Node implements Comparable<Node>{
    int l;
    int r;
    int i;
    
    Node(int l, int r, int i){
        this.l=l;
        this.r=r;
        this.i=i;
    }
    
    //If it returns 0, treeset finds two nodes same and doesn't add it to the set
    public int compareTo(Node b){
        if(this.r==b.r && this.l==b.l){
            return this.i-b.i;
        }
        else if(this.r==b.r){
            return this.l-b.l;
        }
        return this.r-b.r;
    }
    
} 

class Reader {
    static BufferedReader reader;
    static StringTokenizer tokenizer;
 
    static void init() {
        reader=new BufferedReader(new InputStreamReader(System.in));
        tokenizer=new StringTokenizer("");
    }
 
    static String next() throws IOException {
        while (!tokenizer.hasMoreTokens() ) {
            tokenizer=new StringTokenizer(reader.readLine());
        }
        return tokenizer.nextToken();
    }
 
    static int nextInt() throws IOException { return Integer.parseInt(next()); }
    static double nextDouble() throws IOException { return Double.parseDouble(next()); }
    static long nextLong() throws IOException { return Long.parseLong(next()); }
    static String nextLine() throws IOException { return reader.readLine(); }
}