#include <bits/stdc++.h>
using namespace std;

#define pb push_back
#define rs resize
#define mp make_pair
#define pi 3.1415926535897932384626433832795
#define sz(a) (int)(a).size()
#define Sort(a) sort((a).begin(), (a).end())
#define Reverse(a) reverse((a).begin(), (a).end())
#define sf scanf
#define pf printf
#define ms(a, x) memset((a), (x), sizeof(a))
typedef vector <int> vi;
typedef vector <vi> vvi;
typedef vector <vvi> vvvi;
typedef vector <vvvi> vvvvi;
typedef vector <bool> vb;
typedef vector <vb> vvb;
typedef vector <vvb> vvvb;
typedef vector <vvvb> vvvvb;
typedef long long ll;
typedef vector <ll> vl;
typedef vector <vl> vvl;
typedef vector <vvl> vvvl;
typedef vector <vvvl> vvvvl;
typedef pair <int, int> ii;
typedef vector <ii> vii;
typedef vector <vii> vvii;
typedef pair <int, ll> il;
typedef vector <il> vil;
typedef vector <vil> vvil;
typedef pair <ll, int> li;
typedef vector <li> vli;
typedef vector <vli> vvli;
typedef set <int> si;
typedef set <li> sli;
typedef set <il> sil;
typedef vector <string> vs;
typedef vector <vs> vvs;
typedef vector <vvs> vvvs;
typedef map <char, int> mci;
typedef pair <ll, ll> pll;
typedef vector <pll> vll;

int gcd(int a, int b) {
    return b != 0 ? gcd(b, a % b) : a;
}

struct Rational {
    int a, b;

    Rational() {}
    Rational(ll a, ll b = 1) : a(a), b(b) {
        ll d = gcd(abs(a), abs(b));
        this->a /= d;
        this->b /= d;
        if (this->b < 0) {
            this->a *= -1;
            this->b *= -1;
        }
    }

    Rational operator +(Rational other) {
        return Rational(a * other.b + b * other.a, b * other.b);
    }

    Rational operator -(Rational other) {
        return Rational(a * other.b - b * other.a, b * other.b);
    }

    Rational operator *(Rational other) {
        return Rational(a * other.a, b * other.b);
    }

    Rational operator /(Rational other) {
        return Rational(a * other.b, b * other.a);
    }

    bool operator <(Rational other) {
        return a * other.b < b * other.a;
    }

    bool operator >(Rational other) {
        return a * other.b > b * other.a;
    }

    bool operator ==(Rational other) {
        return a * other.b == b * other.a;
    }
};

ostream& operator <<(ostream& out, Rational a) {
    out << a.a << '/' << a.b;
    return out;
}

struct point {
    Rational x, y;

    point() {}
    point(Rational x, Rational y) : x(x), y(y) {}

    point operator -(point b) {
        return point(x - b.x, y - b.y);
    }

    point operator +(point b) {
        return point(x + b.x, y + b.y);
    }

};

bool operator <(point a, point b) {
    return a.x * b.y - a.y * b.x > 0 || a.x * b.y - a.y * b.x == 0 && a.x * a.x + a.y * a.y < b.x * b.x + b.y * b.y;
}

bool operator ==(point a, point b) {
    return a.x == b.x && a.y == b.y;
}

bool operator <=(point a, point b) {
    return a < b || b == a;
}

ostream& operator <<(ostream& out, point a) {
    out << a.x << ' ' << a.y << endl;
    return out;
}

void eprint(vector <pair <point, int> > a) {
    cerr << endl;
    for (auto x: a) {
        cerr << x.first;
    }
    cerr << endl;
}

int main() {
    //freopen("input.txt", "r", stdin);
    //freopen("output.txt", "w", stdout);
    ios_base::sync_with_stdio(0);
    cin.tie(0);
    int n;
    cin >> n;
    vector <pair <point, int> > a(n);
    for (int i = 0; i < n; ++i) {
        int s, r;
        cin >> s >> r;
        a[i].first.x = Rational(1, s);
        a[i].first.y = Rational(1, r);
        a[i].second = i + 1;
    }
    int best = 0;
    for (int i = 1; i < n; ++i) {
        if (a[i].first.x < a[best].first.x || a[i].first.x == a[best].first.x && a[i].first.y < a[best].first.y) {
            best = i;
        }
    }
    Rational x = a[best].first.x, y = a[best].first.y;
    //cerr << x << ' ' << y << endl;
    for (int i = 0; i < n; ++i) {
        a[i].first = a[i].first - point(x, y);
    }
    sort(a.begin(), a.end());
    //eprint(a);
    vector <pair <point, int> > ans;
    ans.pb(a[0]);
    ans.pb(a[1]);
    for (int i = 2; i < sz(a); ++i) {
        while (sz(ans) > 1 && (a[i].first - ans.back().first) <= (ans.back().first - ans[sz(ans) - 2].first)) {
            ans.pop_back();
        }
        ans.push_back(a[i]);
    }
    //eprint(ans);
    best = 0;
    for (int i = 1; i < sz(ans); ++i) {
        if (ans[i].first.y < ans[best].first.y || ans[i].first.y == ans[best].first.y && ans[i].first.x < ans[best].first.x)
            best = i;
    }
    vector <int> result;
    for (int i = 0; i <= best; ++i) {
        result.pb(ans[i].second);
    }
    Sort(result);
    for (int i = 0; i < sz(result); ++i) {
        cout << result[i] << ' ';
    }
    return 0;
}


#include <bits/stdc++.h>
using namespace std;

#define pb push_back
#define rs resize
#define mp make_pair
#define pi 3.1415926535897932384626433832795
#define sz(a) (int)(a).size()
#define Sort(a) sort((a).begin(), (a).end())
#define Reverse(a) reverse((a).begin(), (a).end())
#define sf scanf
#define pf printf
#define ms(a, x) memset((a), (x), sizeof(a))
typedef vector <int> vi;
typedef vector <vi> vvi;
typedef vector <vvi> vvvi;
typedef vector <vvvi> vvvvi;
typedef vector <bool> vb;
typedef vector <vb> vvb;
typedef vector <vvb> vvvb;
typedef vector <vvvb> vvvvb;
typedef long long ll;
typedef vector <ll> vl;
typedef vector <vl> vvl;
typedef vector <vvl> vvvl;
typedef vector <vvvl> vvvvl;
typedef pair <int, int> ii;
typedef vector <ii> vii;
typedef vector <vii> vvii;
typedef pair <int, ll> il;
typedef vector <il> vil;
typedef vector <vil> vvil;
typedef pair <ll, int> li;
typedef vector <li> vli;
typedef vector <vli> vvli;
typedef set <int> si;
typedef set <li> sli;
typedef set <il> sil;
typedef vector <string> vs;
typedef vector <vs> vvs;
typedef vector <vvs> vvvs;
typedef map <char, int> mci;
typedef pair <ll, ll> pll;
typedef vector <pll> vll;

struct point {
    ll s, r, n;
};

bool check(point a, point b, point c) {
    if ((b.s - a.s) * (b.r - c.r) * a.r * c.s != (b.r - a.r) * (b.s - c.s) * a.s * c.r)
        return (b.s - a.s) * (b.r - c.r) * a.r * c.s > (b.r - a.r) * (b.s - c.s) * a.s * c.r;
    /*cerr << endl;
    cerr << a.s << ' ' << a.r << endl;
    cerr << b.s << ' ' << b.r << endl;
    cerr << c.s << ' ' << c.r << endl;
    cerr << endl;*/
    if (b.s != a.s || b.s != c.s) {
        return abs(b.s - a.s) * c.s < abs(b.s - c.s) * a.s;
    }
    return abs(b.r - a.r) * c.r < abs(b.r - c.r) * a.r;
}

point p;

bool check(point a, point b) {
    return check(a, p, b);
}

int main() {
    //freopen("input.txt", "r", stdin);
    //freopen("output.txt", "w", stdout);
    ios_base::sync_with_stdio(0);
    cin.tie(0);
    int n;
    cin >> n;
    if (n == 1) {
        cout << 1;
        return 0;
    }
    vector <point> a(n);
    for (int i = 0; i < n; ++i) {
        cin >> a[i].s >> a[i].r;
        a[i].n = i + 1;
    }
    int left = 0;
    for (int i = 1; i < n; ++i) {
        if (a[i].s > a[left].s || a[i].s == a[left].s && a[i].r > a[left].r) {
            left = i;
        }
    }
    swap(a[left], a[0]);
    p = a[0];
    sort(a.begin() + 1, a.end(), [](point a, point b) {
        return check(a, p, b);
    });
    vector <point> ans;
    ans.pb(a[0]);
    ans.pb(a[1]);
    for (int i = 2; i < n; ++i) {
        while (sz(ans) > 1 && check(a[i], ans[ans.size() - 2], ans.back())) {
            ans.pop_back();
        }
        ans.push_back(a[i]);
    }
    left = 0;
    for (int i = 0; i < sz(ans); ++i) {
        if (ans[i].r > ans[left].r || ans[i].r == ans[left].r && ans[i].s >= ans[left].s) {
            left = i;
        }
    }
    vi result;
    for (int i = 0; i <= left; ++i) {
        result.push_back(ans[i].n);
    }
    Sort(result);
    for (int i = 0; i < sz(result); ++i) {
        cout << result[i] << ' ';
    }
}


#include <bits/stdc++.h>
using namespace std;

#define pb push_back
#define rs resize
#define mp make_pair
#define pi 3.1415926535897932384626433832795
#define sz(a) (int)(a).size()
#define Sort(a) sort((a).begin(), (a).end())
#define Reverse(a) reverse((a).begin(), (a).end())
#define sf scanf
#define pf printf
#define ms(a, x) memset((a), (x), sizeof(a))
typedef vector <int> vi;
typedef vector <vi> vvi;
typedef vector <vvi> vvvi;
typedef vector <vvvi> vvvvi;
typedef vector <bool> vb;
typedef vector <vb> vvb;
typedef vector <vvb> vvvb;
typedef vector <vvvb> vvvvb;
typedef long long ll;
typedef vector <ll> vl;
typedef vector <vl> vvl;
typedef vector <vvl> vvvl;
typedef vector <vvvl> vvvvl;
typedef pair <int, int> ii;
typedef vector <ii> vii;
typedef vector <vii> vvii;
typedef pair <int, ll> il;
typedef vector <il> vil;
typedef vector <vil> vvil;
typedef pair <ll, int> li;
typedef vector <li> vli;
typedef vector <vli> vvli;
typedef set <int> si;
typedef set <li> sli;
typedef set <il> sil;
typedef vector <string> vs;
typedef vector <vs> vvs;
typedef vector <vvs> vvvs;
typedef map <char, int> mci;
typedef pair <ll, ll> pll;
typedef vector <pll> vll;
typedef long double ld;

const ld eps = 1e-22;

struct point {
    ld x, y;

    point() {}
    point(ld x, ld y) : x(x), y(y) {}
};

ld operator &(point a, point b) {
    return a.x * b.y - a.y * b.x;
}

point operator +(point a, point b) {
    return point(a.x - b.x, a.y - b.y);
}

point operator -(point a, point b) {
    return point(a.x - b.x, a.y - b.y);
}

ld len(point a) {
    return a.x * a.x + a.y * a.y;
}

bool operator ==(point a, point b) {
    return fabs(a.x - b.x) < eps && fabs(a.y - b.y) < eps;
}

void eprint(vector <pair <point, int> > a) {
    for (auto x: a) {
        cerr << x.second << ' ';
    }
    cerr << endl;
}

int main() {
    //freopen("input.txt", "r", stdin);
    //freopen("output.txt", "w", stdout);
    int n;
    cin >> n;
    if (n == 1) {
        cout << 1 << endl;
        return 0;
    }
    vector <pair <point, int> > a(n);
    for (int i = 0; i < n; ++i) {
        int s, r;
        cin >> s >> r;
        a[i] = mp(point(1.0 / s, 1.0 / r), i + 1);
    }
    int best = 0;
    for (int i = 1; i < n; ++i) {
        if (a[i].first.x < a[best].first.x || fabs(a[i].first.x - a[best].first.x) < eps && a[i].first.y < a[best].first.y) {
            best = i;
        }
    }
    //cerr << best + 1 << endl;
    swap(a[0], a[best]);
    for (int i = 1; i < n; ++i) {
        a[i].first.x -= a[0].first.x;
        a[i].first.y -= a[0].first.y;
    }
    a[0].first = point(0.0, 0.0);
    sort(a.begin() + 1, a.end(), [](pair <point, int> A, pair <point, int> B) {
        auto a = A.first, b = B.first;
        ld mul = a & b;
        if (fabs(mul) < eps) {
            return len(a) < len(b);
        }
        return mul > 0;
    });
    //eprint(a);
    vector <pair <point, int> > c;
    c.pb(a[0]);
    for (int i = 1; i < n; ++i) {
        while (sz(c) > 1 && ((a[i].first - c.back().first) & (c.back().first - c[sz(c) - 2].first)) > eps) {
            c.pop_back();
        }
        c.push_back(a[i]);
    }
    //eprint(c);
    best = 0;
    for (int i = 0; i < sz(c); ++i) {
        if (c[i].first.y < c[best].first.y || fabs(c[i].first.y - c[best].first.y) < eps && c[i].first.x < c[best].first.x || c[i].first == c[best].first) {
            best = i;
        }
    }
    vi result;
    for (int i = 0; i <= best; ++i) {
        result.pb(c[i].second);
    }
    Sort(result);
    for (int x: result) {
        cout << x << ' ';
    }
    cout << endl;
}


#include <bits/stdc++.h>
using namespace std;

#define pb push_back
#define rs resize
#define mp make_pair
#define pi 3.1415926535897932384626433832795
#define sz(a) (int)(a).size()
#define Sort(a) sort((a).begin(), (a).end())
#define Reverse(a) reverse((a).begin(), (a).end())
#define sf scanf
#define pf printf
#define ms(a, x) memset((a), (x), sizeof(a))
typedef vector <int> vi;
typedef vector <vi> vvi;
typedef vector <vvi> vvvi;
typedef vector <vvvi> vvvvi;
typedef vector <bool> vb;
typedef vector <vb> vvb;
typedef vector <vvb> vvvb;
typedef vector <vvvb> vvvvb;
typedef long long ll;
typedef vector <ll> vl;
typedef vector <vl> vvl;
typedef vector <vvl> vvvl;
typedef vector <vvvl> vvvvl;
typedef pair <int, int> ii;
typedef vector <ii> vii;
typedef vector <vii> vvii;
typedef pair <int, ll> il;
typedef vector <il> vil;
typedef vector <vil> vvil;
typedef pair <ll, int> li;
typedef vector <li> vli;
typedef vector <vli> vvli;
typedef set <int> si;
typedef set <li> sli;
typedef set <il> sil;
typedef vector <string> vs;
typedef vector <vs> vvs;
typedef vector <vvs> vvvs;
typedef map <char, int> mci;
typedef pair <ll, ll> pll;
typedef vector <pll> vll;

