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;
const long double EPS = 1e-22L;
int sgn(long double t) { return abs(t) < EPS ? 0 : (t > 0) - (t < 0); }
struct PT {
  long double x, y;
  PT(long double x = 0.0L, long double y = 0.0L) : x(x), y(y) {}
  PT operator-(PT o) { return {x - o.x, y - o.y}; }
  PT operator*(long double t) { return {x * t, y * t}; }
  PT operator/(long double t) { return {x / t, y / t}; }
  PT operator+(PT o) { return {x + o.x, y + o.y}; }
};
long double dot(PT u, PT v) { return u.x * v.x + u.y * v.y; }
long double cross(PT u, PT v) { return u.x * v.y - v.x * u.y; }
long double orient(PT a, PT b, PT c) { return cross(b - a, c - a); }
long double abs(PT p) { return hypot(p.x, p.y); }
bool operator<(PT p, PT q) {
  int sx = sgn(p.x - q.x);
  return sx == 0 ? sgn(p.y - q.y) < 0 : sx < 0;
}
bool operator==(PT p, PT q) {
  return sgn(p.x - q.x) == 0 && sgn(p.y - q.y) == 0;
}
vector<PT> solve(vector<PT>& v) {
  sort(v.begin(), v.end());
  v.erase(unique(v.begin(), v.end()), v.end());
  int n = v.size();
  vector<PT> h;
  int i = 0, j = 1;
  for (int k = 0; k < n; k++) {
    while (i > j && sgn(orient(h[i - 2], h[i - 1], v[k])) < 0) {
      h.resize(--i);
    }
    h.resize(++i, v[k]);
  }
  while (i > 1 && sgn(h[i - 1].y - h[i - 2].y) >= 0) {
    h.resize(--i);
  }
  return h;
}
int main() {
  cin.tie(nullptr);
  ios_base::sync_with_stdio(false);
  int n;
  cin >> n;
  vector<PT> v;
  map<PT, vector<int> > mult;
  for (int i = 1; i <= n; i++) {
    int x, y;
    cin >> x >> y;
    PT p(x, y);
    p.x = 1.0L / p.x;
    p.y = 1.0L / p.y;
    v.push_back(p);
    mult[p].push_back(i);
  }
  auto h = solve(v);
  vector<int> ans;
  for (PT& p : h) {
    for (int k : mult[p]) ans.push_back(k);
  }
  sort(ans.begin(), ans.end());
  for (int k : ans) cout << k << ' ';
}
