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

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<ll>> dp(k + 1, vector<ll>(n, 1e18));
    vector<vector<ll>> par(k + 1, vector<ll>(n, -1));
    lop(i, n){
        dp[1][i] = 0, par[1][i] = 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];

            if(g == 1e18) continue;

            par[i][j] = g;
            dp[i][j] = j;
            if(j)
                dp[i][j] = min(dp[i][j - 1], j);
        }
    }

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

        ll j = k, ind = i;
        while(par[j][ind] != ind){
            ind = par[j][ind], j--;
            temp.pb(mp[arr[ind]]);
        }
        sort(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]);
            }

            vector<ll> del;
            alop(i, cmp){
                if(sol[i][j] != mn) del.pb(i);
            }

            alop(i, del)
                cmp.erase(cmp.find(i));
        }

        lop(i, k)
            cout << sol[*cmp.begin()][i] + 1 << endl;
    }

    
    return 0;
}