#include <bits/stdc++.h>
using namespace std;
struct interval {
int l, r;
int i;
auto operator<=>(const interval &r) const = default;
};
const int inf = 1e9;
template <typename T>
class segment_tree {
int n;
vector<T> seg;
public:
segment_tree(int n) : n(n), seg(2 * n, T{}) {}
void apply(int i, T x) {
i += n;
for (seg[i] = seg[i] + x, i >>= 1; i > 0; i >>= 1) {
seg[i] = seg[2 * i] + seg[2 * i + 1];
}
}
T query(int l, int r) {
T ans = T{};
for (l += n, r += n + 1; l < r; l >>= 1, r >>= 1) {
if (l & 1)
ans = ans + seg[l++];
if (r & 1)
ans = ans + seg[--r];
}
return ans;
}
};
struct max_t {
int x;
max_t() : x(-inf) {}
max_t(int x) : x(x) {}
max_t operator+(const max_t &r) {
return max_t{max(x, r.x)};
}
};
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); }
};
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());
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) {
vector<interval> A;
for (auto &[l, r, i] : a) {
if (L <= l && r <= R) {
A.emplace_back(l, r, i);
}
}
const int n = A.size();
if (n == 0) {
return 0;
}
vector<int> dp(n, 1);
segment_tree<max_t> st(buff.size());
for (int i = n - 1; i >= 0; --i) {
dp[i] = max(dp[i], st.query(comp(A[i].r), buff.size() - 1).x + 1);
st.apply(comp(A[i].l), dp[i]);
}
return *max_element(dp.begin(), dp.end());
};
int cur = solve(1, int(1e9));
if (k > cur) {
cout << "-1\n";
return 0;
}
set<pair<int, int>> curs;
lazy_segment_tree st(buff.size());
vector<int> ans;
for (int i = 0; i < n; ++i) {
int q1 = st.query(comp(A[i].l), comp(A[i].r));
int q2 = st.query(comp(A[i].l), comp(A[i].l));
int q3 = st.query(comp(A[i].r), comp(A[i].r));
if (q1 - q2 - q3 != 0 || q2 > 1 || q3 > 1) {
continue;
}
pair<int, int> p = {A[i].l, A[i].r};
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);
st.apply(comp(p.first), comp(p.second), 1);
}
}
for (int i = 0; i < k; ++i) {
cout << ans[i] << '\n';
}
}
