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.util.*;
import static java.lang.Math.*;
import java.io.*;

public class C {
    public static void main(String[] args) throws Exception {
        BufferedReader in = new BufferedReader(new InputStreamReader(System.in));
        StringTokenizer stok = new StringTokenizer(in.readLine());
        int N = Integer.valueOf(stok.nextToken());
        Person[] P = new Person[N];
        for (int i = 0; i < N; i++) {
            stok = new StringTokenizer(in.readLine());
            int s = Integer.valueOf(stok.nextToken());
            int r = Integer.valueOf(stok.nextToken());
            P[i] = new Person(s, r, i + 1);
        }
        Arrays.sort(P);
        ArrayList<Person> S = new ArrayList<Person>();
        Person prev = null;
        for (Person p : P) {
            //System.out.println(p);
            if (prev != null && p.compareTo(prev) == 0) {
                //System.out.println("pre");
                prev.idxs.addAll(p.idxs);
                continue;
            }
            prev = p;
            if (S.size() > 0) {
                Person last = S.get(S.size() - 1);
                if (last.s >= p.s && last.r >= p.r) {
                    //System.out.println("dominated");
                    continue;
                }
            }
            S.add(p);
            while (S.size() >= 3 && 
                   ccw(S.get(S.size() - 3), S.get(S.size() - 2), S.get(S.size() -1))) {
                S.remove(S.size() - 2);
            }
        }
        //System.out.println(S);
        StringBuffer anss = new StringBuffer("");
        ArrayList<Integer> ans = new ArrayList<Integer>();
        for (Person p : S)
            for (int idx : p.idxs)
                ans.add(idx);
        Collections.sort(ans);
        for (int a : ans)
            anss.append(a+" ");
        System.out.println(anss);
    }
    static boolean ccw(Person a, Person b, Person c) {
        return a.s * c.r * (a.r - b.r) * (b.s - c.s) < (a.s - b.s) * (b.r - c.r) * a.r * c.s;
    }

    static class Person implements Comparable<Person> {
        long s, r;
        ArrayList<Integer> idxs;
        public Person(int s, int r, int idx) {
            this.s = s;
            this.r = r;
            this.idxs = new ArrayList<Integer>();
            this.idxs.add(idx);
        }
        public int compareTo(Person p) {
            if (r > p.r)
                return -1;
            if (r < p.r)
                return 1;
            if (s > p.s)
                return -1;
            if (s < p.s)
                return 1;
            return 0;
        }
        public String toString() {
            return String.format("(%d, %d, %s)", s, r, idxs);
        }
    } 
}
