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.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;
    for(int i = 0; i<n; i++)
    {
        Point p = data[i];
        while(k >= 2 && cross(p, res[k-1], res[k-2]) >= 0) k--;
        res[k++] = p;
    }
    //for(Point p : res) System.out.println(p.x.num+" "+p.x.denom+" "+p.y.num+" "+p.y.denom);
    while(k > 1 && res[k-1].x == res[k-2].x && res[k-1].y < res[k-2].y) k--;
    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;
}
static BigInteger gcd(BigInteger a, BigInteger b)
{
    if(b.signum() == 0) return a;
    return gcd(b, a.mod(b));
}
static class Fraction implements Comparable<Fraction>
{
    BigInteger num, denom;
    public Fraction(BigInteger a, BigInteger b)
    {
        num = a;
        denom = b;
    }
    public Fraction(long a, long b)
    {
        num = BigInteger.valueOf(a);
        denom = BigInteger.valueOf(b);
    }
    void reduce()
    {
        BigInteger g = gcd(num.abs(), denom.abs());
        num = num.divide(g);
        denom = denom.divide(g);
    }
    Fraction add(Fraction f)
    {
        BigInteger nnum = num.multiply(f.denom).add(denom.multiply(f.num));
        BigInteger ndenom = denom.multiply(f.denom);
        return new Fraction(nnum, ndenom);
    }
    Fraction negate()
    {
        return new Fraction(num.negate(), denom);
    }
    Fraction subtract(Fraction f)
    {
        return add(f.negate());
    }
    Fraction multiply(Fraction f)
    {
        return new Fraction(num.multiply(f.num), denom.multiply(f.denom));
    }
    @Override
    public int compareTo(Fraction o) {
        return num.multiply(o.denom).compareTo(denom.multiply(o.num));
    }
    
}
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());
    }
}
}