struct point {
    ll s, r, n;
};

bool check(point a, point b, point c) {
    if ((b.s - a.s) * (b.r - c.r) * a.r * c.s != (b.r - a.r) * (b.s - c.s) * a.s * c.r)
        return (b.s - a.s) * (b.r - c.r) * a.r * c.s > (b.r - a.r) * (b.s - c.s) * a.s * c.r;
    if (b.s != 0) {
        return abs(b.s - a.s) * c.s < abs(b.s - c.s) * a.s;
    }
    return abs(b.r - a.r) * c.r < abs(b.r - c.r) * a.r;
}

point p;

bool check(point a, point b) {
    return check(a, p, b);
}

int main() {
    //freopen("input.txt", "r", stdin);
    //freopen("output.txt", "w", stdout);
    ios_base::sync_with_stdio(0);
    cin.tie(0);
    int n;
    cin >> n;
    if (n == 1) {
        cout << 1;
        return 0;
    }
    vector <point> a(n);
    for (int i = 0; i < n; ++i) {
        cin >> a[i].s >> a[i].r;
        a[i].n = i + 1;
    }
    int left = 0;
    for (int i = 1; i < n; ++i) {
        if (a[i].s > a[left].s || a[i].s == a[left].s && a[i].r > a[left].r) {
            left = i;
        }
    }
    swap(a[left], a[0]);
    p = a[0];
    sort(a.begin() + 1, a.end(), [](point a, point b) {
        return check(a, p, b);
    });
    vector <point> ans;
    ans.pb(a[0]);
    ans.pb(a[1]);
    for (int i = 2; i < n; ++i) {
        while (sz(ans) > 1 && check(a[i], ans[ans.size() - 2], ans.back())) {
            ans.pop_back();
        }
        ans.push_back(a[i]);
    }
    left = 0;
    for (int i = 0; i < sz(ans); ++i) {
        if (ans[i].r > ans[left].r || ans[i].r == ans[left].r && ans[i].s >= ans[left].s) {
            left = i;
        }
    }
    vi result;
    for (int i = 0; i <= left; ++i) {
        result.push_back(ans[i].n);
    }
    Sort(result);
    for (int i = 0; i < sz(result); ++i) {
        cout << result[i] << ' ';
    }
}


#include <iostream>
#include <vector>
#include <algorithm>
#include <set>
#include <map>
#include <string>
using namespace std;

#define pb push_back
#define rs resize
#define mp make_pair
#define pi 3.1415926535897932384626433832795
#define sz(a) (int)(a).size()
#define Sort(a) sort((a).begin(), (a).end())
#define Reverse(a) reverse((a).begin(), (a).end())
#define sf scanf
#define pf printf
#define ms(a, x) memset((a), (x), sizeof(a))
typedef vector <int> vi;
typedef vector <vi> vvi;
typedef vector <vvi> vvvi;
typedef vector <vvvi> vvvvi;
typedef vector <bool> vb;
typedef vector <vb> vvb;
typedef vector <vvb> vvvb;
typedef vector <vvvb> vvvvb;
typedef long long ll;
typedef vector <ll> vl;
typedef vector <vl> vvl;
typedef vector <vvl> vvvl;
typedef vector <vvvl> vvvvl;
typedef pair <int, int> ii;
typedef vector <ii> vii;
typedef vector <vii> vvii;
typedef pair <int, ll> il;
typedef vector <il> vil;
typedef vector <vil> vvil;
typedef pair <ll, int> li;
typedef vector <li> vli;
typedef vector <vli> vvli;
typedef set <int> si;
typedef set <li> sli;
typedef set <il> sil;
typedef vector <string> vs;
typedef vector <vs> vvs;
typedef vector <vvs> vvvs;
typedef map <char, int> mci;
typedef pair <ll, ll> pll;
typedef vector <pll> vll;
typedef long double ld;

const ld eps = 1e-22;

struct point {
    ld x, y;

    point() {}
    point(ld x, ld y) : x(x), y(y) {}
};

ld operator &(point a, point b) {
    return a.x * b.y - a.y * b.x;
}

point operator +(point a, point b) {
    return point(a.x - b.x, a.y - b.y);
}

point operator -(point a, point b) {
    return point(a.x - b.x, a.y - b.y);
}

ld len(point a) {
    return a.x * a.x + a.y * a.y;
}

bool operator ==(point a, point b) {
    return fabs(a.x - b.x) < eps && fabs(a.y - b.y) < eps;
}

void eprint(vector <pair <point, int> > a) {
    for (int i = 0; i < sz(a); ++i) {
        cerr << a[i].second << ' ';
    }
    cerr << endl;
}

int main() {
    //freopen("input.txt", "r", stdin);
    //freopen("output.txt", "w", stdout);
    int n;
    cin >> n;
    if (n == 1) {
        cout << 1 << endl;
        return 0;
    }
    vector <pair <point, int> > a(n);
    for (int i = 0; i < n; ++i) {
        int s, r;
        cin >> s >> r;
        a[i] = mp(point(1.0 / s, 1.0 / r), i + 1);
    }
    int best = 0;
    for (int i = 1; i < n; ++i) {
        if (a[i].first.x < a[best].first.x || fabs(a[i].first.x - a[best].first.x) < eps && a[i].first.y < a[best].first.y) {
            best = i;
        }
    }
    //cerr << best + 1 << endl;
    swap(a[0], a[best]);
    for (int i = 1; i < n; ++i) {
        a[i].first.x -= a[0].first.x;
        a[i].first.y -= a[0].first.y;
    }
    a[0].first = point(0.0, 0.0);
    sort(a.begin() + 1, a.end(), [](pair <point, int> A, pair <point, int> B) {
        auto a = A.first, b = B.first;
        ld mul = a & b;
        if (fabs(mul) < eps) {
            return len(a) < len(b);
        }
        return mul > 0;
    });
    vector <pair <point, vector <int> > > c;
    c.pb({a[0].first, vi(1, a[0].second)});
    cerr.precision(30);
    cerr << fixed;
    for (int i = 1; i < n; ++i) {
        while (sz(c) > 1) {
            //cerr << a[i].second << ' ' << c.back().second << ' ' << c[sz(c) - 2].second << endl;
            //cerr << ((a[i].first - c.back().first) & (c.back().first - c[sz(c) - 2].first)) << endl << endl;
            if (((a[i].first - c.back().first) & (c.back().first - c[sz(c) - 2].first)) < eps) {
                break;
            }
            c.pop_back();
        }
        if (a[i].first == c.back().first) {
            c.back().second.pb(a[i].second);
        } else {
            c.push_back({a[i].first, vi(1, a[i].second)});
        }
    }
    best = 0;
    for (int i = 0; i < sz(c); ++i) {
        if (c[i].first.y < c[best].first.y || fabs(c[i].first.y - c[best].first.y) < eps && c[i].first.x < c[best].first.x || c[i].first == c[best].first) {
            best = i;
        }
    }
    vi result;
    for (int i = 0; i <= best; ++i) {
        for (auto x: c[i].second) {
            result.pb(x);
        }
    }
    Sort(result);
    for (int i = 0; i < sz(result); ++i) {
        cout << result[i] << ' ';
    }
    cout << endl;
}


#include <bits/stdc++.h>
using namespace std;

#define pb push_back
#define rs resize
#define mp make_pair
#define pi 3.1415926535897932384626433832795
#define sz(a) (int)(a).size()
#define Sort(a) sort((a).begin(), (a).end())
#define Reverse(a) reverse((a).begin(), (a).end())
#define sf scanf
#define pf printf
#define ms(a, x) memset((a), (x), sizeof(a))
typedef vector <int> vi;
typedef vector <vi> vvi;
typedef vector <vvi> vvvi;
typedef vector <vvvi> vvvvi;
typedef vector <bool> vb;
typedef vector <vb> vvb;
typedef vector <vvb> vvvb;
typedef vector <vvvb> vvvvb;
typedef long long ll;
typedef vector <ll> vl;
typedef vector <vl> vvl;
typedef vector <vvl> vvvl;
typedef vector <vvvl> vvvvl;
typedef pair <int, int> ii;
typedef vector <ii> vii;
typedef vector <vii> vvii;
typedef pair <int, ll> il;
typedef vector <il> vil;
typedef vector <vil> vvil;
typedef pair <ll, int> li;
typedef vector <li> vli;
typedef vector <vli> vvli;
typedef set <int> si;
typedef set <li> sli;
typedef set <il> sil;
typedef vector <string> vs;
typedef vector <vs> vvs;
typedef vector <vvs> vvvs;
typedef map <char, int> mci;
typedef pair <ll, ll> pll;
typedef vector <pll> vll;

ll gcd(ll a, ll b) {
    return b != 0 ? gcd(b, a % b) : a;
}

struct Rational {
    ll a, b;

    Rational() {}
    Rational(ll a, ll b = 1) : a(a), b(b) {
        ll d = gcd(abs(a), abs(b));
        this->a /= d;
        this->b /= d;
        if (this->b < 0) {
            this->a *= -1;
            this->b *= -1;
        }
    }

    Rational operator +(Rational other) {
        return Rational(a * other.b + b * other.a, b * other.b);
    }

    Rational operator -(Rational other) {
        return Rational(a * other.b - b * other.a, b * other.b);
    }

    Rational operator *(Rational other) {
        return Rational(a * other.a, b * other.b);
    }

    Rational operator /(Rational other) {
        return Rational(a * other.b, b * other.a);
    }

    bool operator <(Rational other) {
        return a * other.b < b * other.a;
    }

    bool operator >(Rational other) {
        return a * other.b > b * other.a;
    }

    bool operator ==(Rational other) {
        return a * other.b == b * other.a;
    }
};

ostream& operator <<(ostream& out, Rational a) {
    out << a.a << '/' << a.b;
    return out;
}

struct point {
    Rational x, y;

    point() {}
    point(Rational x, Rational y) : x(x), y(y) {}

    point operator -(point b) {
        return point(x - b.x, y - b.y);
    }

    point operator +(point b) {
        return point(x + b.x, y + b.y);
    }

};

bool operator <(point a, point b) {
    return a.x * b.y - a.y * b.x > 0 || a.x * b.y - a.y * b.x == 0 && a.x * a.x + a.y * a.y < b.x * b.x + b.y * b.y;
}

bool operator ==(point a, point b) {
    return a.x == b.x && a.y == b.y;
}

bool operator <=(point a, point b) {
    return a < b || b == a;
}

ostream& operator <<(ostream& out, point a) {
    out << a.x << ' ' << a.y << endl;
    return out;
}

void eprint(vector <pair <point, int> > a) {
    cerr << endl;
    for (auto x: a) {
        cerr << x.first;
    }
    cerr << endl;
}

int main() {
    //freopen("input.txt", "r", stdin);
    //freopen("output.txt", "w", stdout);
    ios_base::sync_with_stdio(0);
    cin.tie(0);
    int n;
    cin >> n;
    vector <pair <point, int> > a(n);
    for (int i = 0; i < n; ++i) {
        int s, r;
        cin >> s >> r;
        a[i].first.x = Rational(1, s);
        a[i].first.y = Rational(1, r);
        a[i].second = i + 1;
    }
    int best = 0;
    for (int i = 1; i < n; ++i) {
        if (a[i].first.x < a[best].first.x || a[i].first.x == a[best].first.x && a[i].first.y < a[best].first.y) {
            best = i;
        }
    }
    Rational x = a[best].first.x, y = a[best].first.y;
    //cerr << x << ' ' << y << endl;
    for (int i = 0; i < n; ++i) {
        a[i].first = a[i].first - point(x, y);
    }
    sort(a.begin(), a.end());
    //eprint(a);
    vector <pair <point, int> > ans;
    ans.pb(a[0]);
    ans.pb(a[1]);
    for (int i = 2; i < sz(a); ++i) {
        while (sz(ans) > 1 && (a[i].first - ans.back().first) <= (ans.back().first - ans[sz(ans) - 2].first)) {
            ans.pop_back();
        }
        ans.push_back(a[i]);
    }
    //eprint(ans);
    best = 0;
    for (int i = 1; i < sz(ans); ++i) {
        if (ans[i].first.y < ans[best].first.y || ans[i].first.y == ans[best].first.y && ans[i].first.x < ans[best].first.x)
            best = i;
    }
    vector <int> result;
    for (int i = 0; i <= best; ++i) {
        result.pb(ans[i].second);
    }
    Sort(result);
    for (int i = 0; i < sz(result); ++i) {
        cout << result[i] << ' ';
    }
    return 0;
}


#include <bits/stdc++.h>
using namespace std;

#define pb push_back
#define rs resize
#define mp make_pair
#define pi 3.1415926535897932384626433832795
#define sz(a) (int)(a).size()
#define Sort(a) sort((a).begin(), (a).end())
#define Reverse(a) reverse((a).begin(), (a).end())
#define sf scanf
#define pf printf
#define ms(a, x) memset((a), (x), sizeof(a))
typedef vector <int> vi;
typedef vector <vi> vvi;
typedef vector <vvi> vvvi;
typedef vector <vvvi> vvvvi;
typedef vector <bool> vb;
typedef vector <vb> vvb;
typedef vector <vvb> vvvb;
typedef vector <vvvb> vvvvb;
typedef long long ll;
typedef vector <ll> vl;
typedef vector <vl> vvl;
typedef vector <vvl> vvvl;
typedef vector <vvvl> vvvvl;
typedef pair <int, int> ii;
typedef vector <ii> vii;
typedef vector <vii> vvii;
typedef pair <int, ll> il;
typedef vector <il> vil;
typedef vector <vil> vvil;
typedef pair <ll, int> li;
typedef vector <li> vli;
typedef vector <vli> vvli;
typedef set <int> si;
typedef set <li> sli;
typedef set <il> sil;
typedef vector <string> vs;
typedef vector <vs> vvs;
typedef vector <vvs> vvvs;
typedef map <char, int> mci;
typedef pair <ll, ll> pll;
typedef vector <pll> vll;

