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 
from itertools import imap
import sys
n = input()


def parseints(s, n):
    r, i, x = [0] * n, 0, 0
    for c in imap(ord, s):
        if c == 32:
            r[i], i, x = x, i + 1, 0
        else:
            x = x * 10 + c - 48
    return r

z = parseints(sys.stdin.read().replace('\n', ' '), n * 2)
# p = zip(z[::2], z[1::2], range(1, n))
p = zip(z[::2], z[1::2])


def convex_hull(points):
    # points = list(set(points))
    # points.sort(reverse=True)

    if len(points) <= 1:
        return points

    pindex = range(len(points))
    pkey = [x * 10001 + y for x, y in points]
    pindex.sort(key=lambda i: pkey[i], reverse=True)


    def cross(o, a, b):
        ax, ay = a
        bx, by = b
        ox, oy = o
        return (oy * (ox * (ay * bx - ax * by) +
                      ax * bx * (by - ay)) -
                ox * ay * by * (bx - ax))
    # def cross(o, a, b):
    #     return (o[1] * (o[0] * (a[1] * b[0] - a[0] * b[1]) +
    #                     a[0] * b[0] * (b[1] - a[1])) -
    #             o[0] * a[1] * b[1] * (b[0] - a[0]))

    lower = []
    for pi in pindex:
        p = points[pi]
        while len(lower) >= 2 and cross(lower[-2], lower[-1], p) < 0:
            lower.pop()
        if not lower or lower[-1][1] < p[1]:
            lower.append(p)

    return lower

pdic = {}
for i, x in enumerate(p, 1):
    pdic.setdefault(x, []).append(i)

ch = convex_hull(p)
res = []
for x in ch:
    res.extend(pdic[x])

res.sort()
print ' '.join(map(str, res))
