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 

//package codeforces;

import java.io.BufferedReader;
import java.io.Closeable;
import java.io.IOException;
import java.io.InputStreamReader;
import java.io.PrintWriter;
import java.math.BigInteger;
import java.util.ArrayList;
import java.util.Arrays;
import java.util.Collections;
import java.util.Comparator;
import java.util.LinkedList;
import java.util.List;
import java.util.Queue;
import java.util.Random;
import java.util.StringTokenizer;

public class C implements Closeable {
    BufferedReader reader = new BufferedReader(new InputStreamReader(System.in));
    PrintWriter writer = new PrintWriter(System.out);
    StringTokenizer stringTokenizer;

    C() throws IOException {
//        reader = new BufferedReader(new FileReader("input.txt"));
//        writer = new PrintWriter(new FileWriter("bridges.out"));
    }

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

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

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

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

    final int MOD = 1000 * 1000 * 1000 + 7;

    int sum(int a, int b) {
        a += b;
        return a >= MOD ? a - MOD : a;
    }

    int product(int a, int b) {
        return (int) (1l * a * b % MOD);
    }

    int pow(int x, int k) {
        int result = 1;
        while (k > 0) {
            if (k % 2 == 1) {
                result = product(result, x);
            }
            x = product(x, x);
            k /= 2;
        }
        return result;
    }

    int pow(int x, long k) {
        int result = 1;
        while (k > 0) {
            if (k % 2 == 1) {
                result = product(result, x);
            }
            x = product(x, x);
            k /= 2;
        }
        return result;
    }

    int inv(int x) {
        return pow(x, MOD - 2);
    }

    void solve() throws IOException {
        class Number implements Comparable<Number> {
            long p, q;

            public Number(long p, long q) {
                this.p = p;
                this.q = q;
            }

            @Override
            public int compareTo(Number o) {
                return BigInteger.valueOf(p * o.q).compareTo(BigInteger.valueOf(o.p * q));
            }
        }
        class Dude {
            int s, r;
            List<Integer> ids = new ArrayList<>();

            Dude(int s, int r, int id) {
                this.s = s;
                this.r = r;
                ids.add(id);
            }

            Number timeToCatchUp(Dude other) {
                return new Number((other.s - this.s) * other.r, 1l * this.s * other.s * (this.r - other.r));
            }
        }
        int n = nextInt();
        Dude[] dudes = new Dude[n];
        for(int i = 0; i < n; i++) {
            dudes[i] = new Dude(nextInt(), nextInt(), i + 1);
        }
        Arrays.sort(dudes, new Comparator<Dude>() {
            @Override
            public int compare(Dude o1, Dude o2) {
                return o2.s - o1.s;
            }
        });
        Dude[] stack = new Dude[n];
        int ni = 0;
        stack[ni++] = dudes[0];
        for(int i = 1; i < n; i++) {
            if(dudes[i].r < stack[ni - 1].r) {
                continue;
            }
            if(dudes[i].r == stack[ni - 1].r) {
                if(dudes[i].s == stack[ni - 1].s) {
                    stack[ni - 1].ids.addAll(dudes[i].ids);
                }
                continue;
            }
            while(ni > 0 && dudes[i].s == stack[ni - 1].s) {
                ni--;
            }
            while(ni >= 2 && dudes[i].timeToCatchUp(stack[ni - 2]).compareTo(stack[ni - 1].timeToCatchUp(stack[ni - 2])) < 0) {
                ni--;
            }
            stack[ni++] = dudes[i];
        }
        List<Integer> answer = new ArrayList<>();
        for(int i = 0; i < ni; i++) {
            answer.addAll(stack[i].ids);
        }
        Collections.sort(answer);
        for (Integer x : answer) {
            writer.print(x + " ");
        }
    }

    public static void main(String[] args) throws IOException {
        try (C c = new C()) {
            c.solve();
        }
    }

    @Override
    public void close() throws IOException {
        reader.close();
        writer.close();
    }
}