ll gcd(ll a, ll b) {
    return b != 0 ? gcd(b, a % b) : a;
}

struct Rational {
    ll a, b;

    Rational() {}
    Rational(ll a, ll b = 1) : a(a), b(b) {
        ll d = gcd(abs(a), abs(b));
        this->a /= d;
        this->b /= d;
        if (this->b < 0) {
            this->a *= -1;
            this->b *= -1;
        }
    }

    Rational operator +(Rational other) {
        return Rational(a * other.b + b * other.a, b * other.b);
    }

    Rational operator -(Rational other) {
        return Rational(a * other.b - b * other.a, b * other.b);
    }

    Rational operator *(Rational other) {
        return Rational(a * other.a, b * other.b);
    }

    Rational operator /(Rational other) {
        return Rational(a * other.b, b * other.a);
    }

    bool operator <(Rational other) {
        return a * other.b < b * other.a;
    }

    bool operator >(Rational other) {
        return a * other.b > b * other.a;
    }

    bool operator ==(Rational other) {
        return a * other.b == b * other.a;
    }
};

ostream& operator <<(ostream& out, Rational a) {
    out << a.a << '/' << a.b;
    return out;
}

struct point {
    Rational x, y;

    point() {}
    point(Rational x, Rational y) : x(x), y(y) {}

    point operator -(point b) {
        return point(x - b.x, y - b.y);
    }

    point operator +(point b) {
        return point(x + b.x, y + b.y);
    }

};

bool operator <(point a, point b) {
    return a.x * b.y - a.y * b.x > 0 || a.x * b.y - a.y * b.x == 0 && a.x * a.x + a.y * a.y < b.x * b.x + b.y * b.y;
}

bool operator ==(point a, point b) {
    return a.x == b.x && a.y == b.y;
}

bool operator <=(point a, point b) {
    return a < b || b == a;
}

ostream& operator <<(ostream& out, point a) {
    out << a.x << ' ' << a.y << endl;
    return out;
}

void eprint(vector <pair <point, int> > a) {
    cerr << endl;
    for (auto x: a) {
        cerr << x.first;
    }
    cerr << endl;
}

int main() {
    //freopen("input.txt", "r", stdin);
    //freopen("output.txt", "w", stdout);
    int n;
    cin >> n;
    vector <pair <point, int> > a(n);
    for (int i = 0; i < n; ++i) {
        int s, r;
        cin >> s >> r;
        a[i].first.x = Rational(1, s);
        a[i].first.y = Rational(1, r);
        a[i].second = i + 1;
    }
    int best = 0;
    for (int i = 1; i < n; ++i) {
        if (a[i].first.x < a[best].first.x || a[i].first.x == a[best].first.x && a[i].first.y < a[best].first.y) {
            best = i;
        }
    }
    Rational x = a[best].first.x, y = a[best].first.y;
    //cerr << x << ' ' << y << endl;
    for (int i = 0; i < n; ++i) {
        a[i].first = a[i].first - point(x, y);
    }
    sort(a.begin(), a.end());
    //eprint(a);
    vector <pair <point, int> > ans;
    ans.pb(a[0]);
    ans.pb(a[1]);
    for (int i = 2; i < sz(a); ++i) {
        while (sz(ans) > 1 && (a[i].first - ans.back().first) <= (ans.back().first - ans[sz(ans) - 2].first)) {
            ans.pop_back();
        }
        ans.push_back(a[i]);
    }
    //eprint(ans);
    best = 0;
    for (int i = 1; i < sz(ans); ++i) {
        if (ans[i].first.y < ans[best].first.y || ans[i].first.y == ans[best].first.y && ans[i].first.x < ans[best].first.x)
            best = i;
    }
    vector <int> result;
    for (int i = 0; i <= best; ++i) {
        result.pb(ans[i].second);
    }
    Sort(result);
    for (int i = 0; i < sz(result); ++i) {
        cout << result[i] << ' ';
    }
    return 0;
}


#include <bits/stdc++.h>
using namespace std;

#define pb push_back
#define rs resize
#define mp make_pair
#define pi 3.1415926535897932384626433832795
#define sz(a) (int)(a).size()
#define Sort(a) sort((a).begin(), (a).end())
#define Reverse(a) reverse((a).begin(), (a).end())
#define sf scanf
#define pf printf
#define ms(a, x) memset((a), (x), sizeof(a))
typedef vector <int> vi;
typedef vector <vi> vvi;
typedef vector <vvi> vvvi;
typedef vector <vvvi> vvvvi;
typedef vector <bool> vb;
typedef vector <vb> vvb;
typedef vector <vvb> vvvb;
typedef vector <vvvb> vvvvb;
typedef long long ll;
typedef vector <ll> vl;
typedef vector <vl> vvl;
typedef vector <vvl> vvvl;
typedef vector <vvvl> vvvvl;
typedef pair <int, int> ii;
typedef vector <ii> vii;
typedef vector <vii> vvii;
typedef pair <int, ll> il;
typedef vector <il> vil;
typedef vector <vil> vvil;
typedef pair <ll, int> li;
typedef vector <li> vli;
typedef vector <vli> vvli;
typedef set <int> si;
typedef set <li> sli;
typedef set <il> sil;
typedef vector <string> vs;
typedef vector <vs> vvs;
typedef vector <vvs> vvvs;
typedef map <char, int> mci;
typedef pair <ll, ll> pll;
typedef vector <pll> vll;

int gcd(int a, int b) {
    return b != 0 ? gcd(b, a % b) : a;
}

struct Rational {
    int a, b;

    Rational() {}
    Rational(ll a, ll b = 1) : a(a), b(b) {}

    Rational operator +(Rational other) {
        return Rational(a * other.b + b * other.a, b * other.b);
    }

    Rational operator -(Rational other) {
        return Rational(a * other.b - b * other.a, b * other.b);
    }

    Rational operator *(Rational other) {
        return Rational(a * other.a, b * other.b);
    }

    Rational operator /(Rational other) {
        return Rational(a * other.b, b * other.a);
    }

    bool operator <(Rational other) {
        return a * other.b < b * other.a;
    }

    bool operator >(Rational other) {
        return a * other.b > b * other.a;
    }

    bool operator ==(Rational other) {
        return a * other.b == b * other.a;
    }
};

ostream& operator <<(ostream& out, Rational a) {
    out << a.a << '/' << a.b;
    return out;
}

struct point {
    Rational x, y;

    point() {}
    point(Rational x, Rational y) : x(x), y(y) {}

    point operator -(point b) {
        return point(x - b.x, y - b.y);
    }

    point operator +(point b) {
        return point(x + b.x, y + b.y);
    }

};

bool operator <(point a, point b) {
    return a.x * b.y - a.y * b.x > 0 || a.x * b.y - a.y * b.x == 0 && a.x * a.x + a.y * a.y < b.x * b.x + b.y * b.y;
}

bool operator ==(point a, point b) {
    return a.x == b.x && a.y == b.y;
}

bool operator <=(point a, point b) {
    return a < b || b == a;
}

ostream& operator <<(ostream& out, point a) {
    out << a.x << ' ' << a.y << endl;
    return out;
}

void eprint(vector <pair <point, int> > a) {
    cerr << endl;
    for (auto x: a) {
        cerr << x.first;
    }
    cerr << endl;
}

int main() {
    //freopen("input.txt", "r", stdin);
    //freopen("output.txt", "w", stdout);
    int n;
    sf("%d", &n);
    vector <pair <point, int> > a(n);
    for (int i = 0; i < n; ++i) {
        int s, r;
        sf("%d%d", &s, &r);
        a[i].first.x = Rational(1, s);
        a[i].first.y = Rational(1, r);
        a[i].second = i + 1;
    }
    int best = 0;
    for (int i = 1; i < n; ++i) {
        if (a[i].first.x < a[best].first.x || a[i].first.x == a[best].first.x && a[i].first.y < a[best].first.y) {
            best = i;
        }
    }
    Rational x = a[best].first.x, y = a[best].first.y;
    //cerr << x << ' ' << y << endl;
    for (int i = 0; i < n; ++i) {
        a[i].first = a[i].first - point(x, y);
    }
    sort(a.begin(), a.end());
    //eprint(a);
    vector <pair <point, int> > ans;
    ans.pb(a[0]);
    ans.pb(a[1]);
    for (int i = 2; i < sz(a); ++i) {
        while (sz(ans) > 1 && (a[i].first - ans.back().first) <= (ans.back().first - ans[sz(ans) - 2].first)) {
            ans.pop_back();
        }
        ans.push_back(a[i]);
    }
    //eprint(ans);
    best = 0;
    for (int i = 1; i < sz(ans); ++i) {
        if (ans[i].first.y < ans[best].first.y || ans[i].first.y == ans[best].first.y && ans[i].first.x < ans[best].first.x)
            best = i;
    }
    vector <int> result;
    for (int i = 0; i <= best; ++i) {
        result.pb(ans[i].second);
    }
    Sort(result);
    for (int i = 0; i < sz(result); ++i) {
        pf("%d ", result[i]);
    }
    return 0;
}


#include <bits/stdc++.h>
using namespace std;

#define pb push_back
#define rs resize
#define mp make_pair
#define pi 3.1415926535897932384626433832795
#define sz(a) (int)(a).size()
#define Sort(a) sort((a).begin(), (a).end())
#define Reverse(a) reverse((a).begin(), (a).end())
#define sf scanf
#define pf printf
#define ms(a, x) memset((a), (x), sizeof(a))
typedef vector <int> vi;
typedef vector <vi> vvi;
typedef vector <vvi> vvvi;
typedef vector <vvvi> vvvvi;
typedef vector <bool> vb;
typedef vector <vb> vvb;
typedef vector <vvb> vvvb;
typedef vector <vvvb> vvvvb;
typedef long long ll;
typedef vector <ll> vl;
typedef vector <vl> vvl;
typedef vector <vvl> vvvl;
typedef vector <vvvl> vvvvl;
typedef pair <int, int> ii;
typedef vector <ii> vii;
typedef vector <vii> vvii;
typedef pair <int, ll> il;
typedef vector <il> vil;
typedef vector <vil> vvil;
typedef pair <ll, int> li;
typedef vector <li> vli;
typedef vector <vli> vvli;
typedef set <int> si;
typedef set <li> sli;
typedef set <il> sil;
typedef vector <string> vs;
typedef vector <vs> vvs;
typedef vector <vvs> vvvs;
typedef map <char, int> mci;
typedef pair <ll, ll> pll;
typedef vector <pll> vll;

int gcd(int a, int b) {
    return b != 0 ? gcd(b, a % b) : a;
}

struct Rational {
    int a, b;

    Rational() {}
    Rational(ll a, ll b = 1) : a(a), b(b) {
        ll d = gcd(abs(a), abs(b));
        this->a /= d;
        this->b /= d;
        if (this->b < 0) {
            this->a *= -1;
            this->b *= -1;
        }
    }

    Rational operator +(Rational other) {
        return Rational(a * other.b + b * other.a, b * other.b);
    }

    Rational operator -(Rational other) {
        return Rational(a * other.b - b * other.a, b * other.b);
    }

    Rational operator *(Rational other) {
        return Rational(a * other.a, b * other.b);
    }

    Rational operator /(Rational other) {
        return Rational(a * other.b, b * other.a);
    }

    bool operator <(Rational other) {
        return a * other.b < b * other.a;
    }

    bool operator >(Rational other) {
        return a * other.b > b * other.a;
    }

    bool operator ==(Rational other) {
        return a * other.b == b * other.a;
    }
};

ostream& operator <<(ostream& out, Rational a) {
    out << a.a << '/' << a.b;
    return out;
}

struct point {
    Rational x, y;

    point() {}
    point(Rational x, Rational y) : x(x), y(y) {}

    point operator -(point b) {
        return point(x - b.x, y - b.y);
    }

    point operator +(point b) {
        return point(x + b.x, y + b.y);
    }

};

bool operator <(point a, point b) {
    return a.x * b.y - a.y * b.x > 0 || a.x * b.y - a.y * b.x == 0 && a.x * a.x + a.y * a.y < b.x * b.x + b.y * b.y;
}

bool operator ==(point a, point b) {
    return a.x == b.x && a.y == b.y;
}

bool operator <=(point a, point b) {
    return a < b || b == a;
}

ostream& operator <<(ostream& out, point a) {
    out << a.x << ' ' << a.y << endl;
    return out;
}

void eprint(vector <pair <point, int> > a) {
    cerr << endl;
    for (auto x: a) {
        cerr << x.first;
    }
    cerr << endl;
}

int main() {
    //freopen("input.txt", "r", stdin);
    //freopen("output.txt", "w", stdout);
    int n;
    sf("%d", &n);
    vector <pair <point, int> > a(n);
    for (int i = 0; i < n; ++i) {
        int s, r;
        sf("%d%d", &s, &r);
        a[i].first.x = Rational(1, s);
        a[i].first.y = Rational(1, r);
        a[i].second = i + 1;
    }
    int best = 0;
    for (int i = 1; i < n; ++i) {
        if (a[i].first.x < a[best].first.x || a[i].first.x == a[best].first.x && a[i].first.y < a[best].first.y) {
            best = i;
        }
    }
    Rational x = a[best].first.x, y = a[best].first.y;
    //cerr << x << ' ' << y << endl;
    for (int i = 0; i < n; ++i) {
        a[i].first = a[i].first - point(x, y);
    }
    sort(a.begin(), a.end());
    //eprint(a);
    vector <pair <point, int> > ans;
    ans.pb(a[0]);
    ans.pb(a[1]);
    for (int i = 2; i < sz(a); ++i) {
        while (sz(ans) > 1 && (a[i].first - ans.back().first) <= (ans.back().first - ans[sz(ans) - 2].first)) {
            ans.pop_back();
        }
        ans.push_back(a[i]);
    }
    //eprint(ans);
    best = 0;
    for (int i = 1; i < sz(ans); ++i) {
        if (ans[i].first.y < ans[best].first.y || ans[i].first.y == ans[best].first.y && ans[i].first.x < ans[best].first.x)
            best = i;
    }
    vector <int> result;
    for (int i = 0; i <= best; ++i) {
        result.pb(ans[i].second);
    }
    Sort(result);
    for (int i = 0; i < sz(result); ++i) {
        pf("%d ", result[i]);
    }
    return 0;
}


