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 int INF = (int)2e9;
const long long INFL = (long long)9e18;
const int MAXINT = ((~0) ^ (1 << 31));
const long long MAXLL = ((~0) ^ ((long long)1 << 63));
template <class T>
inline T pow2(T a) {
  return a * a;
}
template <class T>
inline bool mineq(T &a, T b) {
  return (a > b) ? (a = b, true) : false;
}
template <class T>
inline bool maxeq(T &a, T b) {
  return (a < b) ? (a = b, true) : false;
}
const int maxn = (int)2e5 + 10;
;
const int base = 1000 * 1000 * 1000;
struct BigInteger {
  int d[10000], len;
  bool operator<(BigInteger other) const {
    if (len != other.len) return len < other.len;
    for (int i = len - 1; i >= (int)(0); i--) {
      if (d[i] < other.d[i])
        return true;
      else if (d[i] > other.d[i])
        return false;
    }
    return false;
  }
  BigInteger(long long val) {
    len = 0;
    memset(d, 0, 10000 * sizeof(int));
    while (val > 0) {
      d[len] = val % base;
      val /= base;
      len++;
    }
  }
  BigInteger() { BigInteger(0ll); }
  BigInteger(const BigInteger &b) {
    len = b.len;
    for (int i = 0; i < b.len; i++) d[i] = b.d[i];
  }
  static BigInteger fromStr(char *s, BigInteger &r) {
    r.len = 0;
    for (int i = (int)strlen(s); i > 0; i -= 9) {
      s[i] = 0;
      r.d[r.len++] = atoi(i >= 9 ? s + i - 9 : s);
    }
    while (r.d[r.len - 1] == 0) r.d[--(r.len)] = 0;
    return r;
  }
  BigInteger add(BigInteger &b) {
    BigInteger r(b);
    int carry = 0;
    for (int i = 0; i < (((r.len) > (len)) ? (r.len) : (len)) || carry; i++) {
      if (i == r.len) r.d[r.len++] = 0;
      r.d[i] += carry + (i < len ? d[i] : 0);
      carry = r.d[i] >= base;
      if (carry) r.d[i] -= base;
    }
    return r;
  }
  BigInteger add(long long b) {
    BigInteger t(b);
    return add(t);
  }
  BigInteger subtract(const BigInteger &b, int sh = 0) {
    BigInteger r(*this), c(b);
    if (sh > 0) {
      for (int i = c.len - 1; i >= 0; i--) c.d[i + sh] = c.d[i];
      for (int i = 0; i < sh; i++) c.d[i] = 0;
      c.len += sh;
    }
    int carry = 0;
    for (int i = 0; i < c.len || carry; i++) {
      r.d[i] -= carry + (i < c.len ? c.d[i] : 0);
      carry = r.d[i] < 0;
      if (carry) r.d[i] += base;
    }
    while (r.len > 0 && r.d[r.len - 1] == 0) r.d[--(r.len)] = 0;
    return r;
  }
  BigInteger multiply(int val) {
    BigInteger r(*this);
    int carry = 0;
    for (int i = 0; i < r.len || carry; i++) {
      if (i == r.len) r.d[r.len++] = 0;
      long long cur = carry + (long long)(r.d[i]) * val;
      r.d[i] = int(cur % base);
      carry = int(cur / base);
    }
    while (r.len > 0 && r.d[r.len - 1] == 0) r.d[--(r.len)] = 0;
    return r;
  }
  BigInteger multiply(const BigInteger &b) const {
    BigInteger r(0);
    r.len = len + b.len;
    for (int i = 0; i < len; i++)
      for (int j = 0, carry = 0; j < b.len || carry; j++) {
        long long cur =
            r.d[i + j] + (long long)d[i] * (j < b.len ? b.d[j] : 0) + carry;
        r.d[i + j] = int(cur % base);
        carry = int(cur / base);
      }
    while (r.len > 0 && r.d[r.len - 1] == 0) r.d[--(r.len)] = 0;
    return r;
  }
  BigInteger divide(int val, int &rem) {
    BigInteger r(*this);
    rem = 0;
    for (int i = r.len - 1; i >= 0; i--) {
      long long cur = r.d[i] + (long long)rem * base;
      r.d[i] = int(cur / val);
      rem = int(cur % val);
    }
    while (r.len > 0 && r.d[r.len - 1] == 0) r.d[--(r.len)] = 0;
    return r;
  }
  int findBin(BigInteger &rem, BigInteger &b, int sp) {
    int down = 0, up = base;
    BigInteger c;
    while (up - 1 > down) {
      c = b.multiply((up + down) / 2);
      int cm = abscmp(rem, c, sp);
      if (cm == 1) down = (down + up) / 2;
      if (cm == -1) up = (down + up) / 2;
      if (cm == 0) {
        up = (down + up) / 2;
        down = up;
      }
    }
    c = b.multiply((up + down) / 2);
    if (abscmp(rem, c, 0) > 0)
      rem = rem.subtract(c, sp);
    else {
      c = c.subtract(rem, sp);
      rem = c;
    }
    return (up + down) / 2;
  }
  BigInteger divide(BigInteger &d, BigInteger &rem) {
    rem = 0;
    BigInteger res = 0;
    int c = abscmp(d);
    if (c == 0) {
      res.d[0] = 1;
      res.len = 1;
      return res;
    }
    if (c < 0) {
      rem = *this;
      return res;
    }
    rem = *this;
    int sp = len - d.len;
    if (abscmp(*this, d, sp) < 0) sp--;
    res.len = sp + 1;
    while (sp >= 0) {
      res.d[sp] = findBin(rem, d, sp);
      sp--;
    }
    return res;
  }
  int abscmp(const BigInteger &other, int sh = 0) {
    if (len > other.len + sh) return 1;
    if (len < other.len + sh) return -1;
    for (int i = other.len - 1; i >= 0; i--)
      if (d[i + sh] > other.d[i])
        return 1;
      else if (d[i + sh] < other.d[i])
        return -1;
    for (int i = 0; i < sh; i++)
      if (d[i] > 0) return 1;
    return 0;
  }
  int abscmp(const BigInteger &a, const BigInteger &b, int sh = 0) {
    if (a.len > b.len + sh) return 1;
    if (a.len < b.len + sh) return -1;
    for (int i = b.len - 1; i >= 0; i--)
      if (a.d[i + sh] > b.d[i])
        return 1;
      else if (a.d[i + sh] < b.d[i])
        return -1;
    for (int i = 0; i < sh; i++)
      if (a.d[i] > 0) return 1;
    return 0;
  }
  BigInteger pow(int val) {
    BigInteger r = 1, a = *this;
    while (val > 0)
      if ((val & 1) == 0) {
        a = a.multiply(a);
        val >>= 1;
      } else {
        r = r.multiply(a);
        --val;
      }
    return r;
  }
  int cmp(BigInteger &other) { return 0; }
  BigInteger sqrt() {
    BigInteger r = 0;
    r.len = (len + 1) / 2;
    int cur = r.len - 1;
    while (cur >= 0) {
      int up = base - 1, down = 0, v, c = 0;
      while (up > down) {
        v = (up + down) >> 1;
        r.d[cur] = v;
        c = r.multiply(r).abscmp(*this);
        if (c > 0)
          up = v - 1;
        else if (c < 0)
          down = v + 1;
        else
          break;
      }
      while (c < 0) {
        r.d[cur]++;
        c = r.multiply(r).abscmp(*this);
      }
      while (c > 0) {
        r.d[cur]--;
        if (r.multiply(r).abscmp(*this) <= 0) {
          break;
        }
      }
      cur--;
    }
    return r;
  }
  BigInteger gcd(BigInteger &other) {
    BigInteger a(*this), b(other), tmp;
    while (b.len != 0) {
      a.divide(b, tmp);
      a = b;
      b = tmp;
    }
    return a;
  }
};
BigInteger operator+(BigInteger &a, BigInteger &b) {
  BigInteger r = a.add(b);
  return r;
}
BigInteger operator-(BigInteger &a, BigInteger &b) {
  BigInteger r = a.subtract(b);
  return r;
}
BigInteger operator*(const BigInteger &a, const BigInteger &b) {
  BigInteger r = a.multiply(b);
  return r;
}
BigInteger operator/(BigInteger &a, int b) {
  int rem = 0;
  BigInteger r = a.divide(b, rem);
  return r;
}
BigInteger operator/(BigInteger &a, BigInteger &b) {
  BigInteger rem = 0;
  BigInteger r = a.divide(b, rem);
  return r;
}
int operator%(BigInteger &a, int b) {
  int rem = 0;
  if (b >= base)
    return a.d[a.len - 1];
  else
    a.divide(b, rem);
  return rem;
}
BigInteger operator%(BigInteger &a, BigInteger &b) {
  BigInteger rem = 0;
  a.divide(b, rem);
  return rem;
}
BigInteger operator^(BigInteger &a, int b) {
  int rem = 0;
  BigInteger r = a.pow(b);
  return r;
}
basic_ostream<char> &operator<<(basic_ostream<char> &out, const BigInteger &b) {
  short digs[9];
  if (b.len == 0)
    out << 0;
  else {
    for (int i = b.len - 1; i >= 0; i--) {
      int t = b.d[i], k = 0;
      for (int j = 8; j >= 0; j--) {
        digs[j] = t % 10;
        t /= 10;
        if (t == 0 && k == 0) k = j;
      }
      if (i != b.len - 1) k = 0;
      for (int j = k; j < 9; j++) out << digs[j];
    }
  }
  return out;
}
basic_istream<char> &operator>>(basic_istream<char> &in, BigInteger &b) {
  char s[10000 * 9 + 1];
  in >> s;
  BigInteger::fromStr(s, b);
  return in;
}
bool check(BigInteger &a, int p) {
  BigInteger tmp(a);
  int rem;
  while (p > 0) {
    tmp = tmp.divide(2, rem);
    if (rem) return false;
    p--;
  }
  return true;
}
struct pt {
  int x, y, id;
  bool operator<(const pt &a) const { return (x != a.x ? x > a.x : y > a.y); }
  void input(int _id) {
    id = _id;
    cin >> x >> y;
  }
} num[maxn];
vector<pt> stk;
inline int sgn(int a) {
  if (!a) return 0;
  return (a < 0 ? -1 : 1);
}
inline bool cross(pt &a, pt &b, pt &c, pt &d) {
  int sgn1 = sgn(c.x - d.x) * sgn(a.y - b.y);
  int sgn2 = sgn(a.x - b.x) * sgn(c.y - d.y);
  BigInteger t1 = abs(c.x - d.x), t2 = abs(a.y - b.y), t3 = abs(a.x * b.x),
             t4 = abs(d.y * c.y);
  BigInteger t5 = abs(a.x - b.x), t6 = abs(c.y - d.y), t7 = abs(c.x * d.x),
             t8 = abs(a.y * b.y);
  BigInteger A = (t1 * t2 * t3 * t4), B = (t5 * t6 * t7 * t8);
  if (sgn1 != sgn2) return sgn1 < sgn2;
  return ((long double)1 / b.x - (long double)1 / a.x) *
                 ((long double)1 / d.y - (long double)1 / c.y) -
             ((long double)1 / b.y - (long double)1 / a.y) *
                 ((long double)1 / d.x - (long double)1 / c.x) >
         1e-25;
  return A < B;
  return true;
}
inline bool check(pt &a, pt &b, pt &c) { return cross(b, a, b, c); }
void add(pt a) {
  if (!stk.empty()) {
    pt b = stk.back();
    if (a.x == b.x && b.y == a.y) {
      return;
    }
    if (a.y <= b.y) return;
  }
  if (stk.size() < 2) {
    stk.push_back(a);
    return;
  }
  int f = true;
  do {
    pt x = stk[stk.size() - 2], y = stk.back();
    if ((x.x == y.x && x.y == y.y) || check(x, y, a))
      stk.pop_back();
    else
      f = false;
  } while (f && stk.size() >= 2);
  stk.push_back(a);
}
bool cmp(const pt &a, const pt &b) { return a.id < b.id; }
int main() {
  ios_base::sync_with_stdio(0);
  cin.tie(0);
  int n;
  cin >> n;
  for (int i = 0; i < (int)(n); i++) num[i].input(i + 1);
  sort(num, num + n);
  for (int i = 0; i < (int)(n); i++) {
    add(num[i]);
  }
  set<pair<int, int> > st;
  for (int i = 0; i < (int)(stk.size()); i++)
    st.insert(make_pair(stk[i].x, stk[i].y));
  sort(num, num + n, cmp);
  for (int i = 0; i < (int)(n); i++) {
    if (st.count(make_pair(num[i].x, num[i].y))) cout << num[i].id << " ";
  }
}
