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 
import java.io.BufferedReader;
import java.io.IOException;
import java.io.InputStream;
import java.io.InputStreamReader;
import java.io.OutputStream;
import java.io.PrintWriter;
import java.io.Reader;
import java.util.Arrays;
import java.util.Comparator;
import java.util.StringTokenizer;
import java.util.TreeSet;

// Codeforces Round #299 (Div. 2)
// Tavas and Pashmaks
public class Problem_535_E {


  public static void main(String[] args)
  {
    InputStream inputStream = System.in;
    OutputStream outputStream = System.out;
    PrintWriter out = new PrintWriter(outputStream);
    Problem_535_E solver = new Problem_535_E();
    solver.solve(1, new InputStreamReader(inputStream), out);
    out.close();
  }

  static class Pair implements Comparable<Pair> {
    int first;

    int second;

    Pair(int f, int s)
    {
      first = f;
      second = s;
    }

    public int compareTo(Pair o)
    {
      int r = first - o.first;

      if(r == 0)
        r = second - o.second;

      return r;
    }
  }

  long vec(int a, int b, int c) {
    return 1l * X[c] * Y[a] * (X[b] - X[a]) * (Y[c] - Y[b]) - 1l * X[a] * Y[c] * (Y[b] - Y[a]) * (X[c] - X[b]);
  }

  int[] X;
  int[] Y;

  public void solve(int test, Reader input, PrintWriter out)
  {
    MyScanner in = new MyScanner(input);

    int n = in.nextInt();

    X = new int[n];
    Y = new int[n];
    TreeSet<Pair> used = new TreeSet<Pair>();
    for (int i = 0; i < n; i++) {
      X[i] = in.nextInt();
      Y[i] = in.nextInt();
    }
    int apt = 0;
    Integer[] A = new Integer[n];
    for (int i = 0; i < n; i++) {
      Pair p = new Pair(X[i], Y[i]);
      if (used.contains(p))
        continue;
      else {
        A[apt++] = i;
        used.add(p);
      }
    }
    A = Arrays.copyOf(A, apt);
    int pos = 0;
    int neg = 0;
    for (int i = 1; i < A.length; i++) {
      if (Y[A[i]] > Y[A[pos]] || (Y[A[i]] == Y[A[pos]] && X[A[i]] > X[A[pos]]))
        pos = i;
      if (X[A[i]] > X[A[neg]] || (X[A[i]] == X[A[neg]] && Y[A[i]] > Y[A[neg]]))
        neg = i;
    }
    neg = A[neg];
    int t = A[0];
    A[0] = A[pos];
    A[pos] = t;
    pos = A[0];
    final Integer[] finalA = A;
    Arrays.sort(A, 1, A.length, new Comparator<Integer>() {
      @Override
      public int compare(Integer a, Integer b) {
        long v = vec(finalA[0], a, b);
        if (v != 0)
          return Long.compare(v, 0);
        else {
          int da = (X[a] - X[finalA[0]]) * (X[a] - X[finalA[0]]) + (Y[a] - Y[finalA[0]]) * (Y[a] - Y[finalA[0]]);
          int db = (X[b] - X[finalA[0]]) * (X[b] - X[finalA[0]]) + (Y[b] - Y[finalA[0]]) * (Y[b] - Y[finalA[0]]);
          return Long.compare(da, db);
        }
      }
    });
    int[] H = new int[A.length];
    int pt = 0;
    H[pt++] = A[0];
    if (pos != neg) {
      for (int i = 1; i < A.length; i++) {
        int p = A[i];
        while (true) {
          if (pt < 2)
            break;
          int a = H[pt - 2];
          int b = H[pt - 1];
          long v = vec(a, b, p);
          if (v > 0)
            --pt;
          else
            break;
        }
        H[pt++] = p;
        if (p == neg)
          break;
      }
    }
    Arrays.sort(H, 0, pt);
    used.clear();
    for (int i = 0; i < pt; i++)
      used.add(new Pair(X[H[i]], Y[H[i]]));
    int cnt = 0;
    for (int i = 0; i < n; i++) {
      if (used.contains(new Pair(X[i], Y[i]))) {
        if(cnt++ > 0)
          out.print(' ');
        out.printf("%d", i + 1);
      }
    }

    out.println();
  }

  //-----------MyScanner class for faster input----------
  public static class MyScanner {
    BufferedReader br;
    StringTokenizer st;

    public MyScanner(Reader reader) {
      br = new BufferedReader(reader);
    }

    String next() {
      while (st == null || !st.hasMoreElements()) {
        try {
          st = new StringTokenizer(br.readLine());
        } catch (IOException e) {
          e.printStackTrace();
        }
      }
      return st.nextToken();
    }

    int nextInt() {
      return Integer.parseInt(next());
    }

    long nextLong() {
      return Long.parseLong(next());
    }

    double nextDouble() {
      return Double.parseDouble(next());
    }

    String nextLine(){
      String str = "";
      try {
        str = br.readLine();
      } catch (IOException e) {
        e.printStackTrace();
      }
      return str;
    }

  }
  //--------------------------------------------------------

}
