/**
 * @file qoj3101-1.cpp
 * @author n685
 * @brief
 * @date 2024-07-03
 *
 *
 */
#include <bits/stdc++.h>

#ifdef LOCAL
#include "dd/debug.h"
#else
#define dbg(...) 42
#define dbgR(...) 4242
#define dbgP(...) 420
#define dbgRP(...) 420420
void nline() {}
void bar() {}
#endif

namespace rs = std::ranges;
namespace rv = std::views;

constexpr int MX = 100000;
constexpr int LG = std::__lg(2 * MX - 1);

template <class T> struct CC {
  std::vector<T> val;
  void insert(T a) { val.push_back(a); }
  void init() {
    std::sort(val.begin(), val.end());
    val.erase(std::unique(val.begin(), val.end()), val.end());
  }
  int operator[](T a) const {
    return static_cast<int>(std::distance(
        val.begin(), std::lower_bound(val.begin(), val.end(), a)));
  }
  int size() const { return static_cast<int>(val.size()); }
};

struct Event {
  int val, i, type;
};

int main() {
#ifndef LOCAL
  std::ios::sync_with_stdio(false);
  std::cin.tie(nullptr);
#endif

  int n, k;
  std::cin >> n >> k;
  ++n;
  ++k;

  std::vector<int> l(n), r(n);
  CC<int> cc;
  cc.insert(0);
  for (const int i : rv::iota(1, n)) {
    std::cin >> l[i] >> r[i];
    cc.insert(l[i]);
    cc.insert(r[i]);
  }
  cc.init();
  const int m = cc.size();
  for (int &i : l) {
    i = cc[i];
  }
  for (int &i : r) {
    i = cc[i];
  }
  std::vector lift(LG, std::vector<int>(n + 1, n));
  {
    std::vector<Event> ev;
    for (const int i : rv::iota(0, n)) {
      ev.emplace_back(l[i], i, 0);
      ev.emplace_back(r[i], i, 1);
    }
    std::ranges::sort(ev, std::greater<>(),
                      [](const Event &e) { return e.val; });
    int miR = m, mi = n;
    for (const auto &[val, i, type] : ev) {
      if (type == 0) {
        if (miR > r[i]) {
          miR = r[i];
          mi = i;
        }
      } else {
        lift[0][i] = mi;
      }
    }
    for (const int i : rv::iota(1, LG)) {
      for (const int j : rv::iota(0, n)) {
        lift[i][j] = lift[i - 1][lift[i - 1][j]];
      }
    }
  }
  auto count = [&](int i, int rb) -> int {
    int ans = 0;
    for (int j : rv::iota(0, LG) | rv::reverse) {
      int nxt = lift[j][i];
      if (nxt != n and r[nxt] <= rb) {
        ans or_eq (1 << j);
        i = nxt;
      }
    }
    return ans;
  };
  std::set<std::pair<int, int>> in;
  in.emplace(0, 0);
  int cnt = count(0, n);
  for (const int i : rv::iota(1, n)) {
    const auto it = in.lower_bound({r[i], 0});
    if ((it != in.end() and l[it->second] < r[i]) or
        std::prev(it)->first > l[i]) {
      continue;
    }
    const int rb = (it == in.end() ? n : l[it->second]),
              li = std::prev(it)->second;
    int lcnt = cnt - count(li, rb);
    lcnt += count(li, l[i]);
    lcnt += 1;
    lcnt += count(i, rb);
    if (lcnt >= k) {
      in.emplace(r[i], i);
    }
    if (std::ssize(in) >= k) {
      break;
    }
  }
  if (std::ssize(in) < k) {
    std::cout << "-1\n";
  } else {
    std::vector<int> ans;
    ans.reserve(k);
    for (const auto &[a, i] : in | rv::drop(1)) {
      ans.push_back(i);
    }
    std::ranges::sort(ans);
    for (const int i : ans) {
      std::cout << i << '\n';
    }
  }
}