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;
struct P {
  double x, y;
  int id;
  P() {}
  P(double x, double y) : x(x), y(y) {}
  P operator+(P p) { return P(x + p.x, y + p.y); }
  void operator+=(P p) { x += p.x, y += p.y; }
  P operator-(P p) { return P(x - p.x, y - p.y); }
  void operator-=(P p) { x -= p.x, y -= p.y; }
  P operator*(double d) { return P(x * d, y * d); }
  void operator*=(double d) { x *= d, y *= d; }
  P operator/(double d) { return P(x / d, y / d); }
  void operator/=(double d) { x /= d, y /= d; }
  void read() { scanf("%lf%lf", &x, &y); }
  bool operator<(const P p) const {
    if (fabs(p.x - x) < 1e-7) {
      if (fabs(p.y - y) < 1e-7) return false;
      return y < p.y;
    }
    return x < p.x;
  }
  bool operator==(const P p) const {
    return fabs(p.x - x) < 1e-7 && fabs(p.y - y) < 1e-7;
  }
  bool operator!=(const P p) const {
    return fabs(p.x - x) > 1e-7 || fabs(p.y - y) > 1e-7;
  }
  P rotate(double d) {
    return P(x * cos(d) - y * sin(d), x * sin(d) + y * cos(d));
  }
};
struct L {
  P p1, p2;
  L() {}
  L(P p1, P p2) : p1(p1), p2(p2) {}
  P vector<int>() { return p2 - p1; }
  P unit(double d) {
    P res = p2 - p1;
    double vecl =
        sqrt((p1.x - p2.x) * (p1.x - p2.x) + (p1.y - p2.y) * (p1.y - p2.y));
    return res * double(d / vecl);
  }
};
double dot(P p1, P p2) { return p1.x * p2.x + p1.y * p2.y; }
double det(P p1, P p2) { return p1.x * p2.y - p2.x * p1.y; }
double norm(P p) { return sqrt(p.x * p.x + p.y * p.y); }
int ccw(P a, P b, P c) {
  b = b - a, c = c - a;
  if (det(b, c) > 1e-7) return 1;
  if (det(b, c) < -1e-7) return -1;
  if (dot(b, c) < -1e-7) return 2;
  if (norm(b) < norm(c)) return -2;
  return 0;
}
double angle(P p1, P p2) { return fabs(atan2(det(p1, p2), dot(p1, p2))); }
bool is_parallel(L l, L m) {
  return fabs(det(l.vector<int>(), m.vector<int>())) < 1e-7;
}
bool intersectLL(L l, L m) {
  return !is_parallel(l, m) || fabs(det(l.vector<int>(), m.p1 - l.p1)) < 1e-7;
}
bool intersectLS(L l, L s) {
  return det(l.vector<int>(), s.p1 - l.p1) * det(l.vector<int>(), s.p2 - l.p1) <
         1e-7;
}
bool intersectLP(L l, P p) { return fabs(det(l.p2 - p, l.p1 - p)) < 1e-7; }
bool intersectSS(L s, L t) {
  return ccw(s.p1, s.p2, t.p1) * ccw(s.p1, s.p2, t.p2) <= 0 &&
         ccw(t.p1, t.p2, s.p1) * ccw(t.p1, t.p2, s.p2) <= 0;
}
bool intersectSP(L s, P p) {
  return norm(s.p1 - p) + norm(s.p2 - p) - norm(s.vector<int>()) < 1e-7;
}
P crosspointSS(L s, L t) {
  return s.p1 + (s.vector<int>()) * (det(t.vector<int>(), t.p1 - s.p1) /
                                     det(t.vector<int>(), s.vector<int>()));
}
P crosspointLL(L s, L t) {
  double A = det(s.vector<int>(), t.vector<int>());
  double B = det(s.vector<int>(), s.p2 - t.p1);
  if (fabs(A) < 1e-7 && fabs(B) < 1e-7) return s.p1;
  if (fabs(A) < 1e-7) return P((1 << 28), (1 << 28));
  return t.p1 + t.vector<int>() * (B / A);
}
double distPP(P a, P b) { return norm(a - b); }
double distSP(L s, P p) {
  if (dot(s.p2 - s.p1, p - s.p1) < 1e-7) return distPP(s.p1, p);
  if (dot(s.p1 - s.p2, p - s.p2) < 1e-7) return distPP(s.p2, p);
  return fabs(det(s.p2 - s.p1, p - s.p1)) / distPP(s.p1, s.p2);
}
double distSS(L s, L t) {
  if (intersectSS(s, t)) return 0;
  return min(min(distSP(s, t.p1), distSP(s, t.p2)),
             min(distSP(t, s.p1), distSP(t, s.p2)));
}
vector<P> convex_hull(vector<P> kk) {
  vector<P> res;
  int n = kk.size();
  sort(kk.begin(), kk.end());
  res.resize(n * 2 + 1);
  int k = 0;
  for (int(i) = 0; (i) < (n); (i)++) {
    while (k >= 2 && det(res[k - 1] - res[k - 2], kk[i] - res[k - 1]) <= 1e-7)
      k--;
    res[k++] = kk[i];
  }
  res.resize(k);
  return res;
}
int N;
double A, B;
vector<P> p;
int main() {
  scanf("%d", &N);
  p.resize(N);
  for (int(i) = 0; (i) < (N); (i)++) {
    scanf("%lf%lf", &A, &B);
    p[i] = P(1.0 / A, -1.0 / B);
    p[i].id = i + 1;
  }
  vector<P> tt = convex_hull(p);
  for (int(i) = 0; (i) < (N); (i)++) {
    bool ok = false;
    for (int(j) = (1); (j) < (tt.size()); (j)++) {
      L l = L(tt[j - 1], tt[j]);
      if (intersectSP(l, p[i])) ok = true;
      if (ok) break;
    }
    for (int(j) = 0; (j) < (tt.size()); (j)++)
      if (distPP(tt[j], p[i]) < 1e-7) ok = true;
    if (ok) printf("%d ", i + 1);
  }
}