#include <bits/stdc++.h>
using namespace std;

#define pb push_back
#define rs resize
#define mp make_pair
#define pi 3.1415926535897932384626433832795
#define sz(a) (int)(a).size()
#define Sort(a) sort((a).begin(), (a).end())
#define Reverse(a) reverse((a).begin(), (a).end())
#define sf scanf
#define pf printf
#define ms(a, x) memset((a), (x), sizeof(a))
typedef vector <int> vi;
typedef vector <vi> vvi;
typedef vector <vvi> vvvi;
typedef vector <vvvi> vvvvi;
typedef vector <bool> vb;
typedef vector <vb> vvb;
typedef vector <vvb> vvvb;
typedef vector <vvvb> vvvvb;
typedef long long ll;
typedef vector <ll> vl;
typedef vector <vl> vvl;
typedef vector <vvl> vvvl;
typedef vector <vvvl> vvvvl;
typedef pair <int, int> ii;
typedef vector <ii> vii;
typedef vector <vii> vvii;
typedef pair <int, ll> il;
typedef vector <il> vil;
typedef vector <vil> vvil;
typedef pair <ll, int> li;
typedef vector <li> vli;
typedef vector <vli> vvli;
typedef set <int> si;
typedef set <li> sli;
typedef set <il> sil;
typedef vector <string> vs;
typedef vector <vs> vvs;
typedef vector <vvs> vvvs;
typedef map <char, int> mci;
typedef pair <ll, ll> pll;
typedef vector <pll> vll;
typedef long double ld;

const ld eps = 1e-22;

struct point {
    ld x, y;

    point() {}
    point(ld x, ld y) : x(x), y(y) {}
};

ld operator &(point a, point b) {
    return a.x * b.y - a.y * b.x;
}

point operator +(point a, point b) {
    return point(a.x - b.x, a.y - b.y);
}

point operator -(point a, point b) {
    return point(a.x - b.x, a.y - b.y);
}

ld len(point a) {
    return a.x * a.x + a.y * a.y;
}

bool operator ==(point a, point b) {
    return fabs(a.x - b.x) < eps && fabs(a.y - b.y) < eps;
}

void eprint(vector <pair <point, int> > a) {
    for (auto x: a) {
        cerr << x.second << ' ';
    }
    cerr << endl;
}

int main() {
    freopen("input.txt", "r", stdin);
    freopen("output.txt", "w", stdout);
    int n;
    cin >> n;
    if (n == 1) {
        cout << 1 << endl;
        return 0;
    }
    vector <pair <point, int> > a(n);
    for (int i = 0; i < n; ++i) {
        int s, r;
        cin >> s >> r;
        a[i] = mp(point(1.0 / s, 1.0 / r), i + 1);
    }
    int best = 0;
    for (int i = 1; i < n; ++i) {
        if (a[i].first.x < a[best].first.x || fabs(a[i].first.x - a[best].first.x) < eps && a[i].first.y < a[best].first.y) {
            best = i;
        }
    }
    swap(a[0], a[best]);
    for (int i = 1; i < n; ++i) {
        a[i].first.x -= a[0].first.x;
        a[i].first.y -= a[0].first.y;
    }
    a[0].first = point(0.0, 0.0);
    sort(a.begin() + 1, a.end(), [](pair <point, int> A, pair <point, int> B) {
        auto a = A.first, b = B.first;
        ld mul = a & b;
        if (fabs(mul) < eps) {
            return len(a) < len(b);
        }
        return mul > 0;
    });
    eprint(a);
    vector <pair <point, int> > c;
    c.pb(a[0]);
    for (int i = 1; i < n; ++i) {
        while (sz(c) > 1 && ((a[i].first - c.back().first) & (c.back().first - c[sz(c) - 2].first)) > 0) {
            c.pop_back();
        }
        c.push_back(a[i]);
    }
    eprint(c);
    best = 0;
    for (int i = 0; i < n; ++i) {
        if (a[i].first.y < a[best].first.y || fabs(a[i].first.y - a[best].first.y) < eps && a[i].first.x < a[best].first.x || a[i].first == a[best].first) {
            best = i;
        }
    }
    vi result;
    for (int i = 0; i <= best; ++i) {
        result.pb(a[i].second);
    }
    Sort(result);
    for (int x: result) {
        cout << x << ' ';
    }
    cout << endl;
}


#include <bits/stdc++.h>
using namespace std;

#define pb push_back
#define rs resize
#define mp make_pair
#define pi 3.1415926535897932384626433832795
#define sz(a) (int)(a).size()
#define Sort(a) sort((a).begin(), (a).end())
#define Reverse(a) reverse((a).begin(), (a).end())
#define sf scanf
#define pf printf
#define ms(a, x) memset((a), (x), sizeof(a))
typedef vector <int> vi;
typedef vector <vi> vvi;
typedef vector <vvi> vvvi;
typedef vector <vvvi> vvvvi;
typedef vector <bool> vb;
typedef vector <vb> vvb;
typedef vector <vvb> vvvb;
typedef vector <vvvb> vvvvb;
typedef long long ll;
typedef vector <ll> vl;
typedef vector <vl> vvl;
typedef vector <vvl> vvvl;
typedef vector <vvvl> vvvvl;
typedef pair <int, int> ii;
typedef vector <ii> vii;
typedef vector <vii> vvii;
typedef pair <int, ll> il;
typedef vector <il> vil;
typedef vector <vil> vvil;
typedef pair <ll, int> li;
typedef vector <li> vli;
typedef vector <vli> vvli;
typedef set <int> si;
typedef set <li> sli;
typedef set <il> sil;
typedef vector <string> vs;
typedef vector <vs> vvs;
typedef vector <vvs> vvvs;
typedef map <char, int> mci;
typedef pair <ll, ll> pll;
typedef vector <pll> vll;

ll gcd(ll a, ll b) {
    return b != 0 ? gcd(b, a % b) : a;
}

struct Rational {
    ll a, b;

    Rational() {}
    Rational(ll a, ll b = 1) : a(a), b(b) {
        ll d = gcd(abs(a), abs(b));
        this->a /= d;
        this->b /= d;
        if (this->b < 0) {
            this->a *= -1;
            this->b *= -1;
        }
    }

    Rational operator +(Rational other) {
        return Rational(a * other.b + b * other.a, b * other.b);
    }

    Rational operator -(Rational other) {
        return Rational(a * other.b - b * other.a, b * other.b);
    }

    Rational operator *(Rational other) {
        return Rational(a * other.a, b * other.b);
    }

    Rational operator /(Rational other) {
        return Rational(a * other.b, b * other.a);
    }

    bool operator <(Rational other) {
        return a * other.b < b * other.a;
    }

    bool operator >(Rational other) {
        return a * other.b > b * other.a;
    }

    bool operator ==(Rational other) {
        return a * other.b == b * other.a;
    }
};

ostream& operator <<(ostream& out, Rational a) {
    out << a.a << '/' << a.b;
    return out;
}

struct point {
    long double x, y;

    point() {}
    point(long double x, long double y) : x(x), y(y) {}

    point operator -(point b) {
        return point(x - b.x, y - b.y);
    }

    point operator +(point b) {
        return point(x + b.x, y + b.y);
    }

    double operator &(point b) {
        return x * b.y - y * b.x;
    }
};

const long double eps = 1e-22;

bool operator <(point a, point b) {
    /*cerr.precision(22);
    cerr << fixed;
    cerr << endl;
    cerr << a.x * b.y - a.y * b.x << endl;
    cerr << fabs(a.x * b.y - a.y * b.x) << endl;
    cerr << a.x * a.x + a.y * a.y << ' ' << b.x * b.x + b.y * b.y << endl;
    cerr << endl;*/
    return a.x * b.y - a.y * b.x > eps || fabs(a.x * b.y - a.y * b.x) < eps && a.x * a.x + a.y * a.y < b.x * b.x + b.y * b.y;
}

bool operator ==(point a, point b) {
    /*cerr.precision(22);
    cerr << fixed;
    cerr << endl;
    cerr << fabs(a.x - b.x) << ' ' << fabs(a.y - b.y) << endl;
    cerr << endl;*/
    return fabs(a.x - b.x) < eps && fabs(a.y - b.y) < eps;
}

bool operator >=(point a, point b) {
    return b < a || b == a;
}

ostream& operator <<(ostream& out, point a) {
    out << a.x << ' ' << a.y << endl;
    return out;
}

void eprint(vector <pair <point, int> > a) {
    cerr << endl;
    for (auto x: a) {
        cerr << x.second << ' ' << x.first;
    }
    cerr << endl;
}

int main() {
    freopen("input.txt", "r", stdin);
    //freopen("output.txt", "w", stdout);
    ios_base::sync_with_stdio(0);
    cin.tie(0);
    int n;
    cin >> n;
    vector <pair <point, int> > a(n);
    for (int i = 0; i < n; ++i) {
        int s, r;
        cin >> s >> r;
        a[i].first.x = 1.0 / s;
        a[i].first.y = 1.0 / r;
        a[i].second = i + 1;
    }
    int best = 0;
    for (int i = 1; i < n; ++i) {
        if (a[i].first.x < a[best].first.x || a[i].first.x == a[best].first.x && a[i].first.y < a[best].first.y) {
            best = i;
        }
    }
    long double x = a[best].first.x, y = a[best].first.y;
    //cerr << x << ' ' << y << endl;
    for (int i = 0; i < n; ++i) {
        a[i].first = a[i].first - point(x, y);
    }
    sort(a.begin(), a.end());
    eprint(a);
    vector <pair <point, int> > ans;
    ans.pb(a[0]);
    ans.pb(a[1]);
    for (int i = 2; i < sz(a); ++i) {
        while (sz(ans) > 1 && (a[i].first - ans.back().first) >= (ans.back().first - ans[sz(ans) - 2].first) ||
                fabs((a[i].first - ans.back().first) & (ans.back().first - ans[sz(ans) - 2].first)) < eps) {
            ans.pop_back();
        }
        ans.push_back(a[i]);
    }
    eprint(ans);
    best = 0;
    for (int i = 1; i < sz(ans); ++i) {
        if (ans[i].first.y < ans[best].first.y || ans[i].first.y == ans[best].first.y && ans[i].first.x < ans[best].first.x)
            best = i;
    }
    vector <int> result;
    for (int i = 0; i <= best; ++i) {
        result.pb(ans[i].second);
    }
    for (int i = 0; i < n; ++i) {
        if (a[i].first == ans[0].first || a[i].first == ans[best].first)
            result.pb(a[i].second);
    }
    Sort(result);
    for (int i = 0; i < sz(result); ++i) {
        if (i == 0 || result[i] != result[i - 1]) {
            cout << result[i] << ' ';
        }
    }
    return 0;
}


#include <bits/stdc++.h>
using namespace std;

#define pb push_back
#define rs resize
#define mp make_pair
#define pi 3.1415926535897932384626433832795
#define sz(a) (int)(a).size()
#define Sort(a) sort((a).begin(), (a).end())
#define Reverse(a) reverse((a).begin(), (a).end())
#define sf scanf
#define pf printf
#define ms(a, x) memset((a), (x), sizeof(a))
typedef vector <int> vi;
typedef vector <vi> vvi;
typedef vector <vvi> vvvi;
typedef vector <vvvi> vvvvi;
typedef vector <bool> vb;
typedef vector <vb> vvb;
typedef vector <vvb> vvvb;
typedef vector <vvvb> vvvvb;
typedef long long ll;
typedef vector <ll> vl;
typedef vector <vl> vvl;
typedef vector <vvl> vvvl;
typedef vector <vvvl> vvvvl;
typedef pair <int, int> ii;
typedef vector <ii> vii;
typedef vector <vii> vvii;
typedef pair <int, ll> il;
typedef vector <il> vil;
typedef vector <vil> vvil;
typedef pair <ll, int> li;
typedef vector <li> vli;
typedef vector <vli> vvli;
typedef set <int> si;
typedef set <li> sli;
typedef set <il> sil;
typedef vector <string> vs;
typedef vector <vs> vvs;
typedef vector <vvs> vvvs;
typedef map <char, int> mci;
typedef pair <ll, ll> pll;
typedef vector <pll> vll;

ll gcd(ll a, ll b) {
    return b != 0 ? gcd(b, a % b) : a;
}

struct Rational {
    ll a, b;

    Rational() {}
    Rational(ll a, ll b = 1) : a(a), b(b) {
        ll d = gcd(abs(a), abs(b));
        this->a /= d;
        this->b /= d;
        if (this->b < 0) {
            this->a *= -1;
            this->b *= -1;
        }
    }

    Rational operator +(Rational other) {
        return Rational(a * other.b + b * other.a, b * other.b);
    }

    Rational operator -(Rational other) {
        return Rational(a * other.b - b * other.a, b * other.b);
    }

    Rational operator *(Rational other) {
        return Rational(a * other.a, b * other.b);
    }

    Rational operator /(Rational other) {
        return Rational(a * other.b, b * other.a);
    }

    bool operator <(Rational other) {
        return a * other.b < b * other.a;
    }

    bool operator >(Rational other) {
        return a * other.b > b * other.a;
    }

    bool operator ==(Rational other) {
        return a * other.b == b * other.a;
    }
};

ostream& operator <<(ostream& out, Rational a) {
    out << a.a << '/' << a.b;
    return out;
}

struct point {
    long double x, y;

    point() {}
    point(long double x, long double y) : x(x), y(y) {}

    point operator -(point b) {
        return point(x - b.x, y - b.y);
    }

    point operator +(point b) {
        return point(x + b.x, y + b.y);
    }

};

const double eps = 1e-15;

bool operator <(point a, point b) {
    return a.x * b.y - a.y * b.x > eps || fabs(a.x * b.y - a.y * b.x) < eps && a.x * a.x + a.y * a.y < b.x * b.x + b.y * b.y;
}

bool operator ==(point a, point b) {
    return fabs(a.x - b.x) < eps && fabs(a.y - b.y) < eps;
}

bool operator <=(point a, point b) {
    return a < b || b == a;
}

ostream& operator <<(ostream& out, point a) {
    out << a.x << ' ' << a.y << endl;
    return out;
}

