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 
5
10 50
10 50
10 50
10 50
10 50
 2
10000 10000
10000 10000
 3
10000 10000
10000 10000
10000 10000
 3
1000 3000
1500 1500
3000 1000
 43
75 16
70 7
75 16
54 2
70 7
54 2
70 7
54 2
70 7
54 2
54 2
70 7
70 7
54 2
70 7
75 16
70 7
54 2
54 2
54 2
54 2
54 2
54 2
75 16
70 7
70 7
54 2
70 7
75 16
54 2
75 16
75 16
54 2
54 2
70 7
70 7
75 16
70 7
70 7
70 7
75 16
75 16
54 2
 1
1 1
 2
1 1
1 1
 44
78 52
75 16
70 7
75 16
54 2
70 7
54 2
70 7
54 2
70 7
54 2
54 2
70 7
70 7
54 2
70 7
75 16
70 7
54 2
54 2
54 2
54 2
54 2
54 2
75 16
70 7
70 7
54 2
70 7
75 16
54 2
75 16
75 16
54 2
54 2
70 7
70 7
75 16
70 7
70 7
70 7
75 16
75 16
54 2
 3
1000 3000
1499 1499
3000 1000
 5
50 50
49 50
50 49
49 49
50 1
 18
82 38
33 69
33 69
33 69
33 69
33 69
82 38
33 69
33 69
33 69
82 38
33 69
33 69
82 38
82 38
33 69
33 69
33 69
 1
10000 9999
 3
1000 3000
1501 1501
3000 1000
 2
1 2
2 1

1 2 3 4 5
 1 2
 1 2 3
 1 2 3
 1 3 16 24 29 31 32 37 41 42
 1
 1 2
 1
 1 3
 1
 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18
 1
 1 2 3
 1 2 

#include <bits/stdc++.h>
using namespace std;
const int N = 200005;
const int M = 10005;
long long gcd(long long a, long long b) {
  if (a == 0 && b == 0) return 1;
  if (a < 0) a *= -1;
  if (b < 0) b *= -1;
  long long t;
  while (a > 0) {
    t = a;
    a = b % a;
    b = t;
  }
  return max(b, 1ll);
}
struct fraction {
  long long num, den;
  fraction(long long x = 0, long long y = 1) {
    if (y < 0) {
      x *= -1, y *= -1;
    }
    long long g = gcd(x, y);
    num = x / g;
    den = y / g;
  }
  fraction(const fraction& f) : num(f.num), den(f.den) {}
  fraction& operator=(const fraction& f) {
    num = f.num;
    den = f.den;
    return *this;
  }
  fraction operator+(const fraction& f) const {
    long long g2 = gcd(den, f.den);
    return fraction(f.den / g2 * num + den / g2 * f.num, den / g2 * f.den);
  }
  fraction operator-(const fraction& f) const {
    long long g2 = gcd(den, f.den);
    return fraction(f.den / g2 * num - den / g2 * f.num, den / g2 * f.den);
  }
  fraction operator*(const fraction& f) const {
    long long g1 = gcd(num, f.den);
    long long g2 = gcd(den, f.num);
    return fraction((num / g1) * (f.num / g2), (den / g2) * (f.den / g1));
  }
  bool operator==(const fraction& f) const {
    return num == f.num && den == f.den;
  }
  bool operator<(const fraction& f) const {
    long long g1 = gcd(num, f.num);
    long long g2 = gcd(den, f.den);
    return (num / g1) * (f.den / g2) < (f.num / g1) * (den / g2);
  }
  bool operator>(const fraction& f) const {
    long long g1 = gcd(num, f.num);
    long long g2 = gcd(den, f.den);
    return (num / g1) * (f.den / g2) > (f.num / g1) * (den / g2);
  }
};
struct point {
  fraction x, y;
  vector<int>* pointer;
  point() {}
  point(const point& p) : x(p.x), y(p.y), pointer(p.pointer) {}
  bool operator<(const point& p) const { return x == p.x ? y < p.y : x < p.x; }
  point& operator=(const point& p) {
    x = p.x;
    y = p.y;
    pointer = p.pointer;
  }
};
fraction cross(const point& a, const point& b) { return a.x * b.y - a.y * b.x; }
fraction cross(const point& a, const point& b, const point& c) {
  return cross(a, b) + cross(b, c) + cross(c, a);
}
bool minY(const point& a, const point& b) {
  return a.y == b.y ? a.x < b.x : a.y < b.y;
}
point p[N], *hull[N];
int n, h, winners[N], size;
map<int, map<int, vector<int> > > ID;
bool thetaSort(const point& a, const point& b) { return cross(p[0], a, b) > 0; }
void convexHull() {
  swap(*min_element(p, p + n), p[0]);
  sort(p + 1, p + n, thetaSort);
  h = 0;
  for (int i = 0; i < n; hull[h++] = &p[i++])
    while (h >= 2 && cross(*hull[h - 2], *hull[h - 1], p[i]).num < 0) --h;
  --h;
}
int main() {
  ios::sync_with_stdio(false);
  cin.tie(0);
  cin >> n;
  for (int i = 0; i < n; ++i) {
    int x, y;
    cin >> x >> y;
    ID[x][y].push_back(i + 1);
  }
  n = 0;
  for (map<int, map<int, vector<int> > >::iterator it = ID.begin();
       it != ID.end(); ++it) {
    for (map<int, vector<int> >::iterator it2 = it->second.begin();
         it2 != it->second.end(); ++it2) {
      p[n].x.num = p[n].y.num = 1;
      p[n].x.den = it->first;
      p[n].y.den = it2->first;
      p[n].pointer = &it2->second;
      ++n;
    }
  }
  convexHull();
  int ix = 0;
  for (int i = 1; i < h; ++i) {
    if (*hull[i] < *hull[ix]) ix = i;
  }
  int iy = 0;
  for (int i = 1; i < h; ++i) {
    if (minY(*hull[i], *hull[iy])) iy = i;
  }
  for (int i = ix; i % h != iy; ++i) {
    vector<int>& v = *hull[i % h]->pointer;
    for (int j = 0; j < v.size(); ++j) winners[size++] = v[j];
  }
  vector<int>& v = *hull[iy]->pointer;
  for (int j = 0; j < v.size(); ++j) winners[size++] = v[j];
  sort(winners, winners + size);
  cout << winners[0];
  for (int i = 1; i < size; ++i) {
    if (winners[i - 1] != winners[i]) cout << ' ' << winners[i];
  }
  cout << endl;
}
