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>
std::default_random_engine random_engine(0xdeadbeef);
template <class T>
inline T randint(T L, T R) {
  return std::uniform_int_distribution<T>(L, R)(random_engine);
}
using namespace std;
long long gcd(long long a, long long b) {
  if (b == 0) return a;
  return gcd(b, a % b);
}
int sgn(long long x) { return x < 0 ? -1 : 1; }
struct pt {
  long long x, y;
  void normalize() {
    if (y < 0) x *= -1, y *= -1;
    long long g = gcd(abs(x), abs(y));
    x /= g;
    y /= g;
  }
  pt operator+(const pt& o) const {
    pt ret;
    ret.x = x * o.y + o.x * y;
    ret.y = y * o.y;
    ret.normalize();
    return ret;
  }
  pt operator-(const pt& o) const {
    pt ret;
    ret.x = x * o.y - o.x * y;
    ret.y = y * o.y;
    ret.normalize();
    return ret;
  }
  pt operator*(const pt& o) const {
    pt ret;
    ret.x = x * o.x;
    ret.y = y * o.y;
    ret.normalize();
    return ret;
  }
  bool operator==(const pt& o) const { return x == o.x && y == o.y; }
  bool operator!=(const pt& o) const { return !(*this == o); }
  bool operator<(const pt& o) const {
    if (*this == o) return false;
    if (x == 0) return true;
    if (o.x == 0) return false;
    long long a = x / y;
    long long b = o.x / o.y;
    if (a != b) return a < b;
    pt p;
    p.x = x - a * y, p.y = y;
    pt q;
    q.x = o.x - b * o.y, q.y = o.y;
    int sign = sgn(p.x) * sgn(q.x);
    swap(p.x, p.y);
    swap(q.x, q.y);
    p.normalize();
    q.normalize();
    if (sign == 1) return q < p;
    return p < q;
  }
  bool operator<=(const pt& o) const { return *this == o || *this < o; }
};
int N;
pair<pt, pt> A[200001];
pair<int, int> B[200000];
pair<int, int> C[200000];
bool negative(pair<pt, pt> a, pair<pt, pt> b) {
  if (sgn((b.second - a.second).x) * sgn((a.first - b.first).x) == -1)
    return true;
  if ((a.first - b.first).x > 0)
    return ((b.second - a.second) * a.first + (a.first - b.first) * a.second)
               .x <= 0;
  return ((b.second - a.second) * a.first + (a.first - b.first) * a.second).x >=
         0;
}
bool good(pair<pt, pt> a, pair<pt, pt> b, pair<pt, pt> c) {
  if (b.first == c.first) return c.second < b.second;
  pt p = b.second - c.second;
  pt q = c.first - b.first;
  pt r = b.second - a.second;
  pt s = a.first - b.first;
  if (q.x < 0) p.x *= -1, q.x *= -1;
  if (s.x < 0) r.x *= -1, s.x *= -1;
  return p * s < r * q;
}
bool cmp(const pair<pt, pt>& a, const pair<pt, pt>& b) {
  if (a.first != b.first) return b.first < a.first;
  return b.second < a.second;
}
int main() {
  scanf("%d", &N);
  int a, b;
  for (int i = 0; i < N; i++) {
    scanf("%d%d", &a, &b);
    B[i].first = a, B[i].second = b;
    C[i] = B[i];
  }
  sort(C, C + N);
  set<pair<int, int>> bad;
  pair<int, int> maxi = {0, 0};
  for (int i = N - 1; i >= 0; i--) {
    if (maxi > make_pair(C[i].second, C[i].first))
      bad.insert({C[i].first, C[i].second});
    maxi = max(maxi, {C[i].second, C[i].first});
  }
  int M = 0;
  A[M].first.x = 1000000000, A[M].first.y = 1;
  A[M].second.x = 0, A[M].second.y = 1;
  M++;
  for (int i = 0; i < N; i++)
    if (!bad.count({B[i].first, B[i].second})) {
      A[M].first.x = 1, A[M].first.y = B[i].first;
      A[M].second.x = 1, A[M].second.y = B[i].second;
      M++;
    }
  sort(A, A + M, cmp);
  vector<pair<pt, pt>> envelope;
  for (int i = 0; i < M; i++) {
    while (envelope.size() >= 1 && envelope.back().first == A[i].first &&
           A[i].second <= envelope.back().second)
      envelope.pop_back();
    while (envelope.size() >= 2 &&
           good(envelope[envelope.size() - 2], envelope.back(), A[i]))
      envelope.pop_back();
    envelope.push_back(A[i]);
  }
  set<pair<int, int>> good;
  for (size_t i = 1; i < envelope.size(); i++)
    good.insert({(int)envelope[i].first.y, (int)envelope[i].second.y});
  for (int i = 0; i < N; i++)
    if (good.count({B[i].first, B[i].second})) printf("%d ", i + 1);
  printf("\n");
  return 0;
}
