#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;
    }
};

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;
}

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<vector<node>> dp(k + 1, vector<node>(n));
    vector<vector<ll>> par(k + 1, vector<ll>(n, -1));
    lop(i, n){
        dp[1][i] = (node){arr[i].second, i}, par[1][i] = i;
        if(i) 
            dp[1][i] = dp[1][i - 1] + dp[1][i];
    }

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

            if(g == 1e18) continue;

            par[i][j] = g;
            dp[i][j] = (node){arr[j].second, j};
            if(j)
                dp[i][j] = dp[i][j - 1] + dp[i][j];
        }
    }

    vector<vector<pair<ll, ll>>> sol;
    lop(i, n){
        ll g = dp[k][i].mn;
        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);
    }

    if(sol.empty()) cout << -1;
    else{
        set<ll> cmp;
        lop(i, sol.size()) 
            cmp.insert(i);
        lop(j, k){
            ll mn = 1e18;
            alop(i, cmp){
                mn = min(mn, sol[i][j].first);
            }
            vector<ll> del;
            alop(i, cmp){
                if(sol[i][j].first != mn) del.pb(i);
            }
            alop(i, del)
                cmp.erase(cmp.find(i));
        }

        lop(i, k)
            cout << sol[0][i].second + 1 << endl;
    }

    
    return 0;
}