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)
   {
      PrintWriter out = new PrintWriter(System.out);
      new C(new FastScanner(), out);
      out.close();
   }
   
   double cross(vec2 p, vec2 a, vec2 b) {
		return a.sub(p).cross(b.sub(p));
	}
	ArrayList<vec2> convexHull(ArrayList<vec2> pts) {
		vec2[] H = new vec2[pts.size()*2+2];
		int k=0, n=pts.size();
		Collections.sort(pts, new Comparator<vec2>(){
			public int compare(vec2 a, vec2 b) {
				if(Math.abs(a.x-b.x) < 1e-14) return Double.compare(a.y,b.y);
				return Double.compare(a.x,b.x);
			}
		});
		for(int i=0; i<n; i++) { //Lower
			while(k >= 2 && cross(H[k-2],H[k-1],pts.get(i)) <= 1e-14) k--;
			H[k++] = pts.get(i);
		}
		ArrayList<vec2> res = new ArrayList<vec2>();
		for(int i=0; i<k; i++)
			res.add(H[i]);
		return res;
	}

   public C(FastScanner in, PrintWriter out)
   {
      ArrayList<vec2> vs = new ArrayList<vec2>();
      int N = in.nextInt();
      for (int i=0; i<N; i++)
         vs.add(new vec2(1.0/in.nextDouble(), 1.0/in.nextDouble(), i));
   
      vs = convexHull(vs); 
      double minY = Double.MAX_VALUE;
      for (vec2 v : vs)
         if (v.y < minY)
            minY = v.y;
      
      boolean[] didPass = new boolean[N];
      for (vec2 v : vs)
      {
         didPass[v.id] = true;
         if (v.y == minY) break;
      }
      for (int i=0; i<N; i++) if (didPass[i])
      {
         out.print(i+1);
         out.print(' ');
      }
   }
}

class vec2
{
   double x, y;
   int id;
   vec2(double xx, double yy, int id)
   {
      x=xx; y=yy; this.id = id;
   }
   
   vec2(double xx, double yy)
   {
      x=xx; y=yy; id = -1;
   }

   vec2 sub(vec2 rhs)
   {
      return new vec2(x-rhs.x, y-rhs.y);
   }

   double cross(vec2 rhs)
   {
      return x*rhs.y-y*rhs.x;
   }

   public String toString()
   {
      return String.format("<%.6f, %.6f>", x, y);
   }
}

class FastScanner{
   private InputStream stream;
   private byte[] buf = new byte[1024];
   private int curChar;
   private int numChars;

   public FastScanner()
   {
      stream = System.in;
   }

   int read()
   {
      if (numChars == -1)
         throw new InputMismatchException();
      if (curChar >= numChars){
         curChar = 0;
         try{
            numChars = stream.read(buf);
         } catch (IOException e) {
            throw new InputMismatchException();
         }
         if (numChars <= 0)
            return -1;
      }
      return buf[curChar++];
   }

   boolean isSpaceChar(int c)
   {
      return c==' '||c=='\n'||c=='\r'||c=='\t'||c==-1;
   }
   
   boolean isEndline(int c)
   {
      return c=='\n'||c=='\r'||c==-1;
   }

   int nextInt()
   {
      return Integer.parseInt(next());
   }
   
   long nextLong()
   {
      return Long.parseLong(next());
   }

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

   String next(){
      int c = read();
      while (isSpaceChar(c))
         c = read();
      StringBuilder res = new StringBuilder();
      do{
         res.appendCodePoint(c);
         c = read();
      }while(!isSpaceChar(c));
      return res.toString();
   }
   
   String nextLine(){
      int c = read();
      while (isEndline(c))
         c = read();
      StringBuilder res = new StringBuilder();
      do{
         res.appendCodePoint(c);
         c = read();
      }while(!isEndline(c));
      return res.toString();
   }
}
