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 CPP):

Solution:
#include <bits/stdc++.h>
using namespace std;
struct LazyST {
  vector<long long> st, lazy;
  int n;
  LazyST(int n) : st(4 * n + 5, 0), lazy(4 * n + 5, 0), n(n) {}
  void init(int k, int s, int e, long long *a) {
    lazy[k] = 0;
    if (s + 1 == e) {
      st[k] = a[s];
      return;
    }
    int m = (s + e) / 2;
    init(2 * k, s, m, a);
    init(2 * k + 1, m, e, a);
    st[k] = st[2 * k] + st[2 * k + 1];
  }
  void push(int k, int s, int e) {
    if (!lazy[k]) return;
    st[k] += (e - s) * lazy[k];
    if (s + 1 < e) {
      lazy[2 * k] += lazy[k];
      lazy[2 * k + 1] += lazy[k];
    }
    lazy[k] = 0;
  }
  void upd(int k, int s, int e, int a, int b, long long v) {
    push(k, s, e);
    if (s >= b || e <= a) return;
    if (s >= a && e <= b) {
      lazy[k] += v;
      push(k, s, e);
      return;
    }
    int m = (s + e) / 2;
    upd(2 * k, s, m, a, b, v);
    upd(2 * k + 1, m, e, a, b, v);
    st[k] = st[2 * k] + st[2 * k + 1];
  }
  long long query(int k, int s, int e, int a, int b) {
    if (s >= b || e <= a) return 0;
    push(k, s, e);
    if (s >= a && e <= b) return st[k];
    int m = (s + e) / 2;
    return query(2 * k, s, m, a, b) + query(2 * k + 1, m, e, a, b);
  }
  void init(long long *a) { init(1, 0, n, a); }
  void upd(int a, int b, long long v) { upd(1, 0, n, a, b, v); }
  long long query(int a, int b) { return query(1, 0, n, a, b); }
};
const pair<int, int> NEUT = {0, 0};
struct STree {
  int n;
  vector<pair<int, int> > t;
  STree(int n) : n(n), t(2 * n + 5, NEUT) {}
  void upd(int p, pair<int, int> value) {
    for (t[p += n] = value; p > 1; p >>= 1) t[p >> 1] = max(t[p], t[p ^ 1]);
  }
  pair<int, int> query(int l, int r) {
    pair<int, int> res = NEUT;
    for (l += n, r += n; l < r; l >>= 1, r >>= 1) {
      if (l & 1) res = max(res, t[l++]);
      if (r & 1) res = max(res, t[--r]);
    }
    return res;
  }
};
const int MAXN = 2e5 + 15;
int n, k;
struct Range {
  int l, r, id;
  Range(int l, int r, int id) : l(l), r(r), id(id) {}
  bool operator<(Range b) const {
    if (l != b.l) return l < b.l;
    return r < b.r;
  }
};
int main() {
  ios::sync_with_stdio(false);
  cin.tie(0);
  cout.tie(0);
  cin >> n >> k;
  vector<Range> v;
  LazyST rng(MAXN);
  STree st(MAXN);
  for (int i = 0, ggdem = n; i < ggdem; i++) {
    int x, y;
    cin >> x >> y;
    x--;
    rng.upd(x, y, 1);
    v.push_back(Range(x, y, i + 1));
  }
  sort(v.begin(), v.end());
  for (int i = 0, ggdem = n; i < ggdem; i++) st.upd(i, {v[i].r, i});
  vector<int> res;
  for (int i = 0, ggdem = MAXN; i < ggdem; i++) {
    while (rng.query(i, i + 1) > k) {
      auto it = upper_bound(v.begin(), v.end(), Range(i, MAXN, -1)) - v.begin();
      int x = st.query(0, it).second;
      rng.upd(v[x].l, v[x].r, -1);
      res.push_back(v[x].id);
      st.upd(x, {0, -1});
    }
  }
  cout << ((int)(res).size()) << "\n";
  for (int i = 0, ggdem = ((int)(res).size()); i < ggdem; i++)
    cout << res[i] << " \n"[i == ((int)(res).size()) - 1];
}