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 inf = 1e9;
const long long inf_ll = 1e18;
template <typename T, typename U>
using c_t = decltype(T() + U());
template <typename T>
struct point {
  T x, y;
  point(T _x, T _y) : x(_x), y(_y) {}
  point() : point(0, 0) {}
  template <typename U>
  point(point<U> a) : point(a.x, a.y) {}
  friend string to_string(const point a) {
    return "(" + to_string(a.x) + ", " + to_string(a.y) + ")";
  }
  friend istream& operator>>(istream& i, point& a) { return i >> a.x >> a.y; }
  friend ostream& operator<<(ostream& o, const point a) {
    return o << "(" << a.x << ", " << a.y << ")";
  }
  point& operator+=(const point a) {
    x += a.x, y += a.y;
    return *this;
  }
  point& operator-=(const point a) {
    x -= a.x, y -= a.y;
    return *this;
  }
  template <typename U>
  point& operator*=(const U r) {
    x *= r, y *= r;
    return *this;
  }
  template <typename U>
  point& operator/=(const U r) {
    x /= r, y /= r;
    return *this;
  }
  template <typename U>
  friend point<c_t<T, U>> operator+(point a, point<U> b) {
    return {a.x + b.x, a.y + b.y};
  }
  template <typename U>
  friend point<c_t<T, U>> operator-(point a, point<U> b) {
    return {a.x - b.x, a.y - b.y};
  }
  template <typename U>
  friend point<c_t<T, U>> operator*(const point a, const U r) {
    return {a.x * r, a.y * r};
  }
  template <typename U>
  friend point<c_t<T, U>> operator*(const U r, const point a) {
    return {a.x * r, a.y * r};
  }
  template <typename U>
  friend point<c_t<T, U>> operator/(const point a, const U r) {
    return {a.x / r, a.y / r};
  }
  template <size_t i>
  T get() {
    return i ? y : x;
  }
  template <typename U>
  friend bool operator==(const point a, const point<U> b) {
    return a.x == b.x && a.y == b.y;
  }
  template <typename U>
  friend bool operator<(const point a, const point<U> b) {
    return a.x == b.x ? a.y < b.y : a.x < b.x;
  }
};
template <typename T>
T sqdist(point<T> a) {
  return a.x * a.x + a.y * a.y;
}
double dist(point<double> a) { return hypot(a.x, a.y); }
double dist(point<double> a, point<double> b) { return dist(a - b); }
template <typename T, typename U>
c_t<T, U> dot(point<T> a, point<U> b) {
  return a.x * b.x + a.y * b.y;
}
template <typename T, typename U>
c_t<T, U> cross(point<T> a, point<U> b) {
  return a.x * b.y - a.y * b.x;
}
point<double> proj(point<double> a, point<double> b, point<double> c) {
  return dot(a - b, c - b) / sqdist(c - b) * (c - b) + b;
}
point<double> intersection(point<double> a, point<double> b, point<double> c,
                           point<double> d) {
  double s = cross(a - c, b - a) / double(cross(d - c, b - a));
  return s * d + (1 - s) * c;
}
bool intersects(point<double> a, point<double> b, point<double> c,
                point<double> d) {
  double s = cross(a - c, b - a) / double(cross(d - c, b - a)),
         t = cross(c - a, d - c) / double(cross(b - a, d - c));
  return t >= 0 && t <= 1 && s >= 0 && s <= 1;
}
double dist(point<double> a, point<double> b, point<double> c) {
  return dist(
      min(double(1), max(double(0), dot(a - b, c - b) / sqdist(c - b))) *
          (c - b) +
      b - a);
}
double dist(point<double> a, point<double> b, point<double> c,
            point<double> d) {
  if (intersects(a, b, c, d)) return 0;
  return min(min(dist(a, c, d), dist(b, c, d)),
             min(dist(c, a, b), dist(d, a, c)));
}
template <typename T>
T area(vector<point<T>> v) {
  T out = cross(v.back(), v[0]);
  for (int i = 0; i < v.size() - 1; i++) out += cross(v[i], v[i + 1]);
  return out;
}
template <typename T>
bool contains(vector<point<T>> v, point<T> a) {
  bool out = 0;
  for (int i = 0; i < v.size(); i++) {
    auto b = v[i], c = v[(i + 1) % v.size()];
    if (b.y > c.y) swap(b, c);
    if (b.y <= a.y && a.y < c.y && cross(b - a, c - a) > 0) out ^= 1;
  }
  return out;
}
const int N = 2e5 + 5;
pair<point<double>, int> a[N];
const double eps = 1e-6;
int main() {
  ios_base::sync_with_stdio(0);
  cin.tie(0);
  cout.tie(0);
  cout << "a" << endl;
  int n;
  cin >> n;
  for (int i = 0; i < n; i++) {
    int x, y;
    cin >> x >> y;
    a[i] = {{-1. / x, -1. / y}, i};
  }
  cout << "a" << endl;
  sort(a, a + n);
  vector<pair<point<double>, int>> v;
  for (int i = 0; i < n; i++) {
    while (!v.empty() && v.back().first.y < a[i].first.y) v.pop_back();
    while (v.size() > 1 && cross(a[i].first - v.back().first,
                                 v.back().first - v[v.size() - 2].first) < -eps)
      v.pop_back();
    v.push_back(a[i]);
  }
  vector<int> out;
  for (auto& [_, i] : v) out.push_back(i);
  sort((out).begin(), (out).end());
  for (auto& i : out) cout << i + 1 << " ";
}
