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.io.BufferedWriter;
import java.util.InputMismatchException;
import java.util.ArrayList;
import java.util.List;
import java.util.NoSuchElementException;
import java.math.BigInteger;
import java.util.Vector;
import java.io.OutputStream;
import java.util.Stack;
import java.util.Collections;
import java.io.PrintWriter;
import java.io.Writer;
import java.io.IOException;
import java.util.Arrays;
import java.io.InputStream;
import java.util.Collection;
import java.io.OutputStreamWriter;
import java.util.Comparator;

/**
 * Built using CHelper plug-in
 * Actual solution is at the top
 * @author Stanislav Pak
 */
public class Main {
	public static void main(String[] args) {
		InputStream inputStream = System.in;
		OutputStream outputStream = System.out;
		InputReader in = new InputReader(inputStream);
		OutputWriter out = new OutputWriter(outputStream);
		TaskC solver = new TaskC();
		solver.solve(1, in, out);
		out.close();
	}
}

class TaskC {
	class Line {
		final List<Integer> ids;
		final double a, b;

		Line(List<Integer> ids, double a, double b) {
			this.ids = ids;
			this.a = a;
			this.b = b;
		}

		public boolean equals(Object o) {
			if (o instanceof Line) {
				Line l = (Line) o;
				return Math.abs(l.a - a) < GeometryUtils.epsilon && Math.abs(l.b - b) < GeometryUtils.epsilon;
			} else {
				return false;
			}
		}

		public double at(double x) {
			return a * x + b;
		}

		public boolean parallelTo(Line line) {
			return Math.abs(line.a - a) < GeometryUtils.epsilon;
		}

		public double intersectWith(Line line) {
			assert !parallelTo(line);
			return (line.b - b) / (a - line.a);
		}
	}
    public void solve(int testNumber, InputReader in, OutputWriter out) {
		int n = in.readInt();
		Line[] lines = new Line[n];
		for (int i = 0; i < n; ++i) {
			double s = in.readInt();
			double r = in.readInt();
			lines[i] = new Line(new ArrayList<Integer>(), 1 / s, 1 / r);
			lines[i].ids.add(i);
		}
		Arrays.sort(lines, new Comparator<Line>() {
			public int compare(Line o1, Line o2) {
				if (Math.abs(o1.a - o2.a) > GeometryUtils.epsilon) {
					if (o1.a > o2.a) return -1;
					return 1;
				}
				if (o1.b + GeometryUtils.epsilon < o2.b) return 1;
				if (o1.b > o2.b + GeometryUtils.epsilon) return -1;
				return 0;
			}
		});
		int m = 1;
		for (int i = 1; i < n; ++i) {
			if (lines[m - 1].equals(lines[i])) {
				lines[m - 1].ids.add(lines[i].ids.get(0));
				continue;
			}
			lines[m++] = lines[i];
		}
		lines = Arrays.copyOf(lines, m);
		Stack<Line> stack = new Stack<>();
		for (Line line : lines) {
			while (!stack.isEmpty()) {
				if (stack.peek().parallelTo(line)) {
					stack.pop();
					continue;
				}
				if (stack.size() == 1) break;
				Line last = stack.pop();
				double x = last.intersectWith(stack.peek());
				if (line.at(x) + GeometryUtils.epsilon >= last.at(x)) {
					stack.add(last);
					break;
				}
			}
			stack.add(line);
		}
		List<Integer> ids = new ArrayList<>();
		for (Line line : stack) {
			ids.addAll(line.ids);
		}
		Collections.sort(ids);
		for (int i = 0; i < ids.size(); ++i) {
			if (i > 0) out.print(" ");
			out.print(ids.get(i) + 1);
		}
		out.printLine();
	}
}

class GeometryUtils {
	public static double epsilon = 1e-8;

}

class InputReader {

	private InputStream stream;
	private byte[] buf = new byte[1024];
	private int curChar;
	private int numChars;
	private SpaceCharFilter filter;

	public InputReader(InputStream stream) {
		this.stream = stream;
	}

	public 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++];
	}

	public int readInt() {
		int c = read();
		while (isSpaceChar(c))
			c = read();
		int sgn = 1;
		if (c == '-') {
			sgn = -1;
			c = read();
		}
		int res = 0;
		do {
			if (c < '0' || c > '9')
				throw new InputMismatchException();
			res *= 10;
			res += c - '0';
			c = read();
		} while (!isSpaceChar(c));
		return res * sgn;
	}

	public boolean isSpaceChar(int c) {
		if (filter != null)
			return filter.isSpaceChar(c);
		return isWhitespace(c);
	}

	public static boolean isWhitespace(int c) {
		return c == ' ' || c == '\n' || c == '\r' || c == '\t' || c == -1;
	}

	public interface SpaceCharFilter {
		public boolean isSpaceChar(int ch);
	}
}

class OutputWriter {
	private final PrintWriter writer;

	public OutputWriter(OutputStream outputStream) {
		writer = new PrintWriter(new BufferedWriter(new OutputStreamWriter(outputStream)));
	}

	public void print(Object...objects) {
		for (int i = 0; i < objects.length; i++) {
			if (i != 0)
				writer.print(' ');
			writer.print(objects[i]);
		}
	}

	public void printLine() {
		writer.println();
	}

	public void close() {
		writer.close();
	}

	public void print(int i) {
		writer.print(i);
	}

}
