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 runswim {
	
	private static final int INF = (int)1e9;
	private static class Pt implements Comparable <Pt> {
		double x; double y;
		public Pt(double a, double b){
			x = a; y = b;
		}
		public int compareTo(Pt arg0) {
			int t = Double.compare(x, arg0.x);
			if(t!=0)return t;
			return Double.compare(y, arg0.y);
		}
		public static boolean ccw(Pt o, Pt a, Pt b){
			return (a.x - o.x) * (b.y - o.y) - (a.y - o.y) * (b.x - o.x) >= 0;
		}
		public String toString(){
			return "(" + x + ", " + y + ")";
		}
		private static final double EPS = 1e-6;
		public static boolean equals(double a, double b){
			return Math.abs(a-b) <= EPS * Math.max(1.0, Math.max(a,b));
		}
		public static Pt[] lowerHull(Pt[] points, boolean keepVertical){
			/**
			 * MODIFIES input array quite nontrivially
			 */
			
			//be careful about vertical ones.
			Arrays.sort(points);
			int start = 0;
			int end = points.length;
			if(keepVertical){
				//we can't miss out on all vertical ones at the end
				
			}
			else{
//				//we have all vertical ones at the beginning and need to delete them
				//actually, no.
//				double x0 = points[0].x;
//				while(equals(points[start+1].x, x0)){
//					start++;
//				}				
			}
			
			ArrayList<Pt> Q = new ArrayList<Pt>();
			for(int i=start;i<end;i++){
				Pt p = points[i];
				while(Q.size() >= 2 && ccw(Q.get(Q.size() - 1), Q.get(Q.size() - 2), p)){
					Q.remove(Q.size() - 1);
				}
				Q.add(p);
			}
			
			Pt[] ans = new Pt[Q.size()];
			for(int i=0;i<Q.size();i++){
				ans[i] = Q.get(i);
			}
			return ans;
		}
	}
	public static void main(String[] args) throws IOException {
		BufferedReader f = new BufferedReader(new InputStreamReader(System.in));
		int N = Integer.parseInt(f.readLine());
		TreeMap<Pt, ArrayList<Integer>> M = new TreeMap<Pt, ArrayList<Integer>>();
		Pt[] points = new Pt[N];
		for(int i=0;i<N;i++){
			StringTokenizer st = new StringTokenizer(f.readLine());
			double swim = Integer.parseInt(st.nextToken());
			double run = Integer.parseInt(st.nextToken());
			swim = 100/swim;
			run = 100/run;
			double x = swim;
			double y = run;
			Pt p = new Pt(x,y);
			points[i] = p;
			if(!M.containsKey(p)){
				M.put(p, new ArrayList<Integer>());
			}
			M.get(p).add(i+1);
		}
		Pt[] hull = Pt.lowerHull(points, false);
		ArrayList<Integer> answers = new ArrayList<Integer>();
		
//		for(Pt p : hull){
//			System.out.println(p);
//		}
		for(int i=0;i<hull.length;i++){
			answers.addAll(M.get(hull[i]));
			if(i != hull.length - 1 && (hull[i+1].y > hull[i].y || Pt.equals(hull[i+1].y, hull[i].y))){
//				System.out.println(hull[i+1].y + " " + hull[i].y);
				break;
			}
		}
		Collections.sort(answers);
		for(int t : answers){
			System.out.print(t + " ");
		}
	}
}