void eprint(vector <pair <point, int> > a) {
    cerr << endl;
    for (auto x: a) {
        cerr << x.first;
    }
    cerr << endl;
}

int main() {
    //freopen("input.txt", "r", stdin);
    //freopen("output.txt", "w", stdout);
    ios_base::sync_with_stdio(0);
    cin.tie(0);
    int n;
    cin >> n;
    vector <pair <point, int> > a(n);
    for (int i = 0; i < n; ++i) {
        int s, r;
        cin >> s >> r;
        a[i].first.x = 1.0 / s;
        a[i].first.y = 1.0 / r;
        a[i].second = i + 1;
    }
    int best = 0;
    for (int i = 1; i < n; ++i) {
        if (a[i].first.x < a[best].first.x || a[i].first.x == a[best].first.x && a[i].first.y < a[best].first.y) {
            best = i;
        }
    }
    long double x = a[best].first.x, y = a[best].first.y;
    //cerr << x << ' ' << y << endl;
    for (int i = 0; i < n; ++i) {
        a[i].first = a[i].first - point(x, y);
    }
    sort(a.begin(), a.end());
    //eprint(a);
    vector <pair <point, int> > ans;
    ans.pb(a[0]);
    ans.pb(a[1]);
    for (int i = 2; i < sz(a); ++i) {
        while (sz(ans) > 1 && (a[i].first - ans.back().first) <= (ans.back().first - ans[sz(ans) - 2].first)) {
            ans.pop_back();
        }
        ans.push_back(a[i]);
    }
    //eprint(ans);
    best = 0;
    for (int i = 1; i < sz(ans); ++i) {
        if (ans[i].first.y < ans[best].first.y || ans[i].first.y == ans[best].first.y && ans[i].first.x < ans[best].first.x)
            best = i;
    }
    vector <int> result;
    for (int i = 0; i <= best; ++i) {
        result.pb(ans[i].second);
    }
    for (int i = 0; i < n; ++i) {
        if (a[i].first == ans[0].first || a[i].first == ans[best].first)
            result.pb(a[i].second);
    }
    Sort(result);
    for (int i = 0; i < sz(result); ++i) {
        if (i == 0 || result[i] != result[i - 1]) {
            cout << result[i] << ' ';
        }
    }
    return 0;
}


#include <bits/stdc++.h>
using namespace std;

#define pb push_back
#define rs resize
#define mp make_pair
#define pi 3.1415926535897932384626433832795
#define sz(a) (int)(a).size()
#define Sort(a) sort((a).begin(), (a).end())
#define Reverse(a) reverse((a).begin(), (a).end())
#define sf scanf
#define pf printf
#define ms(a, x) memset((a), (x), sizeof(a))
typedef vector <int> vi;
typedef vector <vi> vvi;
typedef vector <vvi> vvvi;
typedef vector <vvvi> vvvvi;
typedef vector <bool> vb;
typedef vector <vb> vvb;
typedef vector <vvb> vvvb;
typedef vector <vvvb> vvvvb;
typedef long long ll;
typedef vector <ll> vl;
typedef vector <vl> vvl;
typedef vector <vvl> vvvl;
typedef vector <vvvl> vvvvl;
typedef pair <int, int> ii;
typedef vector <ii> vii;
typedef vector <vii> vvii;
typedef pair <int, ll> il;
typedef vector <il> vil;
typedef vector <vil> vvil;
typedef pair <ll, int> li;
typedef vector <li> vli;
typedef vector <vli> vvli;
typedef set <int> si;
typedef set <li> sli;
typedef set <il> sil;
typedef vector <string> vs;
typedef vector <vs> vvs;
typedef vector <vvs> vvvs;
typedef map <char, int> mci;
typedef pair <ll, ll> pll;
typedef vector <pll> vll;

ll gcd(ll a, ll b) {
    return b != 0 ? gcd(b, a % b) : a;
}

struct Rational {
    ll a, b;

    Rational() {}
    Rational(ll a, ll b = 1) : a(a), b(b) {
        ll d = gcd(abs(a), abs(b));
        this->a /= d;
        this->b /= d;
        if (this->b < 0) {
            this->a *= -1;
            this->b *= -1;
        }
    }

    Rational operator +(Rational other) {
        return Rational(a * other.b + b * other.a, b * other.b);
    }

    Rational operator -(Rational other) {
        return Rational(a * other.b - b * other.a, b * other.b);
    }

    Rational operator *(Rational other) {
        return Rational(a * other.a, b * other.b);
    }

    Rational operator /(Rational other) {
        return Rational(a * other.b, b * other.a);
    }

    bool operator <(Rational other) {
        return a * other.b < b * other.a;
    }

    bool operator >(Rational other) {
        return a * other.b > b * other.a;
    }

    bool operator ==(Rational other) {
        return a * other.b == b * other.a;
    }
};

ostream& operator <<(ostream& out, Rational a) {
    out << a.a << '/' << a.b;
    return out;
}

struct point {
    long double x, y;

    point() {}
    point(long double x, long double y) : x(x), y(y) {}

    point operator -(point b) {
        return point(x - b.x, y - b.y);
    }

    point operator +(point b) {
        return point(x + b.x, y + b.y);
    }

};

const double eps = 1e-23;

bool operator <(point a, point b) {
    return a.x * b.y - a.y * b.x > eps || fabs(a.x * b.y - a.y * b.x) < eps && a.x * a.x + a.y * a.y < b.x * b.x + b.y * b.y;
}

bool operator ==(point a, point b) {
    return fabs(a.x - b.x) < eps && fabs(a.y - b.y) < eps;
}

bool operator <=(point a, point b) {
    return a < b || b == a;
}

ostream& operator <<(ostream& out, point a) {
    out << a.x << ' ' << a.y << endl;
    return out;
}

void eprint(vector <pair <point, int> > a) {
    cerr << endl;
    for (auto x: a) {
        cerr << x.first;
    }
    cerr << endl;
}

int main() {
    //freopen("input.txt", "r", stdin);
    //freopen("output.txt", "w", stdout);
    ios_base::sync_with_stdio(0);
    cin.tie(0);
    int n;
    cin >> n;
    vector <pair <point, int> > a(n);
    for (int i = 0; i < n; ++i) {
        int s, r;
        cin >> s >> r;
        a[i].first.x = 1.0 / s;
        a[i].first.y = 1.0 / r;
        a[i].second = i + 1;
    }
    int best = 0;
    for (int i = 1; i < n; ++i) {
        if (a[i].first.x < a[best].first.x || a[i].first.x == a[best].first.x && a[i].first.y < a[best].first.y) {
            best = i;
        }
    }
    long double x = a[best].first.x, y = a[best].first.y;
    //cerr << x << ' ' << y << endl;
    for (int i = 0; i < n; ++i) {
        a[i].first = a[i].first - point(x, y);
    }
    sort(a.begin(), a.end());
    //eprint(a);
    vector <pair <point, int> > ans;
    ans.pb(a[0]);
    ans.pb(a[1]);
    for (int i = 2; i < sz(a); ++i) {
        while (sz(ans) > 1 && (a[i].first - ans.back().first) <= (ans.back().first - ans[sz(ans) - 2].first)) {
            ans.pop_back();
        }
        ans.push_back(a[i]);
    }
    //eprint(ans);
    best = 0;
    for (int i = 1; i < sz(ans); ++i) {
        if (ans[i].first.y < ans[best].first.y || ans[i].first.y == ans[best].first.y && ans[i].first.x < ans[best].first.x)
            best = i;
    }
    vector <int> result;
    for (int i = 0; i <= best; ++i) {
        result.pb(ans[i].second);
    }
    for (int i = 0; i < n; ++i) {
        if (a[i].first == ans[0].first || a[i].first == ans[best].first)
            result.pb(a[i].second);
    }
    Sort(result);
    for (int i = 0; i < sz(result); ++i) {
        if (i == 0 || result[i] != result[i - 1]) {
            cout << result[i] << ' ';
        }
    }
    return 0;
}


#include <bits/stdc++.h>
using namespace std;

#define pb push_back
#define rs resize
#define mp make_pair
#define pi 3.1415926535897932384626433832795
#define sz(a) (int)(a).size()
#define Sort(a) sort((a).begin(), (a).end())
#define Reverse(a) reverse((a).begin(), (a).end())
#define sf scanf
#define pf printf
#define ms(a, x) memset((a), (x), sizeof(a))
typedef vector <int> vi;
typedef vector <vi> vvi;
typedef vector <vvi> vvvi;
typedef vector <vvvi> vvvvi;
typedef vector <bool> vb;
typedef vector <vb> vvb;
typedef vector <vvb> vvvb;
typedef vector <vvvb> vvvvb;
typedef long long ll;
typedef vector <ll> vl;
typedef vector <vl> vvl;
typedef vector <vvl> vvvl;
typedef vector <vvvl> vvvvl;
typedef pair <int, int> ii;
typedef vector <ii> vii;
typedef vector <vii> vvii;
typedef pair <int, ll> il;
typedef vector <il> vil;
typedef vector <vil> vvil;
typedef pair <ll, int> li;
typedef vector <li> vli;
typedef vector <vli> vvli;
typedef set <int> si;
typedef set <li> sli;
typedef set <il> sil;
typedef vector <string> vs;
typedef vector <vs> vvs;
typedef vector <vvs> vvvs;
typedef map <char, int> mci;
typedef pair <ll, ll> pll;
typedef vector <pll> vll;

ll gcd(ll a, ll b) {
    return b != 0 ? gcd(b, a % b) : a;
}

struct Rational {
    ll a, b;

    Rational() {}
    Rational(ll a, ll b = 1) : a(a), b(b) {
        ll d = gcd(abs(a), abs(b));
        this->a /= d;
        this->b /= d;
        if (this->b < 0) {
            this->a *= -1;
            this->b *= -1;
        }
    }

    Rational operator +(Rational other) {
        return Rational(a * other.b + b * other.a, b * other.b);
    }

    Rational operator -(Rational other) {
        return Rational(a * other.b - b * other.a, b * other.b);
    }

    Rational operator *(Rational other) {
        return Rational(a * other.a, b * other.b);
    }

    Rational operator /(Rational other) {
        return Rational(a * other.b, b * other.a);
    }

    bool operator <(Rational other) {
        return a * other.b < b * other.a;
    }

    bool operator >(Rational other) {
        return a * other.b > b * other.a;
    }

    bool operator ==(Rational other) {
        return a * other.b == b * other.a;
    }
};

ostream& operator <<(ostream& out, Rational a) {
    out << a.a << '/' << a.b;
    return out;
}

struct point {
    long double x, y;

    point() {}
    point(long double x, long double y) : x(x), y(y) {}

    point operator -(point b) {
        return point(x - b.x, y - b.y);
    }

    point operator +(point b) {
        return point(x + b.x, y + b.y);
    }

};

bool operator <(point a, point b) {
    return a.x * b.y - a.y * b.x > 0 || a.x * b.y - a.y * b.x == 0 && a.x * a.x + a.y * a.y < b.x * b.x + b.y * b.y;
}

bool operator ==(point a, point b) {
    return a.x == b.x && a.y == b.y;
}

bool operator <=(point a, point b) {
    return a < b || b == a;
}

ostream& operator <<(ostream& out, point a) {
    out << a.x << ' ' << a.y << endl;
    return out;
}

void eprint(vector <pair <point, int> > a) {
    cerr << endl;
    for (auto x: a) {
        cerr << x.first;
    }
    cerr << endl;
}

int main() {
    //freopen("input.txt", "r", stdin);
    //freopen("output.txt", "w", stdout);
    ios_base::sync_with_stdio(0);
    cin.tie(0);
    int n;
    cin >> n;
    vector <pair <point, int> > a(n);
    for (int i = 0; i < n; ++i) {
        int s, r;
        cin >> s >> r;
        a[i].first.x = 1.0 / s;
        a[i].first.y = 1.0 / r;
        a[i].second = i + 1;
    }
    int best = 0;
    for (int i = 1; i < n; ++i) {
        if (a[i].first.x < a[best].first.x || a[i].first.x == a[best].first.x && a[i].first.y < a[best].first.y) {
            best = i;
        }
    }
    Rational x = a[best].first.x, y = a[best].first.y;
    //cerr << x << ' ' << y << endl;
    for (int i = 0; i < n; ++i) {
        a[i].first = a[i].first - point(x, y);
    }
    sort(a.begin(), a.end());
    //eprint(a);
    vector <pair <point, int> > ans;
    ans.pb(a[0]);
    ans.pb(a[1]);
    for (int i = 2; i < sz(a); ++i) {
        while (sz(ans) > 1 && (a[i].first - ans.back().first) <= (ans.back().first - ans[sz(ans) - 2].first)) {
            ans.pop_back();
        }
        ans.push_back(a[i]);
    }
    //eprint(ans);
    best = 0;
    for (int i = 1; i < sz(ans); ++i) {
        if (ans[i].first.y < ans[best].first.y || ans[i].first.y == ans[best].first.y && ans[i].first.x < ans[best].first.x)
            best = i;
    }
    vector <int> result;
    for (int i = 0; i <= best; ++i) {
        result.pb(ans[i].second);
    }
    Sort(result);
    for (int i = 0; i < sz(result); ++i) {
        cout << result[i] << ' ';
    }
    return 0;
}


#include <bits/stdc++.h>
using namespace std;

#define pb push_back
#define rs resize
#define mp make_pair
#define pi 3.1415926535897932384626433832795
#define sz(a) (int)(a).size()
#define Sort(a) sort((a).begin(), (a).end())
#define Reverse(a) reverse((a).begin(), (a).end())
#define sf scanf
#define pf printf
#define ms(a, x) memset((a), (x), sizeof(a))
typedef vector <int> vi;
typedef vector <vi> vvi;
typedef vector <vvi> vvvi;
typedef vector <vvvi> vvvvi;
typedef vector <bool> vb;
typedef vector <vb> vvb;
typedef vector <vvb> vvvb;
typedef vector <vvvb> vvvvb;
typedef long long ll;
typedef vector <ll> vl;
typedef vector <vl> vvl;
typedef vector <vvl> vvvl;
typedef vector <vvvl> vvvvl;
typedef pair <int, int> ii;
typedef vector <ii> vii;
typedef vector <vii> vvii;
typedef pair <int, ll> il;
typedef vector <il> vil;
typedef vector <vil> vvil;
typedef pair <ll, int> li;
typedef vector <li> vli;
typedef vector <vli> vvli;
typedef set <int> si;
typedef set <li> sli;
typedef set <il> sil;
typedef vector <string> vs;
typedef vector <vs> vvs;
typedef vector <vvs> vvvs;
typedef map <char, int> mci;
typedef pair <ll, ll> pll;
typedef vector <pll> vll;

