Tavas is a cheerleader in the new sports competition named "Pashmaks".

<image>

This competition consists of two part: swimming and then running. People will immediately start running R meters after they finished swimming exactly S meters. A winner is a such person that nobody else finishes running before him/her (there may be more than one winner).

Before the match starts, Tavas knows that there are n competitors registered for the match. Also, he knows that i-th person's swimming speed is si meters per second and his/her running speed is ri meters per second. Unfortunately, he doesn't know the values of R and S, but he knows that they are real numbers greater than 0.

As a cheerleader, Tavas wants to know who to cheer up. So, he wants to know all people that might win. We consider a competitor might win if and only if there are some values of R and S such that with these values, (s)he will be a winner.

Tavas isn't really familiar with programming, so he asked you to help him.

Input

The first line of input contains a single integer n (1 ≤ n ≤ 2 × 105).

The next n lines contain the details of competitors. i-th line contains two integers si and ri (1 ≤ si, ri ≤ 104).

Output

In the first and the only line of output, print a sequence of numbers of possible winners in increasing order.

Examples

Input

3
1 3
2 2
3 1


Output

1 2 3 


Input

3
1 2
1 1
2 1


Output

1 3 
#include <bits/stdc++.h>
using namespace std;
template <class T1, class T2>
inline istream& operator>>(istream& fin, pair<T1, T2>& pr) {
  fin >> pr.first >> pr.second;
  return fin;
}
template <class T0, class T1, class T2>
inline istream& operator>>(istream& fin, tuple<T0, T1, T2>& t) {
  fin >> get<0>(t) >> get<1>(t) >> get<2>(t);
  return fin;
}
template <class T>
inline istream& operator>>(istream& fin, vector<T>& a) {
  for (auto& u : a) fin >> u;
  return fin;
}
template <class T, size_t n>
inline istream& operator>>(istream& fin, array<T, n>& a) {
  for (auto& u : a) fin >> u;
  return fin;
}
bool fail(const pair<int64_t, int64_t>& i, const pair<int64_t, int64_t>& pr,
          const pair<int64_t, int64_t>& j) {
  const auto s1 = i.first;
  const auto r1 = i.second;
  const auto s = pr.first;
  const auto r = pr.second;
  const auto s2 = j.first;
  const auto r2 = j.second;
  ;
  ;
  ;
  const auto lhs = r1 * s2 * (s - s1) + r2 * s1 * (s2 - s);
  const auto rhs = r1 * r2 * s * (s2 - s1);
  ;
  ;
  return r * lhs < rhs;
}
void frwd(map<int64_t, int64_t>::iterator iter, map<int64_t, int64_t>& m) {
  while (true) {
    const auto i = *iter;
    if (++iter == end(m)) return;
    const auto pr = *iter;
    if (++iter == end(m)) return;
    if (!fail(i, pr, *iter)) return;
    --iter;
    iter = m.erase(iter);
    --iter;
  }
}
void bkwd(map<int64_t, int64_t>::iterator iter, map<int64_t, int64_t>& m) {
  while (true) {
    const auto j = *iter;
    if (iter == begin(m)) return;
    const auto pr = *--iter;
    if (iter == begin(m)) return;
    if (!fail(*--iter, pr, j)) return;
    ++iter;
    iter = m.erase(iter);
  }
}
void e535() {
  size_t n;
  cin >> n;
  vector<pair<int64_t, int64_t>> a(n);
  cin >> a;
  map<int64_t, int64_t> m;
  m.emplace(*max_element(begin(a), end(a)));
  {
    auto b = a.front();
    for (const auto& pr : a)
      if (b.second < pr.second || (b.second == pr.second && b.first < pr.first))
        b = pr;
    m.insert(b);
  };
  for (const auto& pr : a) {
    auto j = m.upper_bound(pr.first);
    if (j == begin(m) || j == end(m)) continue;
    auto i = j;
    --i;
    ;
    ;
    ;
    if (fail(*i, pr, *j)) continue;
    auto iter = m.emplace_hint(j, pr.first, pr.second);
    iter->second = pr.second;
    ;
    frwd(iter, m);
    ;
    bkwd(m.find(pr.first), m);
    ;
  }
  vector<size_t> out;
  for (size_t i = 0; i < n; ++i) {
    const auto iter = m.find(a[i].first);
    if (iter != end(m) && iter->second == a[i].second) out.push_back(i + 1);
  }
  copy(begin(out), end(out), ostream_iterator<size_t>(cout, " "));
}
int main(const int argc, char* argv[]) {
  ios_base::sync_with_stdio(0);
  cin.tie(0);
  cout.tie(0);
  ;
  e535();
  return EXIT_SUCCESS;
}
