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.util.*;
import java.io.*;
public class C
{
	public static void main(String[] args) throws Exception
	{
		FastScanner in = new FastScanner(System.in);
		PrintWriter out = new PrintWriter(System.out);
		
		int n = in.nextInt();
		
		Vector[] ps = new Vector[n];
		Vector[] pr = new Vector[n];
		Vector[] points = new Vector[n];
		for(int x = 0; x < n; x++)
		{
			int s = in.nextInt();
			int r = in.nextInt();
			ps[x] = new Vector(s, r, x);
			pr[x] = new Vector(r, s, x);
			points[x] = new Vector(s, r, x);
		}
		
		Arrays.sort(ps);
		Arrays.sort(pr);
		
		int[] right = scan(ps);
		int[] up = scan(pr);
		
//		System.out.println(Arrays.toString(right));
//		System.out.println(Arrays.toString(up));
		
		StringBuilder result = new StringBuilder();
		for(int y = 0; y < points.length; y++)
		{
			if(right[y] == -1 || up[y] == -1 || ((points[right[y]].y < points[y].y || points[right[y]].x == points[y].x) && (points[up[y]].x < points[y].x || points[up[y]].y == points[y].y)
					&& points[y].subtract(points[right[y]]).cross(points[up[y]].subtract(points[right[y]])) >= 0))
			{
				result.append(y + 1);
				result.append(' ');
			}
		}
		
		out.println(result.toString().trim());
		
		out.close();
	}
	
	public static int[] scan(Vector[] points)
	{
		int[] ret = new int[points.length];
		Arrays.fill(ret, -1);
		
		if(points.length > 1)
		{
			ArrayList<Vector> stack = new ArrayList<Vector>();
			stack.add(points[0]);
			stack.add(points[1]);
			ret[points[1].index] = points[0].index;
			
			int top = 1;
			
			for(int i = 2; i < points.length; i++)
			{
				ret[points[i].index] = stack.get(top).index;
				if(stack.size() > 1 && stack.get(top).subtract(stack.get(top - 1)).cross(points[i].subtract(stack.get(top - 1))) <= 0)
				{
					stack.remove(top);
					top--;
					i--;
				}
				else
				{
					stack.add(points[i]);
					top++;
				}
			}
		}
		
		return ret;
	}
	
	static class Vector implements Comparable<Vector>
	{
		int x;
		int y;
		int index;
		
		public Vector(int x, int y, int i)
		{
			this.x = x;
			this.y = y;
			index = i;
		}
		
		public Vector(int x, int y)
		{
			this.x = x;
			this.y = y;
			index = -1;
		}
		
		public Vector subtract(Vector v)
		{
			return new Vector(x - v.x, y - v.y);
		}
		
		public int cross(Vector v)
		{
			return x * v.y - y * v.x;
		}
		
		public int compareTo(Vector o)
		{
			if(x != o.x)
			{
				return o.x - x;
			}
			else
			{
				return o.y - y;
			}
		}
	}
	
	static class FastScanner
	{
		BufferedReader br;
		StringTokenizer st;
		
		public FastScanner(InputStream input)
		{
			br = new BufferedReader(new InputStreamReader(input));
			st = new StringTokenizer("");
		}
		
		public String next() throws IOException
		{
			if(st.hasMoreTokens())
			{
				return st.nextToken();
			}
			else
			{
				st = new StringTokenizer(br.readLine());
				return next();
			}
		}
		
		public int nextInt() throws IOException
		{
			return Integer.parseInt(next());
		}
	}
}
