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.*;
import java.util.*;
import java.math.*;
public class C536 {
public static void main(String[] args) throws IOException {
    input.init(System.in);
    PrintWriter out = new PrintWriter(System.out);
    int n = input.nextInt();
    Point[] data = new Point[n];
    for(int i = 0; i<n; i++) data[i] = new Point(input.nextInt(), input.nextInt(), i);
    ArrayList<Integer> res = new ArrayList<Integer>();
    Point[] p = hull(data);
    for(int i = 0; i<p.length; i++)
    {
        res.add(p[i].i);
    }
    Collections.sort(res);
    for(int i = 0; i<res.size(); i++) out.print(res.get(i)+1+" ");
    out.close();
}
static Point[] hull(Point[] data)
{
    Arrays.sort(data);
    int n = data.length;
    Point[] res = new Point[n];
    int k = 0;
    long maxy = 0, maxx = 0;
    long[] max = new long[100001];
    Point[] unique = new Point[n];
    int u = 0;
    for(int i = 0; i<n; i++)
    {
        Point p = data[i];
        //if(k >= 2) System.out.println(cross(p, res[k-1], res[k-2]));
        while(u >= 2 && cross(p, unique[u-1], unique[u-2]) > 0)
        {
            while(k > 0 && res[k-1].x == unique[u-1].x && res[k-1].y == unique[u-1].y) k--;
            u--;
        }
        if(data[i].x >= max[(int) data[i].y] && (data[i].y >= maxy || data[i].x >= maxx))
        {
            maxx = Math.max(maxx,  data[i].x);
            maxy = Math.max(maxy,  data[i].y);
            max[(int)data[i].y] = data[i].x;
            if(u == 0 || (p.x != unique[u-1].x || p.y != unique[u-1].y)) unique[u++] = p;
            res[k++] = p;
        }
        if(u > 1 && unique[u-1].x == unique[u-2].x && unique[u-1].y != unique[u-2].y)
        {
            while(k > 0 && res[k-1].x == unique[u-1].x && res[k-1].y == unique[u-1].y) k--;
            u--;
        }
        else if(u > 1 && unique[u-1].y == unique[u-2].y && unique[u-1].x != unique[u-2].x)
        {
            while(k > 0 && res[k-1].x == unique[u-1].x && res[k-1].y == unique[u-1].y) k--;
            u--;
        }
    }
    //for(Point p : res) System.out.println(p.x.num+" "+p.x.denom+" "+p.y.num+" "+p.y.denom);
    return Arrays.copyOf(res, k);
}
static long cross(Point p, Point a, Point b)
{
    return a.x * p.y * b.x * b.y + p.x * b.y * a.x * a.y - a.y * p.x * b.x * b.y - p.y * b.x * a.x * a.y + p.x * p.y * a.y * b.x - p.x * p.y * a.x * b.y;
}
static class Point implements Comparable<Point>
{
    long x, y;
    int i;
    public Point(long xx, long yy, int ii)
    {
        x = xx;
        y = yy;
        i = ii;
    }
    public int compareTo(Point o)
    {
        int cx = -Long.compare(x,  o.x);
        if(cx != 0) return cx;
        return -Long.compare(y,  o.y);
    }
}
public static class input {
    static BufferedReader reader;
    static StringTokenizer tokenizer;

    static void init(InputStream input) {
        reader = new BufferedReader(new InputStreamReader(input));
        tokenizer = new StringTokenizer("");
    }

    static String next() throws IOException {
        while (!tokenizer.hasMoreTokens())
            tokenizer = new StringTokenizer(reader.readLine());
        return tokenizer.nextToken();
    }

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

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

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