ll gcd(ll a, ll b) {
    return b != 0 ? gcd(b, a % b) : a;
}

struct Rational {
    ll a, b;

    Rational() {}
    Rational(ll a, ll b = 1) : a(a), b(b) {
        ll d = gcd(abs(a), abs(b));
        this->a /= d;
        this->b /= d;
        if (this->b < 0) {
            this->a *= -1;
            this->b *= -1;
        }
    }

    Rational operator +(Rational other) {
        return Rational(a * other.b + b * other.a, b * other.b);
    }

    Rational operator -(Rational other) {
        return Rational(a * other.b - b * other.a, b * other.b);
    }

    Rational operator *(Rational other) {
        return Rational(a * other.a, b * other.b);
    }

    Rational operator /(Rational other) {
        return Rational(a * other.b, b * other.a);
    }

    bool operator <(Rational other) {
        return a * other.b < b * other.a;
    }

    bool operator >(Rational other) {
        return a * other.b > b * other.a;
    }

    bool operator ==(Rational other) {
        return a * other.b == b * other.a;
    }
};

ostream& operator <<(ostream& out, Rational a) {
    out << a.a << '/' << a.b;
    return out;
}

struct point {
    long double x, y;

    point() {}
    point(long double x, long double y) : x(x), y(y) {}

    point operator -(point b) {
        return point(x - b.x, y - b.y);
    }

    point operator +(point b) {
        return point(x + b.x, y + b.y);
    }

    double operator &(point b) {
        return x * b.y - y * b.x;
    }
};

const long double eps = 1e-22;

bool operator <(point a, point b) {
    /*cerr.precision(22);
    cerr << fixed;
    cerr << endl;
    cerr << a.x * b.y - a.y * b.x << endl;
    cerr << fabs(a.x * b.y - a.y * b.x) << endl;
    cerr << a.x * a.x + a.y * a.y << ' ' << b.x * b.x + b.y * b.y << endl;
    cerr << endl;*/
    return a.x * b.y - a.y * b.x > eps || fabs(a.x * b.y - a.y * b.x) < eps && a.x * a.x + a.y * a.y < b.x * b.x + b.y * b.y;
}

bool operator ==(point a, point b) {
    /*cerr.precision(22);
    cerr << fixed;
    cerr << endl;
    cerr << fabs(a.x - b.x) << ' ' << fabs(a.y - b.y) << endl;
    cerr << endl;*/
    return fabs(a.x - b.x) < eps && fabs(a.y - b.y) < eps;
}

bool operator <=(point a, point b) {
    return a < b || b == a;
}

ostream& operator <<(ostream& out, point a) {
    out << a.x << ' ' << a.y << endl;
    return out;
}

void eprint(vector <pair <point, int> > a) {
    cerr << endl;
    for (auto x: a) {
        cerr << x.second << ' ' << x.first;
    }
    cerr << endl;
}

int main() {
    //freopen("input.txt", "r", stdin);
    //freopen("output.txt", "w", stdout);
    ios_base::sync_with_stdio(0);
    cin.tie(0);
    int n;
    cin >> n;
    vector <pair <point, int> > a(n);
    for (int i = 0; i < n; ++i) {
        int s, r;
        cin >> s >> r;
        a[i].first.x = 1.0 / s;
        a[i].first.y = 1.0 / r;
        a[i].second = i + 1;
    }
    int best = 0;
    for (int i = 1; i < n; ++i) {
        if (a[i].first.x < a[best].first.x || a[i].first.x == a[best].first.x && a[i].first.y < a[best].first.y) {
            best = i;
        }
    }
    long double x = a[best].first.x, y = a[best].first.y;
    //cerr << x << ' ' << y << endl;
    for (int i = 0; i < n; ++i) {
        a[i].first = a[i].first - point(x, y);
    }
    sort(a.begin(), a.end());
    //eprint(a);
    vector <pair <point, int> > ans;
    ans.pb(a[0]);
    ans.pb(a[1]);
    for (int i = 2; i < sz(a); ++i) {
        while (sz(ans) > 1 && (a[i].first - ans.back().first) <= (ans.back().first - ans[sz(ans) - 2].first) &&
                fabs((a[i].first - ans.back().first) & (ans.back().first - ans[sz(ans) - 2].first)) > eps) {
            ans.pop_back();
        }
        ans.push_back(a[i]);
    }
    //eprint(ans);
    best = 0;
    for (int i = 1; i < sz(ans); ++i) {
        if (ans[i].first.y < ans[best].first.y || ans[i].first.y == ans[best].first.y && ans[i].first.x < ans[best].first.x)
            best = i;
    }
    vector <int> result;
    for (int i = 0; i <= best; ++i) {
        result.pb(ans[i].second);
    }
    for (int i = 0; i < n; ++i) {
        if (a[i].first == ans[0].first || a[i].first == ans[best].first)
            result.pb(a[i].second);
    }
    Sort(result);
    for (int i = 0; i < sz(result); ++i) {
        if (i == 0 || result[i] != result[i - 1]) {
            cout << result[i] << ' ';
        }
    }
    return 0;
}


#include <iostream>
#include <vector>
#include <algorithm>
#include <set>
#include <map>
#include <string>
using namespace std;

#define pb push_back
#define rs resize
#define mp make_pair
#define pi 3.1415926535897932384626433832795
#define sz(a) (int)(a).size()
#define Sort(a) sort((a).begin(), (a).end())
#define Reverse(a) reverse((a).begin(), (a).end())
#define sf scanf
#define pf printf
#define ms(a, x) memset((a), (x), sizeof(a))
typedef vector <int> vi;
typedef vector <vi> vvi;
typedef vector <vvi> vvvi;
typedef vector <vvvi> vvvvi;
typedef vector <bool> vb;
typedef vector <vb> vvb;
typedef vector <vvb> vvvb;
typedef vector <vvvb> vvvvb;
typedef long long ll;
typedef vector <ll> vl;
typedef vector <vl> vvl;
typedef vector <vvl> vvvl;
typedef vector <vvvl> vvvvl;
typedef pair <int, int> ii;
typedef vector <ii> vii;
typedef vector <vii> vvii;
typedef pair <int, ll> il;
typedef vector <il> vil;
typedef vector <vil> vvil;
typedef pair <ll, int> li;
typedef vector <li> vli;
typedef vector <vli> vvli;
typedef set <int> si;
typedef set <li> sli;
typedef set <il> sil;
typedef vector <string> vs;
typedef vector <vs> vvs;
typedef vector <vvs> vvvs;
typedef map <char, int> mci;
typedef pair <ll, ll> pll;
typedef vector <pll> vll;
typedef long double ld;

const ld eps = 1e-22;

struct point {
    ld x, y;

    point() {}
    point(ld x, ld y) : x(x), y(y) {}
};

ld operator &(point a, point b) {
    return a.x * b.y - a.y * b.x;
}

point operator +(point a, point b) {
    return point(a.x - b.x, a.y - b.y);
}

point operator -(point a, point b) {
    return point(a.x - b.x, a.y - b.y);
}

ld len(point a) {
    return a.x * a.x + a.y * a.y;
}

bool operator ==(point a, point b) {
    return fabs(a.x - b.x) < eps && fabs(a.y - b.y) < eps;
}

void eprint(vector <pair <point, int> > a) {
    for (int i = 0; i < sz(a); ++i) {
        cerr << a[i].second << ' ';
    }
    cerr << endl;
}

int main() {
    //freopen("input.txt", "r", stdin);
    //freopen("output.txt", "w", stdout);
    int n;
    cin >> n;
    if (n == 1) {
        cout << 1 << endl;
        return 0;
    }
    vector <pair <point, int> > a(n);
    for (int i = 0; i < n; ++i) {
        int s, r;
        cin >> s >> r;
        a[i] = mp(point(1.0 / s, 1.0 / r), i + 1);
    }
    int best = 0;
    for (int i = 1; i < n; ++i) {
        if (a[i].first.x < a[best].first.x || fabs(a[i].first.x - a[best].first.x) < eps && a[i].first.y < a[best].first.y) {
            best = i;
        }
    }
    //cerr << best + 1 << endl;
    swap(a[0], a[best]);
    for (int i = 1; i < n; ++i) {
        a[i].first.x -= a[0].first.x;
        a[i].first.y -= a[0].first.y;
    }
    a[0].first = point(0.0, 0.0);
    sort(a.begin() + 1, a.end(), [](pair <point, int> A, pair <point, int> B) {
        auto a = A.first, b = B.first;
        ld mul = a & b;
        if (fabs(mul) < eps) {
            return len(a) < len(b);
        }
        return mul > 0;
    });
    //eprint(a);
    vector <pair <point, int> > c;
    c.pb(a[0]);
    for (int i = 1; i < n; ++i) {
        while (sz(c) > 1 && ((a[i].first - c.back().first) & (c.back().first - c[sz(c) - 2].first)) > eps) {
            c.pop_back();
        }
        c.push_back(a[i]);
    }
    //eprint(c);
    best = 0;
    for (int i = 0; i < sz(c); ++i) {
        if (c[i].first.y < c[best].first.y || fabs(c[i].first.y - c[best].first.y) < eps && c[i].first.x < c[best].first.x || c[i].first == c[best].first) {
            best = i;
        }
    }
    vi result;
    for (int i = 0; i <= best; ++i) {
        result.pb(c[i].second);
    }
    Sort(result);
    for (int i = 0; i < sz(result); ++i) {
        cout << result[i] << ' ';
    }
    cout << endl;
}


#include <bits/stdc++.h>
using namespace std;

#define pb push_back
#define rs resize
#define mp make_pair
#define pi 3.1415926535897932384626433832795
#define sz(a) (int)(a).size()
#define Sort(a) sort((a).begin(), (a).end())
#define Reverse(a) reverse((a).begin(), (a).end())
#define sf scanf
#define pf printf
#define ms(a, x) memset((a), (x), sizeof(a))
typedef vector <int> vi;
typedef vector <vi> vvi;
typedef vector <vvi> vvvi;
typedef vector <vvvi> vvvvi;
typedef vector <bool> vb;
typedef vector <vb> vvb;
typedef vector <vvb> vvvb;
typedef vector <vvvb> vvvvb;
typedef long long ll;
typedef vector <ll> vl;
typedef vector <vl> vvl;
typedef vector <vvl> vvvl;
typedef vector <vvvl> vvvvl;
typedef pair <int, int> ii;
typedef vector <ii> vii;
typedef vector <vii> vvii;
typedef pair <int, ll> il;
typedef vector <il> vil;
typedef vector <vil> vvil;
typedef pair <ll, int> li;
typedef vector <li> vli;
typedef vector <vli> vvli;
typedef set <int> si;
typedef set <li> sli;
typedef set <il> sil;
typedef vector <string> vs;
typedef vector <vs> vvs;
typedef vector <vvs> vvvs;
typedef map <char, int> mci;
typedef pair <ll, ll> pll;
typedef vector <pll> vll;

ll gcd(ll a, ll b) {
    return b != 0 ? gcd(b, a % b) : a;
}

struct Rational {
    ll a, b;

    Rational() {}
    Rational(ll a, ll b = 1) : a(a), b(b) {
        ll d = gcd(abs(a), abs(b));
        this->a /= d;
        this->b /= d;
        if (this->b < 0) {
            this->a *= -1;
            this->b *= -1;
        }
    }

    Rational operator +(Rational other) {
        return Rational(a * other.b + b * other.a, b * other.b);
    }

    Rational operator -(Rational other) {
        return Rational(a * other.b - b * other.a, b * other.b);
    }

    Rational operator *(Rational other) {
        return Rational(a * other.a, b * other.b);
    }

    Rational operator /(Rational other) {
        return Rational(a * other.b, b * other.a);
    }

    bool operator <(Rational other) {
        return a * other.b < b * other.a;
    }

    bool operator >(Rational other) {
        return a * other.b > b * other.a;
    }

    bool operator ==(Rational other) {
        return a * other.b == b * other.a;
    }
};

ostream& operator <<(ostream& out, Rational a) {
    out << a.a << '/' << a.b;
    return out;
}

struct point {
    long double x, y;

    point() {}
    point(long double x, long double y) : x(x), y(y) {}

    point operator -(point b) {
        return point(x - b.x, y - b.y);
    }

    point operator +(point b) {
        return point(x + b.x, y + b.y);
    }

};

const long double eps = 1e-24;

bool operator <(point a, point b) {
    return a.x * b.y - a.y * b.x > eps || fabs(a.x * b.y - a.y * b.x) < eps && a.x * a.x + a.y * a.y < b.x * b.x + b.y * b.y;
}

bool operator ==(point a, point b) {
    return fabs(a.x - b.x) < eps && fabs(a.y - b.y) < eps;
}

bool operator <=(point a, point b) {
    return a < b || b == a;
}

ostream& operator <<(ostream& out, point a) {
    out << a.x << ' ' << a.y << endl;
    return out;
}

void eprint(vector <pair <point, int> > a) {
    cerr << endl;
    for (auto x: a) {
        cerr << x.first;
    }
    cerr << endl;
}

int main() {
    //freopen("input.txt", "r", stdin);
    //freopen("output.txt", "w", stdout);
    ios_base::sync_with_stdio(0);
    cin.tie(0);
    int n;
    cin >> n;
    vector <pair <point, int> > a(n);
    for (int i = 0; i < n; ++i) {
        int s, r;
        cin >> s >> r;
        a[i].first.x = 1.0 / s;
        a[i].first.y = 1.0 / r;
        a[i].second = i + 1;
    }
    int best = 0;
    for (int i = 1; i < n; ++i) {
        if (a[i].first.x < a[best].first.x || a[i].first.x == a[best].first.x && a[i].first.y < a[best].first.y) {
            best = i;
        }
    }
    long double x = a[best].first.x, y = a[best].first.y;
    //cerr << x << ' ' << y << endl;
    for (int i = 0; i < n; ++i) {
        a[i].first = a[i].first - point(x, y);
    }
    sort(a.begin(), a.end());
    //eprint(a);
    vector <pair <point, int> > ans;
    ans.pb(a[0]);
    ans.pb(a[1]);
    for (int i = 2; i < sz(a); ++i) {
        while (sz(ans) > 1 && (a[i].first - ans.back().first) <= (ans.back().first - ans[sz(ans) - 2].first)) {
            ans.pop_back();
        }
        ans.push_back(a[i]);
    }
    //eprint(ans);
    best = 0;
    for (int i = 1; i < sz(ans); ++i) {
        if (ans[i].first.y < ans[best].first.y || ans[i].first.y == ans[best].first.y && ans[i].first.x < ans[best].first.x)
            best = i;
    }
    vector <int> result;
    for (int i = 0; i <= best; ++i) {
        result.pb(ans[i].second);
    }
    for (int i = 0; i < n; ++i) {
        if (a[i].first == ans[0].first || a[i].first == ans[best].first)
            result.pb(a[i].second);
    }
    Sort(result);
    for (int i = 0; i < sz(result); ++i) {
        if (i == 0 || result[i] != result[i - 1]) {
            cout << result[i] << ' ';
        }
    }
    return 0;
}


