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 
import java.io.OutputStream;
import java.io.IOException;
import java.io.InputStream;
import java.io.PrintWriter;
import java.util.Arrays;
import java.io.IOException;
import java.util.TreeSet;
import java.util.ArrayList;
import java.util.Comparator;
import java.util.Collections;
import java.io.InputStream;
 
/**
 * Built using CHelper plug-in
 * Actual solution is at the top
 */
public class Main {
    public static void main(String[] args) {
        InputStream inputStream = System.in;
        OutputStream outputStream = System.out;
        InputReader in = new InputReader(inputStream);
        PrintWriter out = new PrintWriter(outputStream);
        D1TooManySegmentsEasyVersion solver = new D1TooManySegmentsEasyVersion();
        solver.solve(1, in, out);
        out.close();
    }
 
    static class D1TooManySegmentsEasyVersion {
        int MAXN = 200005;
        PrintWriter out;
        InputReader in;
        final Comparator<Tuple> com = new Comparator<Tuple>() {
            public int compare(Tuple t1, Tuple t2) {
                if (t1.x != t2.x)
                    return Integer.compare(t1.x, t2.x);
                else if (t1.y != t2.y)
                    return Integer.compare(t2.y, t1.y);
                else
                    return Integer.compare(t1.id, t2.id);
            }
        };
        final Comparator<Tuple> com1 = new Comparator<Tuple>() {
            public int compare(Tuple t1, Tuple t2) {
                if (t1.y != t2.y)
                    return Integer.compare(t1.y, t2.y);
                else
                    return Integer.compare(t1.id, t2.id);
            }
        };
 
        public void solve(int testNumber, InputReader in, PrintWriter out) {
            this.out = out;
            this.in = in;
            int n = ni();
            int m = ni();
            int[] hola = new int[201];
            int i = 0;
            int[][] segments = new int[n][2];
            int[] pf = new int[MAXN];
            Tuple[] segment = new Tuple[n];
            Segment_tree st = new Segment_tree(MAXN);
            for (i = 0; i < n; i++) {
                segments[i][0] = ni();
                segments[i][1] = ni();
                pf[segments[i][0]]++;
                pf[segments[i][1] + 1]--;
                segment[i] = new Tuple(segments[i][0], segments[i][1], i);
                st.rangeupdate(segments[i][0], segments[i][1], 1);
            }
            for (i = 1; i < MAXN; i++)
                pf[i] += pf[i - 1];
            ArrayList<Integer> bad_points = new ArrayList<>();
            for (i = 0; i < MAXN; i++) {
                if (pf[i] > m)
                    bad_points.add(i);
            }
 
            boolean[] vis = new boolean[n];
            ArrayList<Integer> ans = new ArrayList<>();
            TreeSet<Tuple> tset = new TreeSet<>(com);
            for (i = 0; i < n; i++)
                tset.add(new Tuple(segment[i].x, segment[i].y, i));
            Arrays.sort(segment, com);
            for (int x : bad_points) {
                ArrayList<Tuple> ar = new ArrayList<>();
                for (Tuple xx : tset) {
                    if (xx.x <= x && xx.y >= x)
                        ar.add(xx);
                    if (xx.x > x)
                        break;
                }
                Collections.sort(ar, com1);
                int reqd = (int) st.query(x, x) - m;
                for (i = 0; i < reqd; i++) {
                    Tuple curr = ar.get(i);
                    st.rangeupdate(curr.x, curr.y, -1);
                    vis[curr.id] = true;
                    tset.remove(curr);
                    ans.add(curr.id + 1);
                }
                for (i = 0; i < ar.size(); i++) {
                    Tuple curr = ar.get(i);
                    if (curr.y < x)
                        tset.remove(curr);
                }
            }
            pn(ans.size());
            for (int x : ans)
                p(x + " ");
 
        }
 
        int ni() {
            return in.nextInt();
        }
 
        void pn(long zx) {
            out.println(zx);
        }
 
        void p(Object o) {
            out.print(o);
        }
 
        class Segment_tree {
            long[] sum;
            long[] lazy;
            int n;
 
            Segment_tree(int x) {
                n = x;
                sum = new long[4 * n];
                lazy = new long[4 * n];
                Arrays.fill(lazy, 0);
                build(1, 0, n - 1);
            }
 
            void build(int node, int tl, int tr) {
                if (tl == tr) { // leaf{
                    sum[node] = 0;
                } else {
                    int mid = tl + tr >> 1, left = node * 2, right = left + 1;
                    build(left, tl, mid);
                    build(right, mid + 1, tr);
                    merge(node);
                }
            }
 
            long query(int l, int r) {
                return query(1, 0, n - 1, l, r);
            }
 
            long query(int node, int tl, int tr, int l, int r) {
                if (r < tl || tr < l)
                    return 0;
                if (tl >= l && tr <= r)
                    return sum[node];
                if (lazy[node] != 0)
                    propagate(node);
                int mid = tl + tr >> 1, left = node * 2, right = left + 1;
                return query(left, tl, mid, l, r) + query(right, mid + 1, tr, l, r);
            }
 
            void merge(int node) {
                sum[node] = sum[node << 1] + sum[node << 1 | 1];
            }
 
            void rangeupdate(int i, int j, long val) {
                rangeupdate(1, 0, n - 1, i, j, val);
            }
 
            void rangeupdate(int node, int tl, int tr, int l, int r, long val) {
                if (r < tl || tr < l) {
                    return;
                }
                if (tl >= l && tr <= r) {
                    sum[node] += val;
                    lazy[node] += val;
                } else {
                    int mid = tl + tr >> 1, left = node * 2, right = left + 1;
                    if (lazy[node] != 0)
                        propagate(node);
                    rangeupdate(left, tl, mid, l, r, val);
                    rangeupdate(right, mid + 1, tr, l, r, val);
                    merge(node);
                }
            }
 
            void propagate(int node) {
                lazy[node * 2] += lazy[node];
                lazy[node * 2 + 1] += lazy[node];
                sum[node * 2] += lazy[node];
                sum[node * 2 + 1] += lazy[node];
                lazy[node] = 0;
            }
 
        }
 
        class Tuple {
            int x;
            int y;
            int id;
 
            Tuple(int a, int b, int ind) {
                x = a;
                y = b;
                id = ind;
            }
 
        }
 
    }
 
    static class InputReader {
        private InputStream stream;
        private byte[] buf = new byte[1024];
        private int curChar;
        private int numChars;
 
        public InputReader(InputStream stream) {
            this.stream = stream;
        }
 
        public int read() {
            if (numChars == -1) {
                throw new UnknownError();
            }
            if (curChar >= numChars) {
                curChar = 0;
                try {
                    numChars = stream.read(buf);
                } catch (IOException e) {
                    throw new UnknownError();
                }
                if (numChars <= 0) {
                    return -1;
                }
            }
            return buf[curChar++];
        }
 
        public int nextInt() {
            return Integer.parseInt(next());
        }
 
        public String next() {
            int c = read();
            while (isSpaceChar(c)) {
                c = read();
            }
            StringBuffer res = new StringBuffer();
            do {
                res.appendCodePoint(c);
                c = read();
            } while (!isSpaceChar(c));
 
            return res.toString();
        }
 
        private boolean isSpaceChar(int c) {
            return c == ' ' || c == '\n' || c == '\r' || c == '\t' || c == -1;
        }
 
    }
}
 