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 People {
  long speedS;
  long speedR;
  int index;
};
long BinSearch(vector<People> winList, long begin, long end,
               vector<double> multiplier, People current) {
  if (end == begin) return begin;
  long mid = (end - begin) / 2;
  if (mid == 0) return 1;
  double mul = (double)((winList[mid - 1].speedS - winList[mid].speedS) *
                        (winList[mid - 1].speedR * winList[mid].speedR)) /
               ((winList[mid].speedR - winList[mid - 1].speedR) *
                winList[mid - 1].speedS * winList[mid].speedS);
  ;
  double midValue =
      (double)(mul) / (winList[mid].speedR) + (double)(1) / winList[mid].speedS;
  ;
  double currentValue =
      (double)(mul) / (current.speedR) + (double)(1) / current.speedS;
  ;
  if (currentValue < midValue) {
    double prev = 0;
    if (mid > 1) {
      double fac =
          (double)((winList[mid - 2].speedS - winList[mid - 1].speedS) *
                   (winList[mid - 2].speedR * winList[mid - 1].speedR)) /
          ((winList[mid - 1].speedR - winList[mid - 2].speedR) *
           winList[mid - 2].speedS * winList[mid - 1].speedS);
      prev = (double)(fac) / (winList[mid - 1].speedR) +
             (double)(1) / winList[mid - 1].speedS;
      ;
    }
    if (mid == 1 || prev < currentValue) {
      return mid;
    }
    return BinSearch(winList, begin, mid - 1, multiplier, current);
  } else {
    return BinSearch(winList, mid + 1, end, multiplier, current);
  }
  return -1;
}
void FindPossibleWiners(vector<People> speed) {
  vector<People> winList(speed.size());
  sort(speed.begin(), speed.end(), [](People a, People b) {
    return a.speedS < b.speedS || (a.speedS == b.speedS && a.speedR < b.speedR);
  });
  long currentR = 0;
  long currentS = 0;
  long length = 0;
  for (long i = speed.size() - 1; i >= 0; i--) {
    if (speed[i].speedR > currentR ||
        (speed[i].speedR == currentR && speed[i].speedS == currentS)) {
      for (long j = length - 1; j > 0; j--) {
        double yPrvfac = (double)((winList[j - 1].speedS - winList[j].speedS) *
                                  (winList[j - 1].speedR * winList[j].speedR)) /
                         ((winList[j].speedR - winList[j - 1].speedR) *
                          winList[j - 1].speedS * winList[j].speedS);
        ;
        double yfac = (double)((winList[j - 1].speedS - speed[i].speedS) *
                               (winList[j - 1].speedR * speed[i].speedR)) /
                      ((speed[i].speedR - winList[j - 1].speedR) *
                       winList[j - 1].speedS * speed[i].speedS);
        ;
        if (yfac >= yPrvfac) break;
        length--;
      }
      winList[length++] = speed[i];
      currentS = speed[i].speedS;
      currentR = speed[i].speedR;
    }
  }
  winList.resize(length);
  sort(winList.begin(), winList.end(),
       [](People a, People b) { return a.index < b.index; });
  for (int i = 0; i < winList.size(); i++) cout << winList[i].index << " ";
}
int main(int argc, char** argv) {
  int cPeople = 0;
  vector<People> people(cPeople);
  cin >> cPeople;
  for (int i = 0; i < cPeople; i++) {
    People tempP;
    cin >> tempP.speedS;
    cin >> tempP.speedR;
    tempP.index = i + 1;
    people.push_back(tempP);
  }
  FindPossibleWiners(people);
}
