#include <bits/stdc++.h>
using namespace std;
struct interval {
int l, r;
int i;
auto operator<=>(const interval &r) const = default;
};
class lazy_segment_tree {
int n;
vector<int> seg, lazy;
public:
lazy_segment_tree(int n) : n(n), seg(4 * n), lazy(8 * n) {}
void push(int v, int tl, int tr) {
seg[v] += lazy[v] * (tr - tl + 1);
lazy[2 * v] += lazy[v];
lazy[2 * v + 1] += lazy[v];
lazy[v] = 0;
}
void apply(int v, int tl, int tr, int l, int r, int x) {
push(v, tl, tr);
if (tr < l || r < tl) {
return;
}
if (l <= tl && tr <= r) {
lazy[v] += x;
push(v, tl, tr);
return;
}
int tm = (tl + tr) / 2;
apply(2 * v, tl, tm, l, r, x);
apply(2 * v + 1, tm + 1, tr, l, r, x);
seg[v] = seg[2 * v] + seg[2 * v + 1];
}
void apply(int l, int r, int x) { apply(1, 0, n - 1, l, r, x); }
int query(int v, int tl, int tr, int l, int r) {
push(v, tl, tr);
if (tr < l || r < tl) {
return 0;
}
if (l <= tl && tr <= r) {
return seg[v];
}
int tm = (tl + tr) / 2;
return query(2 * v, tl, tm, l, r) + query(2 * v + 1, tm + 1, tr, l, r);
}
int query(int l, int r) { return query(1, 0, n - 1, l, r); }
};
const int inf = 1e9;
class segment_tree {
int n;
vector<int> seg;
public:
segment_tree(int n) : n(n), seg(2 * n, -inf) {}
void set(int i, int x) {
for (seg[i += n] = x, i >>= 1; i > 0; i >>= 1) {
seg[i] = max(seg[2 * i], seg[2 * i + 1]);
}
}
void apply(int i, int x) {
i += n;
for (seg[i] = max(seg[i], x), i >>= 1; i > 0; i >>= 1) {
seg[i] = max(seg[2 * i], seg[2 * i + 1]);
}
}
int query(int l, int r) {
int ans = -inf;
for (l += n, r += n + 1; l < r; l >>= 1, r >>= 1) {
if (l & 1)
ans = max(ans, seg[l++]);
if (r & 1)
ans = max(ans, seg[--r]);
}
return ans;
}
};
int main() {
cin.tie(nullptr)->sync_with_stdio(false);
int n, k;
cin >> n >> k;
vector<interval> a(n);
vector<int> buff;
for (int i = 0, l, r; i < n; ++i) {
cin >> l >> r;
a[i] = {l, r, i};
buff.push_back(l), buff.push_back(r);
}
auto A = a;
sort(a.begin(), a.end(), [](interval a, interval b) { return a.r < b.r; });
// for a given interval [l, r], find an interval ahead of it [l', r'] such that l' >= r
segment_tree st(n);
for (int i = 0; i < n; ++i) {
st.set(i, a[i].l);
}
vector lift(n + 1, vector<int>(20));
for (int i = 0; i < n; ++i) {
int j = *ranges::partition_point(views::iota(i + 1, n), [&](int j) {
return st.query(i + 1, j) < a[i].r;
});
lift[i][0] = j;
}
lift[n][0] = n;
for (int bt = 1; bt < 20; ++bt) {
for (int i = 0; i <= n; ++i) {
lift[i][bt] = lift[lift[i][bt - 1]][bt - 1];
}
}
sort(buff.begin(), buff.end());
buff.erase(unique(buff.begin(), buff.end()), buff.end());
auto comp = [&](int i) { return lower_bound(buff.begin(), buff.end(), i) - buff.begin(); };
auto solve = [&](int L, int R) {
// find first interval in a with their l >= L
int i = *ranges::partition_point(views::iota(0, n), [&](int i) {
return st.query(0, i) < L;
});
if (i == n || a[i].r > R) {
return 0;
}
int k = 0;
for (int bt = 19; bt >= 0; --bt) {
if (lift[i][bt] != n && a[lift[i][bt]].r <= R) {
k |= 1 << bt;
i = lift[i][bt];
}
}
return k + 1;
};
int cur = solve(1, int(1e9));
if (k > cur) {
cout << "-1\n";
return 0;
}
set<pair<int, int>> curs;
lazy_segment_tree lst(buff.size());
vector<int> ans;
for (int i = 0; i < n; ++i) {
pair<int, int> _p = {A[i].l, int(1e9) + 1};
auto itt = curs.upper_bound(_p);
if (itt != curs.begin()) {
itt--;
// find an inteval with l <= our l
if (A[i].r <= itt->second) { // full intersection
continue;
}
}
pair<int, int> p = {A[i].l, A[i].r};
int q1 = lst.query(comp(A[i].l), comp(A[i].r));
int q2 = lst.query(comp(A[i].l), comp(A[i].l));
int q3 = lst.query(comp(A[i].r), comp(A[i].r));
if (q1 - q2 - q3 != 0 || q2 > 1 || q3 > 1) {
continue;
}
curs.insert(p);
auto it = curs.find(p);
int lef = 1, rig = 1e9;
if (it != curs.begin()) {
lef = prev(it)->second;
}
if (it != --curs.end()) {
rig = next(it)->first;
}
int pcur = cur;
cur -= solve(lef, rig);
cur += solve(lef, p.first) + 1 + solve(p.second, rig);
if (cur < k) {
curs.erase(it);
cur = pcur;
} else {
ans.push_back(i + 1);
lst.apply(comp(p.first), comp(p.second), 1);
}
}
for (int i = 0; i < k; ++i) {
cout << ans[i] << '\n';
}
}
