/**
 * Created by Zlobober on 14.04.15.
 */
import java.io.*;
import java.util.*;

public class TaskC {
    private final InputReader reader;
    private final OutputWriter writer;

    public TaskC(InputReader reader, OutputWriter writer) {
        this.reader = reader;
        this.writer = writer;
    }

    public static void main(String[] args) {
        InputReader reader = new InputReader(System.in);
        OutputWriter writer = new OutputWriter(System.out);
        new TaskC(reader, writer).run();
        writer.writer.flush();
    }

    int[] X, Y;

    class Pair implements Comparable<Pair> {
        int x, y;
        Pair(int x, int y) {
            this.x = x;
            this.y = y;
        }
        @Override
        public int compareTo(Pair other) {
            if (this.x != other.x)
                return Integer.compare(this.x, other.x);
            return Integer.compare(this.y, other.y);
        }
    }

    List[] eq;
    public void run() {
        int n = reader.nextInt();
        X = new int[n];
        Y = new int[n];
        TreeSet<Pair> used = new TreeSet<Pair>();
        for (int i = 0; i < n; i++) {
            X[i] = reader.nextInt();
            Y[i] = reader.nextInt();
        }
        int apt = 0;
        Integer[] A = new Integer[n];
        for (int i = 0; i < n; i++) {
            if (used.contains(new Pair(X[i], Y[i])))
                continue;
            else {
                A[apt++] = i;
                used.add(new Pair(X[i], Y[i]));
            }
        }
        A = Arrays.copyOf(A, apt);
        int pos = 0;
        int neg = 0;
        for (int i = 1; i < A.length; i++) {
            if (Y[A[i]] > Y[A[pos]] || (Y[A[i]] == Y[A[pos]] && X[A[i]] > X[A[pos]]))
                pos = i;
            if (X[A[i]] > X[A[neg]] || (X[A[i]] == X[A[neg]] && Y[A[i]] > Y[A[neg]]))
                neg = i;
        }
        neg = A[neg];
        int t = A[0];
        A[0] = A[pos];
        A[pos] = t;
        pos = A[0];
        final Integer[] finalA = A;
        Arrays.sort(A, 1, A.length, new Comparator<Integer>() {
            @Override
            public int compare(Integer a, Integer b) {
                long v = vec(finalA[0], a, b);
                if (v != 0)
                    return Long.compare(v, 0);
                else {
                    int da = (X[a] - X[finalA[0]]) * (X[a] - X[finalA[0]]) + (Y[a] - Y[finalA[0]]) * (Y[a] - Y[finalA[0]]);
                    int db = (X[b] - X[finalA[0]]) * (X[b] - X[finalA[0]]) + (Y[b] - Y[finalA[0]]) * (Y[b] - Y[finalA[0]]);
                    return Long.compare(da, db);
                }
            }
        });
        int[] H = new int[A.length];
        int pt = 0;
        H[pt++] = A[0];
        if (pos != neg) {
            for (int i = 1; i < A.length; i++) {
                int p = A[i];
                while (true) {
                    if (pt < 2)
                        break;
                    int a = H[pt - 2];
                    int b = H[pt - 1];
                    long v = vec(a, b, p);
                    if (v > 0)
                        --pt;
                    else
                        break;
                }
                H[pt++] = p;
                if (p == neg)
                    break;
            }
        }
        Arrays.sort(H, 0, pt);
        used.clear();
        for (int i = 0; i < pt; i++)
            used.add(new Pair(X[H[i]], Y[H[i]]));
        for (int i = 0; i < n; i++)
            if (used.contains(new Pair(X[i], Y[i])))
                writer.printf("%d ", i + 1);

        writer.printf("\n");
    }

    long vec(int a, int b, int c) {
        return 1l * X[c] * Y[a] * (X[b] - X[a]) * (Y[c] - Y[b]) - 1l * X[a] * Y[c] * (Y[b] - Y[a]) * (X[c] - X[b]);
    }



    static class InputReader {
        public BufferedReader reader;
        public StringTokenizer tokenizer;

        public InputReader(InputStream stream) {
            reader = new BufferedReader(new InputStreamReader(stream), 32768);
            tokenizer = null;
        }

        public String next() {
            while (tokenizer == null || !tokenizer.hasMoreTokens()) {
                try {
                    tokenizer = new StringTokenizer(reader.readLine());
                } catch (IOException e) {
                    throw new RuntimeException(e);
                }
            }
            return tokenizer.nextToken();
        }

        public int nextInt() {
            return Integer.parseInt(next());
        }

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

        public long nextLong() {
            return Long.parseLong(next());
        }
    }

    static class OutputWriter {
        public PrintWriter writer;

        OutputWriter(OutputStream stream) {
            writer = new PrintWriter(stream);
        }

        public void printf(String format, Object... args) {
            writer.print(String.format(Locale.ENGLISH, format, args));
        }
    }
}