#include <bits/stdc++.h>
using namespace std;

#define pb push_back
#define rs resize
#define mp make_pair
#define pi 3.1415926535897932384626433832795
#define sz(a) (int)(a).size()
#define Sort(a) sort((a).begin(), (a).end())
#define Reverse(a) reverse((a).begin(), (a).end())
#define sf scanf
#define pf printf
#define ms(a, x) memset((a), (x), sizeof(a))
typedef vector <int> vi;
typedef vector <vi> vvi;
typedef vector <vvi> vvvi;
typedef vector <vvvi> vvvvi;
typedef vector <bool> vb;
typedef vector <vb> vvb;
typedef vector <vvb> vvvb;
typedef vector <vvvb> vvvvb;
typedef long long ll;
typedef vector <ll> vl;
typedef vector <vl> vvl;
typedef vector <vvl> vvvl;
typedef vector <vvvl> vvvvl;
typedef pair <int, int> ii;
typedef vector <ii> vii;
typedef vector <vii> vvii;
typedef pair <int, ll> il;
typedef vector <il> vil;
typedef vector <vil> vvil;
typedef pair <ll, int> li;
typedef vector <li> vli;
typedef vector <vli> vvli;
typedef set <int> si;
typedef set <li> sli;
typedef set <il> sil;
typedef vector <string> vs;
typedef vector <vs> vvs;
typedef vector <vvs> vvvs;
typedef map <char, int> mci;
typedef pair <ll, ll> pll;
typedef vector <pll> vll;

ll gcd(ll a, ll b) {
    return b != 0 ? gcd(b, a % b) : a;
}

struct Rational {
    ll a, b;

    Rational() {}
    Rational(ll a, ll b = 1) : a(a), b(b) {
        ll d = gcd(abs(a), abs(b));
        this->a /= d;
        this->b /= d;
        if (this->b < 0) {
            this->a *= -1;
            this->b *= -1;
        }
    }

    Rational operator +(Rational other) {
        return Rational(a * other.b + b * other.a, b * other.b);
    }

    Rational operator -(Rational other) {
        return Rational(a * other.b - b * other.a, b * other.b);
    }

    Rational operator *(Rational other) {
        return Rational(a * other.a, b * other.b);
    }

    Rational operator /(Rational other) {
        return Rational(a * other.b, b * other.a);
    }

    bool operator <(Rational other) {
        return a * other.b < b * other.a;
    }

    bool operator >(Rational other) {
        return a * other.b > b * other.a;
    }

    bool operator ==(Rational other) {
        return a * other.b == b * other.a;
    }
};

ostream& operator <<(ostream& out, Rational a) {
    out << a.a << '/' << a.b;
    return out;
}

struct point {
    long double x, y;

    point() {}
    point(long double x, long double y) : x(x), y(y) {}

    point operator -(point b) {
        return point(x - b.x, y - b.y);
    }

    point operator +(point b) {
        return point(x + b.x, y + b.y);
    }

};

bool operator <(point a, point b) {
    return a.x * b.y - a.y * b.x > 0 || a.x * b.y - a.y * b.x == 0 && a.x * a.x + a.y * a.y < b.x * b.x + b.y * b.y;
}

bool operator ==(point a, point b) {
    return a.x == b.x && a.y == b.y;
}

bool operator <=(point a, point b) {
    return a < b || b == a;
}

ostream& operator <<(ostream& out, point a) {
    out << a.x << ' ' << a.y << endl;
    return out;
}

void eprint(vector <pair <point, int> > a) {
    cerr << endl;
    for (auto x: a) {
        cerr << x.first;
    }
    cerr << endl;
}

int main() {
    //freopen("input.txt", "r", stdin);
    //freopen("output.txt", "w", stdout);
    ios_base::sync_with_stdio(0);
    cin.tie(0);
    int n;
    cin >> n;
    vector <pair <point, int> > a(n);
    for (int i = 0; i < n; ++i) {
        int s, r;
        cin >> s >> r;
        a[i].first.x = 1.0 / s;
        a[i].first.y = 1.0 / r;
        a[i].second = i + 1;
    }
    int best = 0;
    for (int i = 1; i < n; ++i) {
        if (a[i].first.x < a[best].first.x || a[i].first.x == a[best].first.x && a[i].first.y < a[best].first.y) {
            best = i;
        }
    }
    long double x = a[best].first.x, y = a[best].first.y;
    //cerr << x << ' ' << y << endl;
    for (int i = 0; i < n; ++i) {
        a[i].first = a[i].first - point(x, y);
    }
    sort(a.begin(), a.end());
    //eprint(a);
    vector <pair <point, int> > ans;
    ans.pb(a[0]);
    ans.pb(a[1]);
    for (int i = 2; i < sz(a); ++i) {
        while (sz(ans) > 1 && (a[i].first - ans.back().first) <= (ans.back().first - ans[sz(ans) - 2].first)) {
            ans.pop_back();
        }
        ans.push_back(a[i]);
    }
    //eprint(ans);
    best = 0;
    for (int i = 1; i < sz(ans); ++i) {
        if (ans[i].first.y < ans[best].first.y || ans[i].first.y == ans[best].first.y && ans[i].first.x < ans[best].first.x)
            best = i;
    }
    vector <int> result;
    for (int i = 0; i <= best; ++i) {
        result.pb(ans[i].second);
    }
    Sort(result);
    for (int i = 0; i < sz(result); ++i) {
        cout << result[i] << ' ';
    }
    return 0;
}


#include <bits/stdc++.h>
using namespace std;

#define pb push_back
#define rs resize
#define mp make_pair
#define pi 3.1415926535897932384626433832795
#define sz(a) (int)(a).size()
#define Sort(a) sort((a).begin(), (a).end())
#define Reverse(a) reverse((a).begin(), (a).end())
#define sf scanf
#define pf printf
#define ms(a, x) memset((a), (x), sizeof(a))
typedef vector <int> vi;
typedef vector <vi> vvi;
typedef vector <vvi> vvvi;
typedef vector <vvvi> vvvvi;
typedef vector <bool> vb;
typedef vector <vb> vvb;
typedef vector <vvb> vvvb;
typedef vector <vvvb> vvvvb;
typedef long long ll;
typedef vector <ll> vl;
typedef vector <vl> vvl;
typedef vector <vvl> vvvl;
typedef vector <vvvl> vvvvl;
typedef pair <int, int> ii;
typedef vector <ii> vii;
typedef vector <vii> vvii;
typedef pair <int, ll> il;
typedef vector <il> vil;
typedef vector <vil> vvil;
typedef pair <ll, int> li;
typedef vector <li> vli;
typedef vector <vli> vvli;
typedef set <int> si;
typedef set <li> sli;
typedef set <il> sil;
typedef vector <string> vs;
typedef vector <vs> vvs;
typedef vector <vvs> vvvs;
typedef map <char, int> mci;
typedef pair <ll, ll> pll;
typedef vector <pll> vll;
typedef long double ld;

const ld eps = 1e-22;

struct point {
    ld x, y;

    point() {}
    point(ld x, ld y) : x(x), y(y) {}
};

ld operator &(point a, point b) {
    return a.x * b.y - a.y * b.x;
}

point operator +(point a, point b) {
    return point(a.x - b.x, a.y - b.y);
}

point operator -(point a, point b) {
    return point(a.x - b.x, a.y - b.y);
}

ld len(point a) {
    return a.x * a.x + a.y * a.y;
}

bool operator ==(point a, point b) {
    return fabs(a.x - b.x) < eps && fabs(a.y - b.y) < eps;
}

void eprint(vector <pair <point, int> > a) {
    for (auto x: a) {
        cerr << x.second << ' ';
    }
    cerr << endl;
}

int main() {
    //freopen("input.txt", "r", stdin);
    //freopen("output.txt", "w", stdout);
    int n;
    cin >> n;
    if (n == 1) {
        cout << 1 << endl;
        return 0;
    }
    vector <pair <point, int> > a(n);
    for (int i = 0; i < n; ++i) {
        int s, r;
        cin >> s >> r;
        a[i] = mp(point(1.0 / s, 1.0 / r), i + 1);
    }
    int best = 0;
    for (int i = 1; i < n; ++i) {
        if (a[i].first.x < a[best].first.x || fabs(a[i].first.x - a[best].first.x) < eps && a[i].first.y < a[best].first.y) {
            best = i;
        }
    }
    swap(a[0], a[best]);
    for (int i = 1; i < n; ++i) {
        a[i].first.x -= a[0].first.x;
        a[i].first.y -= a[0].first.y;
    }
    a[0].first = point(0.0, 0.0);
    sort(a.begin() + 1, a.end(), [](pair <point, int> A, pair <point, int> B) {
        auto a = A.first, b = B.first;
        ld mul = a & b;
        if (fabs(mul) < eps) {
            return len(a) < len(b);
        }
        return mul > 0;
    });
    //eprint(a);
    vector <pair <point, int> > c;
    c.pb(a[0]);
    for (int i = 1; i < n; ++i) {
        while (sz(c) > 1 && ((a[i].first - c.back().first) & (c.back().first - c[sz(c) - 2].first)) > 0) {
            c.pop_back();
        }
        c.push_back(a[i]);
    }
    //eprint(c);
    best = 0;
    for (int i = 0; i < n; ++i) {
        if (a[i].first.y < a[best].first.y || fabs(a[i].first.y - a[best].first.y) < eps && a[i].first.x < a[best].first.x || a[i].first == a[best].first) {
            best = i;
        }
    }
    vi result;
    for (int i = 0; i <= best; ++i) {
        result.pb(a[i].second);
    }
    Sort(result);
    for (int x: result) {
        cout << x << ' ';
    }
    cout << endl;
}


#include <bits/stdc++.h>
using namespace std;

#define pb push_back
#define rs resize
#define mp make_pair
#define pi 3.1415926535897932384626433832795
#define sz(a) (int)(a).size()
#define Sort(a) sort((a).begin(), (a).end())
#define Reverse(a) reverse((a).begin(), (a).end())
#define sf scanf
#define pf printf
#define ms(a, x) memset((a), (x), sizeof(a))
typedef vector <int> vi;
typedef vector <vi> vvi;
typedef vector <vvi> vvvi;
typedef vector <vvvi> vvvvi;
typedef vector <bool> vb;
typedef vector <vb> vvb;
typedef vector <vvb> vvvb;
typedef vector <vvvb> vvvvb;
typedef long long ll;
typedef vector <ll> vl;
typedef vector <vl> vvl;
typedef vector <vvl> vvvl;
typedef vector <vvvl> vvvvl;
typedef pair <int, int> ii;
typedef vector <ii> vii;
typedef vector <vii> vvii;
typedef pair <int, ll> il;
typedef vector <il> vil;
typedef vector <vil> vvil;
typedef pair <ll, int> li;
typedef vector <li> vli;
typedef vector <vli> vvli;
typedef set <int> si;
typedef set <li> sli;
typedef set <il> sil;
typedef vector <string> vs;
typedef vector <vs> vvs;
typedef vector <vvs> vvvs;
typedef map <char, int> mci;
typedef pair <ll, ll> pll;
typedef vector <pll> vll;

struct point {
    ll s, r, n;
};

bool check(point a, point b, point c) {
    return (b.s - a.s) * (b.r - c.r) * a.r * c.s > (b.r - a.r) * (b.s - c.s) * a.s * c.r;
}

point p;

bool check(point a, point b) {
    return check(a, p, b);
}

int main() {
    //freopen("input.txt", "r", stdin);
    //freopen("output.txt", "w", stdout);
    ios_base::sync_with_stdio(0);
    cin.tie(0);
    int n;
    cin >> n;
    if (n == 1) {
        cout << 1;
        return 0;
    }
    vector <point> a(n);
    for (int i = 0; i < n; ++i) {
        cin >> a[i].s >> a[i].r;
        a[i].n = i + 1;
    }
    int left = 0;
    for (int i = 1; i < n; ++i) {
        if (a[i].s > a[left].s || a[i].s == a[left].s && a[i].r > a[left].r) {
            left = i;
        }
    }
    swap(a[left], a[0]);
    p = a[0];
    sort(a.begin() + 1, a.end(), [](point a, point b) {
        return check(a, p, b);
    });
    vector <point> ans;
    ans.pb(a[0]);
    ans.pb(a[1]);
    for (int i = 2; i < n; ++i) {
        while (sz(ans) > 1 && check(a[i], ans[ans.size() - 2], ans.back())) {
            ans.pop_back();
        }
        ans.push_back(a[i]);
    }
    left = 0;
    for (int i = 0; i < sz(ans); ++i) {
        if (ans[i].r > ans[left].r || ans[i].r == ans[left].r && ans[i].s >= ans[left].s) {
            left = i;
        }
    }
    vi result;
    for (int i = 0; i <= left; ++i) {
        result.push_back(ans[i].n);
    }
    Sort(result);
    for (int i = 0; i < sz(result); ++i) {
        cout << result[i] << ' ';
    }
}


#include <bits/stdc++.h>
using namespace std;

