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 

import java.util.*;
import java.io.*;

public class TavasPashmaks {
    public static void main(String[] args) {
        FastScanner scanner = new FastScanner();
        PrintWriter out = new PrintWriter(System.out,false);
        int n =scanner.nextInt();
        P[] pts = new P[n];
        P[] keep = new P[n];
        for(int i = 0; i < n; i++) {
            int a = scanner.nextInt(), b = scanner.nextInt();
            pts[i] = new P(a,b);
            keep[i] = new P(a,b);
        }
        P[] uhull = upper(pts);
        ArrayList<Integer> list= new ArrayList<>();
        TreeSet<P> set = new TreeSet<>();
        for(int i = 0; i < p; i++) {
            //System.out.println("ADDING: " + uhull[i].x + " " + uhull[i].y);
            set.add(uhull[i]);
        }
        for(int i = 0; i < n; i++) {
            //System.out.println("Testing: " + keep[i].x + " " + keep[i].y);
            if (set.contains(keep[i])) list.add(1+i);
        }
        Collections.sort(list);
        for(int i = 0; i < list.size(); i++) {
            if (i > 0) out.print(" ");
            out.print(list.get(i));
        }
        out.println();
        out.flush();
    }

    static class P implements Comparable<P>{
        long x, y;
        int ind;
        public P (long xx, long yy) {
            x = xx; y = yy;
        }
        public int compareTo(P o) {
            if (x == o.x) return Long.compare(y,o.y);
            return Long.compare(x, o.x);
        }
        P sub(P other) {return new P(x- other.x, y - other.y);}
        long det(P other) {return x *other.y - y * other.x;}
        long signedParallelogramArea(P b, P c) {return b.sub(this).det(c.sub(this));}
        long length2() {return x*x+y*y;}
        static long comp(P a, P b, P c) {
            long mx = a.x * b.x * c.x;
            long my = a.y * b.y * c.y;
            P pa = new P(mx / a.x, my / a.y);
            P pb = new P(mx / b.x, my / b.y);
            P pc = new P(mx / c.x, my / c.y);
            return temp(c, b, a);
        }
        static long temp(P a, P b, P c) {
            return new P(b.x-a.x, b.y-a.y).det(new P(c.x-a.x,c.y-a.y));
        }
    }
    static int p = 0;
    static P[] upper (P[] pts) {
        Arrays.sort(pts);
        P[] up = new P[pts.length];
        int N = pts.length;
        for(int i = 0; i < N; i++) {
            while(p > 0 && up[p-1].y <= pts[i].y) p--;
            while(p > 1 && P.comp(up[p-2], up[p-1], pts[i]) < 0) {
                p--;
            }
            up[p++] = pts[i];
        }
        return up;
    }
    public static class FastScanner {
        BufferedReader br;
        StringTokenizer st;
        public FastScanner(Reader in) {
            br = new BufferedReader(in);
        }
        public FastScanner() {
            this(new InputStreamReader(System.in));
        }
        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 readNextLine() {
            String str = "";
            try {
                str = br.readLine();
            } catch (IOException e) {
                e.printStackTrace();
            }
            return str;
        }
    }
}
