#include <bits/stdc++.h>
#define N 100005
#define mxL 22
#define ls(u) tr[u].ls
#define rs(u) tr[u].rs
using namespace std;
typedef long long ll;

int n, L, K, idr[N], pos[N];
int tp, stk[N], nxt[N][mxL], res[N];
int num[N*2], totn;

int rt, tot;
struct Seg { int ls, rs, sum; bool tg; } tr[N*4];

struct Qry { int l, r, lx, rx; } q[N];
struct Pnt {
    int id;
    bool operator< (const Pnt &x) const { return q[id].r<q[x.id].r; }
};
set <Pnt> s;
set <Pnt>::iterator it;

vector <int> ans;

bool cmpr (const int &a, const int &b) { return q[a].r<q[b].r; }

void buildST (int &u, int l, int r)
{
    if (!u) { u=++tot; }
    if (l==r) { return; }
    int md=(l+r)/2;
    buildST(ls(u), l, md);
    buildST(rs(u), md+1, r);
}
void pushdown (int u, int l, int r)
{
    if (!tr[u].tg) { return; }
    int md=(l+r)/2;
    tr[ls(u)].tg=1; tr[ls(u)].sum=md-l+1;
    tr[rs(u)].tg=1; tr[rs(u)].sum=r-md;
    tr[u].tg=0;
}
int qry (int u, int l, int r, int ql, int qr)
{
    if (l>qr || r<ql) { return 0; }
    if (ql<=l && r<=qr) { return tr[u].sum; }
    pushdown(u, l, r);
    int md=(l+r)/2;
    return qry(ls(u), l, md, ql, qr)+qry(rs(u), md+1, r, ql, qr);
}
void add (int u, int l, int r, int ql, int qr)
{
    if (l>qr || r<ql) { return; }
    if (ql<=l && r<=qr) { tr[u].tg=1; tr[u].sum=r-l+1; return; }
    pushdown(u, l, r);
    int md=(l+r)/2;
    add(ls(u), l, md, ql, qr);
    add(rs(u), md+1, r, ql, qr);
    tr[u].sum=tr[ls(u)].sum+tr[rs(u)].sum;
}

int main ()
{
    // freopen("0test.in", "r", stdin);
    // freopen("0test.out", "w", stdout);

    scanf("%d %d", &n, &K);
    L=ceil(log(n)/log(2));
    for (int i=1; i<=n; i++) {
        scanf("%d %d", &q[i].l, &q[i].r);
        idr[i]=i; num[++totn]=q[i].l; num[++totn]=q[i].r-1;
    }
    q[n+1].l=1000000001;
    q[n+1].r=1000000002;

    sort(idr+1, idr+n+1, cmpr);
    for (int i=1; i<=n; i++) { pos[idr[i]]=i; }

    idr[n+1]=n+1;
    for (int i=n; i>=1; i--) {
        while (tp>0 && q[idr[stk[tp]]].l<=q[idr[i]].l) { tp--; }

        int l=1, r=tp; nxt[i][0]=n+1;
        while (l<=r) {
            int md=(l+r)/2;
            if (q[idr[stk[md]]].l>=q[idr[i]].r) { l=md+1; nxt[i][0]=stk[md]; }
            else { r=md-1; }
        }
        stk[++tp]=i;
    }

    for (int j=0; j<=L; j++) { nxt[n+1][j]=n+1; }
    nxt[0][0]=1;
    for (int i=n; i>=0; i--) {
        for (int j=1; j<=L; j++) { nxt[i][j]=nxt[nxt[i][j-1]][j-1]; }
    }

    sort(num+1, num+totn+1);
    totn=unique(num+1, num+totn+1)-(num+1);
    for (int i=1; i<=n; i++) {
        q[i].lx=lower_bound(num+1, num+totn+1, q[i].l)-num;
        q[i].rx=lower_bound(num+1, num+totn+1, q[i].r-1)-num;
    }

    int curr=0;
    for (int i=1; i<=n; i++) {
        int id=idr[i];
        if (q[id].l>=curr) { res[0]++; curr=q[id].r; }
    }

    if (res[0]<K) { printf("-1"); return 0; }

    buildST(rt, 1, totn);

    int sum=res[0];
    for (int i=1; i<=n; i++) {
        if (qry(rt, 1, totn, q[i].lx, q[i].rx)) { continue; }
        
        int pcur=pos[i];
        it=s.lower_bound((Pnt){ i });

        int nx=(it==s.end() ? n+1 : (*it).id);
        int cnt=0;
        for (int j=L; j>=0; j--) {
            if (q[idr[nxt[pcur][j]]].r<=q[nx].l) { cnt+=(1<<j); pcur=nxt[pcur][j]; }
        }
        res[i]=cnt;

        int pr, tmppr;
        if (it==s.begin()) { pr=0; }
        else { it--; pr=(*it).id; }
        tmppr=pr;
        cnt=0;
        for (int j=L; j>=0; j--) {
            if (q[idr[nxt[pr][j]]].r<=q[i].l) { cnt+=(1<<j); pr=nxt[pr][j]; }
        }

        if (sum+res[i]+cnt-res[tmppr]+1>=K) {
            ans.push_back(i);
            sum+=res[i]-res[tmppr]+cnt+1; res[tmppr]=cnt;
            s.insert((Pnt){ i });
            add(rt, 1, totn, q[i].lx, q[i].rx);
        }

        if (ans.size()>=K) { break; }
    }
    
    for (int i=0; i<K; i++) { printf("%d\n", ans[i]); }

    return 0;
}