#include <bits/stdc++.h>
#pragma GCC optimize("Ofast")
#define lop(i, n) for(ll i = 0; i < (ll)n; i++)
#define in(v) for(auto &i: v) cin >> i;
#define alop(i,v) for(auto &i: v)
#define ll long long
#define ld long double
#define endl '\n'
#define all(v) v.begin(),v.end()
#define mem(dp, x) memset(dp, x, sizeof(dp))
#define sq(x) ((x) * (x))
#define pb push_back
using namespace std;

struct node{
    ll mn = 1e18, ind = 1e18;
    friend node operator+(node a, node b){
        if(a.mn <= b.mn) 
            return a;
        else 
            return b;
    }
};

struct segtree{
    ll s, e; 
    vector<node> tree;
    void init(ll n){
        ll nxt2 = 1 << (__lg(n - 1) + 1);
        s = nxt2 - 1, e = nxt2 * 2 - 2;
        tree.resize(nxt2 * 2 - 1);
    }
    void update(ll index, ll value){
        index += s;
        tree[index] = {value, index};
        while(index){
            index = index / 2 - !(index & 1);
            tree[index] = tree[index * 2 + 1] + tree[index * 2 + 2];
        }
    }
    node get(ll x, ll lx, ll rx, ll r){
        ll mid = (lx + rx) / 2;
        if(rx <= r)
            return tree[x];
        else if(r < lx) 
            return {(ll)1e18, (ll)1e18};
        else
            return get(x * 2 + 1, lx, mid, r) + get(x * 2 + 2, mid + 1, rx, r);
    }
    ll get(ll r){
        node ans = get(0, s, e, r + s);
        if(ans.mn != 1e18) return ans.ind - s;
        return 1e18;
    }
    ll arr(ll ind){return tree[ind + s].mn;}
};

ll bs(vector<pair<ll, ll>> &arr, ll x){
    ll l = 0, r = arr.size() - 1, mid, ans = 1e18;
    while(l <= r){
        mid = (l + r) / 2;
        if(arr[mid].first <= x) 
            ans = mid, l = mid + 1;
        else 
            r = mid - 1;
    }
    return ans;
}

bool cmp(vector<pair<ll, ll>> a, vector<pair<ll, ll>> b){
    lop(i, a.size()){
        if(a[i] < b[i]) 
            return 1;
        else if(a[i] > b[i]) 
            return 0;
    }
}

signed main(){
    ios::sync_with_stdio(0); cin.tie(0); cout.tie(0);
    
    ll n, k; cin >> n >> k;
    vector<pair<ll, ll>> arr(n); //{r, l}
    map<pair<ll, ll>, ll> mp;
    lop(i, n){
        ll a, b; cin >> a >> b;
        arr[i] = {b, a};
        mp[{b, a}] = i;
    }
    sort(all(arr));

    vector<segtree> dp(k + 1);
    ll par[k + 1][n] = {}; mem(par, -1);
    dp[1].init(n);
    lop(i, n){
        dp[1].update(i, arr[i].second), par[1][i] = i;
    }

    for(int i = 2; i <= k; i++){
        dp[i].init(n);
        lop(j, n){
            ll res = bs(arr, arr[j].second);
            if(res == 1e18) continue;
            ll g = dp[i - 1].get(res);

            if(g == 1e18) continue;

            par[i][j] = g;
            dp[i].update(j, arr[j].second);
        }
    }

    vector<vector<pair<ll, ll>>> sol;
    lop(i, n){
        ll g = dp[k].arr(i);
        if(g == 1e18) continue;
        vector<pair<ll, ll>> temp = {{arr[i].second, mp[arr[i]]}};

        ll j = k, ind = i;
        while(par[j][ind] != ind){
            ind = par[j][ind], j--;
            temp.pb({arr[ind].second, mp[arr[ind]]});
        }
        reverse(all(temp));
        sol.pb(temp);
    }

    sort(all(sol), cmp);
    if(sol.empty()) cout << -1;
    else
        lop(i, k) cout << sol[0][i].second + 1 << endl;

    
    return 0;
}