#define pb push_back
#define rs resize
#define mp make_pair
#define pi 3.1415926535897932384626433832795
#define sz(a) (int)(a).size()
#define Sort(a) sort((a).begin(), (a).end())
#define Reverse(a) reverse((a).begin(), (a).end())
#define sf scanf
#define pf printf
#define ms(a, x) memset((a), (x), sizeof(a))
typedef vector <int> vi;
typedef vector <vi> vvi;
typedef vector <vvi> vvvi;
typedef vector <vvvi> vvvvi;
typedef vector <bool> vb;
typedef vector <vb> vvb;
typedef vector <vvb> vvvb;
typedef vector <vvvb> vvvvb;
typedef long long ll;
typedef vector <ll> vl;
typedef vector <vl> vvl;
typedef vector <vvl> vvvl;
typedef vector <vvvl> vvvvl;
typedef pair <int, int> ii;
typedef vector <ii> vii;
typedef vector <vii> vvii;
typedef pair <int, ll> il;
typedef vector <il> vil;
typedef vector <vil> vvil;
typedef pair <ll, int> li;
typedef vector <li> vli;
typedef vector <vli> vvli;
typedef set <int> si;
typedef set <li> sli;
typedef set <il> sil;
typedef vector <string> vs;
typedef vector <vs> vvs;
typedef vector <vvs> vvvs;
typedef map <char, int> mci;
typedef pair <ll, ll> pll;
typedef vector <pll> vll;
typedef long double ld;

const ld eps = 1e-22;

struct point {
    ld x, y;

    point() {}
    point(ld x, ld y) : x(x), y(y) {}
};

ld operator &(point a, point b) {
    return a.x * b.y - a.y * b.x;
}

point operator +(point a, point b) {
    return point(a.x - b.x, a.y - b.y);
}

point operator -(point a, point b) {
    return point(a.x - b.x, a.y - b.y);
}

ld len(point a) {
    return a.x * a.x + a.y * a.y;
}

bool operator ==(point a, point b) {
    return fabs(a.x - b.x) < eps && fabs(a.y - b.y) < eps;
}

void eprint(vector <pair <point, int> > a) {
    for (auto x: a) {
        cerr << x.second << ' ';
    }
    cerr << endl;
}

int main() {
    freopen("input.txt", "r", stdin);
    freopen("output.txt", "w", stdout);
    int n;
    cin >> n;
    if (n == 1) {
        cout << 1 << endl;
        return 0;
    }
    vector <pair <point, int> > a(n);
    for (int i = 0; i < n; ++i) {
        int s, r;
        cin >> s >> r;
        a[i] = mp(point(1.0 / s, 1.0 / r), i + 1);
    }
    int best = 0;
    for (int i = 1; i < n; ++i) {
        if (a[i].first.x < a[best].first.x || fabs(a[i].first.x - a[best].first.x) < eps && a[i].first.y < a[best].first.y) {
            best = i;
        }
    }
    swap(a[0], a[best]);
    for (int i = 1; i < n; ++i) {
        a[i].first.x -= a[0].first.x;
        a[i].first.y -= a[0].first.y;
    }
    a[0].first = point(0.0, 0.0);
    sort(a.begin() + 1, a.end(), [](pair <point, int> A, pair <point, int> B) {
        auto a = A.first, b = B.first;
        ld mul = a & b;
        if (fabs(mul) < eps) {
            return len(a) < len(b);
        }
        return mul > 0;
    });
    eprint(a);
    vector <pair <point, int> > c;
    c.pb(a[0]);
    for (int i = 1; i < n; ++i) {
        while (sz(c) > 1 && ((a[i].first - c.back().first) & (c.back().first - c[sz(c) - 2].first)) > eps) {
            c.pop_back();
        }
        c.push_back(a[i]);
    }
    eprint(c);
    best = 0;
    for (int i = 0; i < n; ++i) {
        if (a[i].first.y < a[best].first.y || fabs(a[i].first.y - a[best].first.y) < eps && a[i].first.x < a[best].first.x || a[i].first == a[best].first) {
            best = i;
        }
    }
    vi result;
    for (int i = 0; i <= best; ++i) {
        result.pb(a[i].second);
    }
    Sort(result);
    for (int x: result) {
        cout << x << ' ';
    }
    cout << endl;
}


#include <bits/stdc++.h>
using namespace std;

#define pb push_back
#define rs resize
#define mp make_pair
#define pi 3.1415926535897932384626433832795
#define sz(a) (int)(a).size()
#define Sort(a) sort((a).begin(), (a).end())
#define Reverse(a) reverse((a).begin(), (a).end())
#define sf scanf
#define pf printf
#define ms(a, x) memset((a), (x), sizeof(a))
typedef vector <int> vi;
typedef vector <vi> vvi;
typedef vector <vvi> vvvi;
typedef vector <vvvi> vvvvi;
typedef vector <bool> vb;
typedef vector <vb> vvb;
typedef vector <vvb> vvvb;
typedef vector <vvvb> vvvvb;
typedef long long ll;
typedef vector <ll> vl;
typedef vector <vl> vvl;
typedef vector <vvl> vvvl;
typedef vector <vvvl> vvvvl;
typedef pair <int, int> ii;
typedef vector <ii> vii;
typedef vector <vii> vvii;
typedef pair <int, ll> il;
typedef vector <il> vil;
typedef vector <vil> vvil;
typedef pair <ll, int> li;
typedef vector <li> vli;
typedef vector <vli> vvli;
typedef set <int> si;
typedef set <li> sli;
typedef set <il> sil;
typedef vector <string> vs;
typedef vector <vs> vvs;
typedef vector <vvs> vvvs;
typedef map <char, int> mci;
typedef pair <ll, ll> pll;
typedef vector <pll> vll;
typedef long double ld;

const ld eps = 1e-22;

struct point {
    ld x, y;

    point() {}
    point(ld x, ld y) : x(x), y(y) {}
};

ld operator &(point a, point b) {
    return a.x * b.y - a.y * b.x;
}

point operator +(point a, point b) {
    return point(a.x - b.x, a.y - b.y);
}

point operator -(point a, point b) {
    return point(a.x - b.x, a.y - b.y);
}

ld len(point a) {
    return a.x * a.x + a.y * a.y;
}

bool operator ==(point a, point b) {
    return fabs(a.x - b.x) < eps && fabs(a.y - b.y) < eps;
}

void eprint(vector <pair <point, int> > a) {
    for (auto x: a) {
        cerr << x.second << ' ';
    }
    cerr << endl;
}

int main() {
    //freopen("input.txt", "r", stdin);
    //freopen("output.txt", "w", stdout);
    int n;
    cin >> n;
    if (n == 1) {
        cout << 1 << endl;
        return 0;
    }
    vector <pair <point, int> > a(n);
    for (int i = 0; i < n; ++i) {
        int s, r;
        cin >> s >> r;
        a[i] = mp(point(1.0 / s, 1.0 / r), i + 1);
    }
    int best = 0;
    for (int i = 1; i < n; ++i) {
        if (a[i].first.x < a[best].first.x || fabs(a[i].first.x - a[best].first.x) < eps && a[i].first.y < a[best].first.y) {
            best = i;
        }
    }
    swap(a[0], a[best]);
    for (int i = 1; i < n; ++i) {
        a[i].first.x -= a[0].first.x;
        a[i].first.y -= a[0].first.y;
    }
    a[0].first = point(0.0, 0.0);
    sort(a.begin() + 1, a.end(), [](pair <point, int> A, pair <point, int> B) {
        auto a = A.first, b = B.first;
        ld mul = a & b;
        if (fabs(mul) < eps) {
            return len(a) < len(b);
        }
        return mul > 0;
    });
    //eprint(a);
    vector <pair <point, int> > c;
    c.pb(a[0]);
    for (int i = 1; i < n; ++i) {
        while (sz(c) > 1 && ((a[i].first - c.back().first) & (c.back().first - c[sz(c) - 2].first)) > eps) {
            c.pop_back();
        }
        c.push_back(a[i]);
    }
    //eprint(c);
    best = 0;
    for (int i = 0; i < n; ++i) {
        if (a[i].first.y < a[best].first.y || fabs(a[i].first.y - a[best].first.y) < eps && a[i].first.x < a[best].first.x || a[i].first == a[best].first) {
            best = i;
        }
    }
    vi result;
    for (int i = 0; i <= best; ++i) {
        result.pb(a[i].second);
    }
    Sort(result);
    for (int x: result) {
        cout << x << ' ';
    }
    cout << endl;
}


#include <bits/stdc++.h>
using namespace std;

#define pb push_back
#define rs resize
#define mp make_pair
#define pi 3.1415926535897932384626433832795
#define sz(a) (int)(a).size()
#define Sort(a) sort((a).begin(), (a).end())
#define Reverse(a) reverse((a).begin(), (a).end())
#define sf scanf
#define pf printf
#define ms(a, x) memset((a), (x), sizeof(a))
typedef vector <int> vi;
typedef vector <vi> vvi;
typedef vector <vvi> vvvi;
typedef vector <vvvi> vvvvi;
typedef vector <bool> vb;
typedef vector <vb> vvb;
typedef vector <vvb> vvvb;
typedef vector <vvvb> vvvvb;
typedef long long ll;
typedef vector <ll> vl;
typedef vector <vl> vvl;
typedef vector <vvl> vvvl;
typedef vector <vvvl> vvvvl;
typedef pair <int, int> ii;
typedef vector <ii> vii;
typedef vector <vii> vvii;
typedef pair <int, ll> il;
typedef vector <il> vil;
typedef vector <vil> vvil;
typedef pair <ll, int> li;
typedef vector <li> vli;
typedef vector <vli> vvli;
typedef set <int> si;
typedef set <li> sli;
typedef set <il> sil;
typedef vector <string> vs;
typedef vector <vs> vvs;
typedef vector <vvs> vvvs;
typedef map <char, int> mci;
typedef pair <ll, ll> pll;
typedef vector <pll> vll;

ll gcd(ll a, ll b) {
    return b != 0 ? gcd(b, a % b) : a;
}

struct Rational {
    ll a, b;

    Rational() {}
    Rational(ll a, ll b = 1) : a(a), b(b) {
        ll d = gcd(abs(a), abs(b));
        this->a /= d;
        this->b /= d;
        if (this->b < 0) {
            this->a *= -1;
            this->b *= -1;
        }
    }

    Rational operator +(Rational other) {
        return Rational(a * other.b + b * other.a, b * other.b);
    }

    Rational operator -(Rational other) {
        return Rational(a * other.b - b * other.a, b * other.b);
    }

    Rational operator *(Rational other) {
        return Rational(a * other.a, b * other.b);
    }

    Rational operator /(Rational other) {
        return Rational(a * other.b, b * other.a);
    }

    bool operator <(Rational other) {
        return a * other.b < b * other.a;
    }

    bool operator >(Rational other) {
        return a * other.b > b * other.a;
    }

    bool operator ==(Rational other) {
        return a * other.b == b * other.a;
    }
};

ostream& operator <<(ostream& out, Rational a) {
    out << a.a << '/' << a.b;
    return out;
}

struct point {
    long double x, y;

    point() {}
    point(long double x, long double y) : x(x), y(y) {}

    point operator -(point b) {
        return point(x - b.x, y - b.y);
    }

    point operator +(point b) {
        return point(x + b.x, y + b.y);
    }

    double operator &(point b) {
        return x * b.y - y * b.x;
    }
};

const long double eps = 1e-22;

bool operator <(point a, point b) {
    /*cerr.precision(22);
    cerr << fixed;
    cerr << endl;
    cerr << a.x * b.y - a.y * b.x << endl;
    cerr << fabs(a.x * b.y - a.y * b.x) << endl;
    cerr << a.x * a.x + a.y * a.y << ' ' << b.x * b.x + b.y * b.y << endl;
    cerr << endl;*/
    return a.x * b.y - a.y * b.x > eps || fabs(a.x * b.y - a.y * b.x) < eps && a.x * a.x + a.y * a.y < b.x * b.x + b.y * b.y;
}

bool operator ==(point a, point b) {
    /*cerr.precision(22);
    cerr << fixed;
    cerr << endl;
    cerr << fabs(a.x - b.x) << ' ' << fabs(a.y - b.y) << endl;
    cerr << endl;*/
    return fabs(a.x - b.x) < eps && fabs(a.y - b.y) < eps;
}

bool operator <=(point a, point b) {
    return a < b || b == a;
}

ostream& operator <<(ostream& out, point a) {
    out << a.x << ' ' << a.y << endl;
    return out;
}

void eprint(vector <pair <point, int> > a) {
    cerr << endl;
    for (auto x: a) {
        cerr << x.second << ' ' << x.first;
    }
    cerr << endl;
}

int main() {
    //freopen("input.txt", "r", stdin);
    //freopen("output.txt", "w", stdout);
    ios_base::sync_with_stdio(0);
    cin.tie(0);
    int n;
    cin >> n;
    vector <pair <point, int> > a(n);
    for (int i = 0; i < n; ++i) {
        int s, r;
        cin >> s >> r;
        a[i].first.x = 1.0 / s;
        a[i].first.y = 1.0 / r;
        a[i].second = i + 1;
    }
    int best = 0;
    for (int i = 1; i < n; ++i) {
        if (a[i].first.x < a[best].first.x || a[i].first.x == a[best].first.x && a[i].first.y < a[best].first.y) {
            best = i;
        }
    }
    long double x = a[best].first.x, y = a[best].first.y;
    //cerr << x << ' ' << y << endl;
    for (int i = 0; i < n; ++i) {
        a[i].first = a[i].first - point(x, y);
    }
    sort(a.begin(), a.end());
    //eprint(a);
    vector <pair <point, int> > ans;
    ans.pb(a[0]);
    ans.pb(a[1]);
    for (int i = 2; i < sz(a); ++i) {
        while (sz(ans) > 1 && (a[i].first - ans.back().first) < (ans.back().first - ans[sz(ans) - 2].first)) {
            ans.pop_back();
        }
        ans.push_back(a[i]);
    }
    //eprint(ans);
    best = 0;
    for (int i = 1; i < sz(ans); ++i) {
        if (ans[i].first.y < ans[best].first.y || ans[i].first.y == ans[best].first.y && ans[i].first.x < ans[best].first.x)
            best = i;
    }
    vector <int> result;
    for (int i = 0; i <= best; ++i) {
        result.pb(ans[i].second);
    }
    for (int i = 0; i < n; ++i) {
        if (a[i].first == ans[0].first || a[i].first == ans[best].first)
            result.pb(a[i].second);
    }
    Sort(result);
    for (int i = 0; i < sz(result); ++i) {
        if (i == 0 || result[i] != result[i - 1]) {
            cout << result[i] << ' ';
        }
    }
    return 0;
}