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.util.Arrays;
import java.util.Comparator;
import java.util.List;
import java.util.Locale;
import java.util.StringTokenizer;
import java.util.TreeSet;

public class R_TavasAndPashMaks {
    
    private final InputReader reader;
    private final OutputWritter writer;
    
    public R_TavasAndPashMaks(InputReader reader,OutputWritter writer){
        this.reader=reader;
        this.writer=writer;
    }
    
    
    public static void main(String[] args) {
        InputReader reader = new InputReader(System.in);
        OutputWritter writer = new OutputWritter(System.out);
        new R_TavasAndPashMaks(reader, writer).run();
        writer.writer.flush();
     }
    
    int[] X, Y;

    class Pair implements Comparable<Pair> {
        int x, y;
        Pair(int x, int y) {
            this.x = x;
            this.y = y;
        }
        @Override
        public int compareTo(Pair other) {
            if (this.x != other.x)
                return Integer.compare(this.x, other.x);
            return Integer.compare(this.y, other.y);
        }
    }
    List[] eq;
    public void run() {
        int n = reader.nextInt();
        X = new int[n];
        Y = new int[n];
        TreeSet<Pair> used = new TreeSet<Pair>();
        for (int i = 0; i < n; i++) {
            X[i] = reader.nextInt();
            Y[i] = reader.nextInt();
        }
        int apt = 0;
        Integer[] A = new Integer[n];
        for (int i = 0; i < n; i++) {
            if (used.contains(new Pair(X[i], Y[i])))
                continue;
            else {
                A[apt++] = i;
                used.add(new Pair(X[i], Y[i]));
            }
        }
        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]]));
        for (int i = 0; i < n; i++)
            if (used.contains(new Pair(X[i], Y[i])))
                writer.printf("%d ", i + 1);

        writer.printf("\n");
    }

    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]);
    }


    
    static class InputReader{
        public BufferedReader reader;
        public StringTokenizer tokenizer;

        public InputReader(InputStream stream) {
            reader = new BufferedReader(new InputStreamReader(stream), 32768);
            tokenizer = null;
        }

        public String next() {
            while (tokenizer == null || !tokenizer.hasMoreTokens()) {
                try {
                    tokenizer = new StringTokenizer(reader.readLine());
                } catch (IOException e) {
                    throw new RuntimeException(e);
                }
            }
            return tokenizer.nextToken();
        }

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

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

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

    }
    

    static class OutputWritter{
        
        public PrintWriter writer;
        
        public OutputWritter(OutputStream out) {
            this.writer=new PrintWriter(out);
        }
        
        public void printf(String format,Object... args){
            writer.print(String.format(Locale.ENGLISH, format, args));
        }
    }

}