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 Ishu
{
    static class Reader 
        { 
            final private int BUFFER_SIZE = 1 << 16; 
            private DataInputStream din; 
            private byte[] buffer; 
            private int bufferPointer, bytesRead; 
      
            public Reader() 
            { 
                din = new DataInputStream(System.in); 
                buffer = new byte[BUFFER_SIZE]; 
                bufferPointer = bytesRead = 0; 
            } 
      
            public Reader(String file_name) throws IOException 
            { 
                din = new DataInputStream(new FileInputStream(file_name)); 
                buffer = new byte[BUFFER_SIZE]; 
                bufferPointer = bytesRead = 0; 
            } 
      
            public String readLine() throws IOException 
            { 
                byte[] buf = new byte[64]; // line length 
                int cnt = 0, c; 
                while ((c = read()) != -1) 
                { 
                    if (c == '\n') 
                        break; 
                    buf[cnt++] = (byte) c; 
                } 
                return new String(buf, 0, cnt); 
            } 
      
            public int nextInt() throws IOException 
            { 
                int ret = 0; 
                byte c = read(); 
                while (c <= ' ') 
                    c = read(); 
                boolean neg = (c == '-'); 
                if (neg) 
                    c = read(); 
                do
                { 
                    ret = ret * 10 + c - '0'; 
                }  while ((c = read()) >= '0' && c <= '9'); 
      
                if (neg) 
                    return -ret; 
                return ret; 
            } 
      
            public long nextLong() throws IOException 
            { 
                long ret = 0; 
                byte c = read(); 
                while (c <= ' ') 
                    c = read(); 
                boolean neg = (c == '-'); 
                if (neg) 
                    c = read(); 
                do { 
                    ret = ret * 10 + c - '0'; 
                } 
                while ((c = read()) >= '0' && c <= '9'); 
                if (neg) 
                    return -ret; 
                return ret; 
            } 
      
            public double nextDouble() throws IOException 
            { 
                double ret = 0, div = 1; 
                byte c = read(); 
                while (c <= ' ') 
                    c = read(); 
                boolean neg = (c == '-'); 
                if (neg) 
                    c = read(); 
      
                do { 
                    ret = ret * 10 + c - '0'; 
                } 
                while ((c = read()) >= '0' && c <= '9'); 
      
                if (c == '.') 
                { 
                    while ((c = read()) >= '0' && c <= '9') 
                    { 
                        ret += (c - '0') / (div *= 10); 
                    } 
                } 
      
                if (neg) 
                    return -ret; 
                return ret; 
            } 
      
            private void fillBuffer() throws IOException 
            { 
                bytesRead = din.read(buffer, bufferPointer = 0, BUFFER_SIZE); 
                if (bytesRead == -1) 
                    buffer[0] = -1; 
            } 
      
            private byte read() throws IOException 
            { 
                if (bufferPointer == bytesRead) 
                    fillBuffer(); 
                return buffer[bufferPointer++]; 
            } 
      
            public void close() throws IOException 
            { 
                if (din == null) 
                    return; 
                din.close(); 
            } 
        } 
    static class Node
    {
    int l;
    int r;
    int idx;
    Node() {}
    Node(int l, int r, int idx)
        {
        this.l = l;
        this.r = r;
        this.idx = idx;
        }
    }
    static class NodeComparator implements Comparator<Node>{
        public int compare(Node x, Node y)
            {
            return y.r - x.r;
            }
    }
    static Reader scan = new Reader();
    static BufferedWriter output = new BufferedWriter(new OutputStreamWriter(System.out)); 
    static void tc() throws Exception
    {
    int n = scan.nextInt();
    int k = scan.nextInt();
    int i,j;
    int[] hash = new int[200002];
    List<Node>[] L = new ArrayList[200001];
    List<Node>[] R = new ArrayList[200001];
    List<Integer> ans = new ArrayList<Integer>();
    for(i=0;i<=200000;++i)
        {
        L[i] = new ArrayList<Node>();
        R[i] = new ArrayList<Node>();
        }
        
    PriorityQueue<Node> pq = new PriorityQueue  <Node>(n, new NodeComparator());    
        
    for(i=0;i<n;++i)
        {
        int l = scan.nextInt();
        int r = scan.nextInt();
        L[l].add(new Node(l, r, i + 1));
        R[r].add(new Node(l, r, i + 1));
        ++hash[l];
        --hash[r+1];
        }
    int cnt = 0;
    for(i=1;i<=200000;++i)
        {
        cnt += hash[i];
       
        int size = R[i-1].size();
        for(j=0;j<size;++j)
            {
            Node node = R[i-1].get(j);
            pq.remove(node);
            }   
            
        size = L[i].size();
        for(j=0;j<size;++j)    
            {
            Node node = L[i].get(j);
            pq.add(node);
            }
            
        if(cnt <= k)
            continue;
            
        int diff = cnt - k;
        while(diff-- > 0)
            {
            Node node = pq.poll();
            hash[node.r + 1]++;
            --cnt;
            ans.add(node.idx);
            }    
        }
    output.write(ans.size() + "\n");
    for(i=0;i<ans.size();++i)
        output.write(ans.get(i) + " ");
    output.write("\n");
    output.flush();
    }
    public static void main(String[] args) throws Exception
    {
    int t = 1;
    //t = scan.nextInt();
    while(t-- > 0)
        tc();
    }
}