#include <bits/stdc++.h>

using namespace std;

typedef long long ll;
typedef pair <int , int> pii;

const int N = 2e5+10 , mod = 1e9+7;

vector <pii> v;
set <pii> s;

bool bet(pii x , pii y){
   if(x.first >= y.first && x.second >= y.second)
      return true;
   return false;
}

double check(pii x , pii y){
   if(x.second == y.second)
      return mod;
   return double(x.first - y.first) / double(y.second - x.second);
}

int xx[N] , yy[N];

int main(){
   ios_base::sync_with_stdio(false); cin.tie(0); cout.tie(0);
   int n;
   cin >> n;
   for(int i = 1 ; i <= n ; i++){
      int r , s;
      cin >> r >> s;
      xx[i] = r , yy[i] = s;
      v.push_back({r , s});
   }
   sort(v.begin() , v.end());
   for(int i = 0 ; i < n ; i++){
      auto x = v[i];
      while(s.size() && bet(x , *s.rbegin()))
         s.erase(*s.rbegin());
      while(s.size() > 2){
         auto it = s.end();
         it--;
         auto it2 = it;
         it2--;
         if(check(x , *it2) > check(*it , *it2))
            s.erase(*it);
      }
      s.insert(x);
   }
   for(int i = 1 ; i <= n ; i++)
      if(s.find({xx[i] , yy[i]}) != s.end())
         cout << i << " ";
   return 0;
}


#include <bits/stdc++.h>

using namespace std;

typedef long long ll;
typedef pair <int , int> pii;

const int N = 2e5+10 , mod = 1e9+7;

vector <pii> v;
set <pii> s;

inline bool bet(pii x , pii y){
   if(x.first >= y.first && x.second >= y.second)
      return true;
   return false;
}

inline double check(pii x , pii y){
   return double(x.first - y.first) / double(y.second - x.second);
}

int xx[N] , yy[N];

int main(){
   ios_base::sync_with_stdio(false); cin.tie(0); cout.tie(0);
   int n;
   scanf("%d" , &n);
   for(int i = 1 ; i <= n ; i++){
      int r , s;
      scanf("%d%d" , &r , &s);
      xx[i] = r , yy[i] = s;
      v.push_back({r , s});
   }
   sort(v.begin() , v.end());
   v.resize(unique(v.begin() , v.end()) - v.begin());
   for(int i = 0 ; i < v.size() ; i++){
      auto x = v[i];
      while(s.size() && bet(x , *s.rbegin()))
         s.erase(*s.rbegin());
      while(s.size() >= 2){
         auto it = s.end();
         it--;
         auto it2 = it;
         it2--;
         if(check(x , *it) >= check(*it , *it2))
            s.erase(*it);
         else
            break;
      }
      s.insert(x);
   }
   for(int i = 1 ; i <= n ; i++)
      if(s.find({xx[i] , yy[i]}) != s.end())
         printf("%d " , i);
   return 0;
}


#include <bits/stdc++.h>

using namespace std;

typedef long long ll;
typedef pair <int , int> pii;

const int N = 2e5+10 , mod = 1e9+7;

vector <pii> v;
set <pii> s;

inline bool bet(pii x , pii y){
   if(x.first >= y.first && x.second >= y.second)
      return true;
   return false;
}

inline double check(pii x , pii y){
   return double(x.first - y.first) / double(y.second - x.second);
}

int xx[N] , yy[N];

int main(){
   ios_base::sync_with_stdio(false); cin.tie(0); cout.tie(0);
   int n;
   scanf("%d" , &n);
   for(int i = 1 ; i <= n ; i++){
      int r , s;
      scanf("%d%d" , &r , &s);
      xx[i] = r , yy[i] = s;
      v.push_back({r , s});
   }
   sort(v.begin() , v.end());
   v.resize(unique(v.begin() , v.end()) - v.begin());
   for(int i = 0 ; i < v.size() ; i++){
      auto x = v[i];
      while(s.size() && bet(x , *s.rbegin()))
         s.erase(*s.rbegin());
      while(s.size() > 2){
         auto it = s.end();
         it--;
         auto it2 = it;
         it2--;
         if(check(x , *it2) > check(*it , *it2))
            s.erase(*it);
         else
            break;
      }
      s.insert(x);
   }
   for(int i = 1 ; i <= n ; i++)
      if(s.find({xx[i] , yy[i]}) != s.end())
         printf("%d " , i);
   return 0;
}


#include <bits/stdc++.h>

using namespace std;

typedef long long ll;
typedef pair <int , int> pii;

const int N = 2e5+10 , mod = 1e9+7;

vector <pii> v;
set <pii> s;

inline bool bet(pii x , pii y){
   if(x.first >= y.first && x.second >= y.second)
      return true;
   return false;
}

inline double check(pii x , pii y){
   if(x.second == y.second)
      return mod;
   return double(x.first - y.first) / double(y.second - x.second);
}

int xx[N] , yy[N];

int main(){
   ios_base::sync_with_stdio(false); cin.tie(0); cout.tie(0);
   int n;
   scanf("%d" , &n);
   for(int i = 1 ; i <= n ; i++){
      int r , s;
      scanf("%d%d" , &r , &s);
      xx[i] = r , yy[i] = s;
      v.push_back({r , s});
   }
   sort(v.begin() , v.end());
   for(int i = 0 ; i < n ; i++){
      auto x = v[i];
      while(s.size() && bet(x , *s.rbegin()))
         s.erase(*s.rbegin());
      while(s.size() > 2){
         auto it = s.end();
         it--;
         auto it2 = it;
         it2--;
         if(check(x , *it2) > check(*it , *it2))
            s.erase(*it);
         else
            break;
      }
      s.insert(x);
   }
   for(int i = 1 ; i <= n ; i++)
      if(s.find({xx[i] , yy[i]}) != s.end())
         printf("%d " , i);
   return 0;
}


#include <bits/stdc++.h>

using namespace std;

typedef long long ll;
typedef pair <int , int> pii;

const int N = 2e5+10 , mod = 1e9+7;

vector <pii> v;
set <pii> s;

inline bool bet(pii x , pii y){
   if(x.first >= y.first && x.second >= y.second)
      return true;
   return false;
}

inline double check(pii x , pii y){
   return double(x.first) * double(y.first * x.second - y.first * y.second) / double(x.second) / double(y.first * y.second - y.second * x.first);
}

int xx[N] , yy[N];

int main(){
   ios_base::sync_with_stdio(false); cin.tie(0); cout.tie(0);
   int n;
   scanf("%d" , &n);
   for(int i = 1 ; i <= n ; i++){
      int r , s;
      scanf("%d%d" , &r , &s);
      xx[i] = r , yy[i] = s;
      v.push_back({r , s});
   }
   sort(v.begin() , v.end());
   v.resize(unique(v.begin() , v.end()) - v.begin());
   for(int i = 0 ; i < v.size() ; i++){
      auto x = v[i];
      while(s.size() && bet(x , *s.rbegin()))
         s.erase(*s.rbegin());
      while(s.size() >= 2){
         auto it = s.end();
         it--;
         auto it2 = it;
         it2--;
         if(check(x , *it) > check(*it , *it2))
            s.erase(*it);
         else
            break;
      }
      s.insert(x);
   }
   for(int i = 1 ; i <= n ; i++)
      if(s.find({xx[i] , yy[i]}) != s.end())
         printf("%d " , i);
   return 0;
}


#include <bits/stdc++.h>

using namespace std;

typedef long long ll;
typedef pair <int , int> pii;

const int N = 2e5+10 , mod = 1e9+7;

vector <pii> v;
set <pii> s;

inline bool bet(pii x , pii y){
   if(x.first >= y.first && x.second >= y.second)
      return true;
   return false;
}

inline double check(pii x , pii y){
   if(x.second == y.second)
      return mod;
   return double(x.first - y.first) / double(y.second - x.second);
}

int xx[N] , yy[N];

int main(){
   ios_base::sync_with_stdio(false); cin.tie(0); cout.tie(0);
   int n;
   scanf("%d" , &n);
   for(int i = 1 ; i <= n ; i++){
      int r , s;
      scanf("%d%d" , &r , &s);
      xx[i] = r , yy[i] = s;
      v.push_back({r , s});
   }
   sort(v.begin() , v.end());
   for(int i = 0 ; i < n ; i++){
      auto x = v[i];
      while(s.size() && bet(x , *s.rbegin()))
         s.erase(*s.rbegin());
      while(s.size() > 2){
         auto it = s.end();
         it--;
         auto it2 = it;
         it2--;
         if(check(x , *it2) > check(*it , *it2))
            s.erase(*it);
      }
      s.insert(x);
   }
   for(int i = 1 ; i <= n ; i++)
      if(s.find({xx[i] , yy[i]}) != s.end())
         printf("%d " , i);
   return 0;
}


#include <bits/stdc++.h>

using namespace std;

typedef long long ll;
typedef pair <int , int> pii;

const int N = 2e5+10 , mod = 1e9+7;

vector <pii> v;
set <pii> s;

inline bool bet(pii x , pii y){
   if(x.first >= y.first && x.second >= y.second)
      return true;
   return false;
}

inline double check(pii x , pii y){
   return double(x.first - y.first) / double(y.second - x.second);
}

int xx[N] , yy[N];

int main(){
   ios_base::sync_with_stdio(false); cin.tie(0); cout.tie(0);
   int n;
   scanf("%d" , &n);
   for(int i = 1 ; i <= n ; i++){
      int r , s;
      scanf("%d%d" , &r , &s);
      xx[i] = r , yy[i] = s;
      v.push_back({r , s});
   }
   sort(v.begin() , v.end());
   v.resize(unique(v.begin() , v.end()) - v.begin());
   for(int i = 0 ; i < v.size() ; i++){
      auto x = v[i];
      while(s.size() && bet(x , *s.rbegin()))
         s.erase(*s.rbegin());
      while(s.size() > 2){
         auto it = s.end();
         it--;
         auto it2 = it;
         it2--;
         if(check(x , *it) >= check(*it , *it2))
            s.erase(*it);
         else
            break;
      }
      s.insert(x);
   }
   for(int i = 1 ; i <= n ; i++)
      if(s.find({xx[i] , yy[i]}) != s.end())
         printf("%d " , i);
   return 0;
}


#include <bits/stdc++.h>

using namespace std;

typedef long long ll;
typedef pair <int , int> pii;

const int N = 2e5+10 , mod = 1e9+7;

vector <pii> v;
set <pii> s;

inline bool bet(pii x , pii y){
   if(x.first >= y.first && x.second >= y.second)
      return true;
   return false;
}

inline double check(pii x , pii y){
   return double(x.first - y.first) / double(y.second - x.second);
}

int xx[N] , yy[N];

int main(){
   ios_base::sync_with_stdio(false); cin.tie(0); cout.tie(0);
   int n;
   scanf("%d" , &n);
   for(int i = 1 ; i <= n ; i++){
      int r , s;
      scanf("%d%d" , &r , &s);
      xx[i] = r , yy[i] = s;
      v.push_back({r , s});
   }
   sort(v.begin() , v.end());
   v.resize(unique(v.begin() , v.end()) - v.begin());
   for(int i = 0 ; i < v.size() ; i++){
      auto x = v[i];
      while(s.size() && bet(x , *s.rbegin()))
         s.erase(*s.rbegin());
      while(s.size() >= 2){
         auto it = s.end();
         it--;
         auto it2 = it;
         it2--;
         if(check(x , *it) > check(*it , *it2))
            s.erase(*it);
         else
            break;
      }
      s.insert(x);
   }
   for(int i = 1 ; i <= n ; i++)
      if(s.find({xx[i] , yy[i]}) != s.end())
         printf("%d " , i);
   return 0;
}


#include <bits/stdc++.h>

using namespace std;

typedef long long ll;
typedef pair <int , int> pii;

const int N = 2e5+10 , mod = 1e9+7;

vector <pii> v;
set <pii> s;

inline bool bet(pii x , pii y){
   if(x.first >= y.first && x.second >= y.second)
      return true;
   return false;
}

inline double check(pii x , pii y){
   return double(x.first) * double(y.first * x.second - y.first * y.second) / double(x.second) / double(y.first * y.second - y.second * x.first);
}

int xx[N] , yy[N];

int main(){
   ios_base::sync_with_stdio(false); cin.tie(0); cout.tie(0);
   int n;
   scanf("%d" , &n);
   for(int i = 1 ; i <= n ; i++){
      int r , s;
      scanf("%d%d" , &r , &s);
      xx[i] = r , yy[i] = s;
      v.push_back({r , s});
   }
   sort(v.begin() , v.end());
   v.resize(unique(v.begin() , v.end()) - v.begin());
   for(int i = 0 ; i < v.size() ; i++){
      auto x = v[i];
      while(s.size() && bet(x , *s.rbegin()))
         s.erase(*s.rbegin());
      while(s.size() >= 2){
         auto it = s.end();
         it--;
         auto it2 = it;
         it2--;
         if(check(x , *it) < check(*it , *it2))
            s.erase(*it);
         else
            break;
      }
      s.insert(x);
   }
   for(int i = 1 ; i <= n ; i++)
      if(s.find({xx[i] , yy[i]}) != s.end())
         printf("%d " , i);
   return 0;
}


#include<bits/stdc++.h>
#define pii pair<db,db>
#define fi first
#define db double
#define se second
#define ll db
using namespace std;
pair<int,pair<int,int> > v [ 200002 ] ;
bool vis [ 200002 ] ;
struct Hull {
	deque<pii > v; deque <int> id ;
	db cross( pii l1, pii l2 ){ return db( l2.se - l1.se ) / db( l1.fi - l2.fi ) ; }
	void Insert ( ll m , ll b , int _id ) {
		pii line = make_pair(m,b);
		while ((int)v.size() > 1 && cross ( line , v.back() ) < cross ( v.back() , v[v.size()-2] ) -1e6 ) v.pop_back(), id.pop_back();
    v.push_back(line);
		id.push_back(_id);
	}
	void solve(){
		sort(id.begin(),id.end());
		for ( int i = 0 ; i < (int)id.size() ; i++ ) printf("%d ", id[i]);
		printf("\n");
	}
};
int main(){
	int n , rr ;
	scanf("%d", &n );
	for ( int i = 0 ; i < n ; i ++ ) scanf("%d%d", &v[i].fi , &v[i].se.fi) , v[i].se.se = i + 1 ;
	sort ( v , v + n ) ; rr = n - 1 ;
	Hull G ;
	vis [ rr ] = 1 ;
	for ( int i = n - 2 ; i >= 0 ; i -- ) if ( v[i].se.fi > v[rr].se.fi || (v[i].fi == v[rr].fi && v[i].se.fi == v[rr].se.fi )) vis [ i ] = 1 , rr = i ;
	for ( int i = 0 ; i < n ; i ++ ){
		if ( vis[i] ) {
			G.Insert ( db(v[i].se.fi - v[i].fi) / db (v[i].se.fi*v[i].fi), 1e6/db(v[i].se.fi), v[i].se.se ) ;
		}
	}
	G.solve();
}


#include<bits/stdc++.h>
#define pii pair<db,db>
#define fi first
#define db double
#define se second
#define ll db
using namespace std;
pair<int,pair<int,int> > v [ 200002 ] ;
bool vis [ 200002 ] ;
struct Hull {
	deque<pii > v; deque <int> id ;
	db cross( pii l1, pii l2 ){ return db( l2.se - l1.se ) / db( l1.fi - l2.fi ) ; }
	void Insert ( ll m , ll b , int _id ) {
		pii line = make_pair(m,b);
		while ((int)v.size() > 1 && cross ( line , v.back() ) < cross ( v.back() , v[v.size()-2] ) -1e9 ) v.pop_back(), id.pop_back();
    v.push_back(line);
		id.push_back(_id);
	}
	void solve(){
		sort(id.begin(),id.end());
		for ( int i = 0 ; i < (int)id.size() ; i++ ) printf("%d ", id[i]);
		printf("\n");
	}
};
int main(){
	int n , rr ;
	scanf("%d", &n );
	for ( int i = 0 ; i < n ; i ++ ) scanf("%d%d", &v[i].fi , &v[i].se.fi) , v[i].se.se = i + 1 ;
	sort ( v , v + n ) ; rr = n - 1 ;
	Hull G ;
	vis [ rr ] = 1 ;
	for ( int i = n - 2 ; i >= 0 ; i -- ) if ( v[i].se.fi > v[rr].se.fi || (v[i].fi == v[rr].fi && v[i].se.fi == v[rr].se.fi )) vis [ i ] = 1 , rr = i ;
	for ( int i = 0 ; i < n ; i ++ ){
		if ( vis[i] ) {
			G.Insert ( db(v[i].se.fi - v[i].fi) / db (v[i].se.fi*v[i].fi), 1e6/db(v[i].se.fi), v[i].se.se ) ;
		}
	}
	G.solve();
}


#include<bits/stdc++.h>
#define pii pair<db,db>
#define fi first
#define db double
#define se second
#define ll db
using namespace std;
pair<int,pair<int,int> > v [ 200002 ] ;
bool vis [ 200002 ] ;
struct Hull {
	deque<pii > v; deque <int> id ;deque<int> id2 ;
	db cross( pii l1, pii l2 ){ return db( l2.se - l1.se ) / db( l1.fi - l2.fi ) ; }
	void Insert ( ll m , ll b , int _id , int id2_) {
		pii line = make_pair(m,b);
		while ((int)v.size() > 1 && cross ( line , v.back() ) <= cross ( v.back() , v[v.size()-2] )  ) v.pop_back(), id.pop_back(),id2.pop_back() ;
    v.push_back(line);
		id.push_back(_id);
		id2.push_back(id2_);
	}
	void solve(){
		sort(id.begin(),id.end());
		for ( int i = 0 ; i < (int)id.size() ; i++ ) printf("%d ", id[i]);
		printf("\n");
	}
	void add ( int x ) {
		id.push_back(x);
	}
};
int main(){
	int n , rr ;
	scanf("%d", &n );
	for ( int i = 0 ; i < n ; i ++ ) scanf("%d%d", &v[i].fi , &v[i].se.fi) , v[i].se.se = i + 1 ;
	sort ( v , v + n ) ; rr = n - 1 ;
	Hull G ;
	vis [ rr ] = 1 ;
	for ( int i = n - 2 ; i >= 0 ; i -- ) if ( v[i].se.fi > v[rr].se.fi ) vis [ i ] = 1 , rr = i ;
	for ( int i = 0 ; i < n ; i ++ ){
		if ( vis[i] ) {
			G.Insert ( db(v[i].se.fi - v[i].fi) / db (v[i].se.fi*v[i].fi), 1e6/db(v[i].se.fi), v[i].se.se, i ) ;
		}
	}
	for ( int i = 0 ; i < G.id2.size(); i ++ ) {
		int j = G.id2[i]- 1 , k = j + 1 ;
		while ( j >= 0 && v[j].se.fi == v[k].se.fi && v[j].fi == v[k].fi ) G.add(j+ 1), j -- ;
	}
	G.solve();
}


#include<bits/stdc++.h>
#define pii pair<db,db>
#define fi first
#define db double
#define se second
#define ll db
using namespace std;
pair<int,pair<int,int> > v [ 200002 ] ;
bool vis [ 200002 ] ;
struct Hull {
	deque<pii > v; deque <int> id ;
	db cross( pii l1, pii l2 ){ return db( l2.se - l1.se ) / db( l1.fi - l2.fi ) ; }
	void Insert ( ll m , ll b , int _id ) {
		pii line = make_pair(m,b);
		while ((int)v.size() > 1 && cross ( line , v.back() ) <= cross ( v.back() , v[v.size()-2] ) ) v.pop_back(), id.pop_back();
    v.push_back(line);
		id.push_back(_id);
	}
	void solve(){
		sort(id.begin(),id.end());
		for ( int i = 0 ; i < (int)id.size() ; i++ ) printf("%d ", id[i]);
		printf("\n");
	}
};
int main(){
	int n , rr ;
	scanf("%d", &n );
	for ( int i = 0 ; i < n ; i ++ ) scanf("%d%d", &v[i].fi , &v[i].se.fi) , v[i].se.se = i + 1 ;
	sort ( v , v + n ) ; rr = n - 1 ;
	Hull G ;
	vis [ rr ] = 1 ;
	for ( int i = n - 2 ; i >= 0 ; i -- ) if ( v[i].se.fi > v[rr].se.fi || (v[i].fi == v[rr].fi && v[i].se.fi == v[rr].se.fi )) vis [ i ] = 1 , rr = i ;
	for ( int i = 0 ; i < n ; i ++ ){
		if ( vis[i] ) {
			G.Insert ( db(v[i].se.fi - v[i].fi) / db (v[i].se.fi*v[i].fi), 1e6/db(v[i].se.fi), v[i].se.se ) ;
		}
	}
	G.solve();
}


#include<bits/stdc++.h>
#define pii pair<db,db>
#define fi first
#define db double
#define se second
#define ll db
using namespace std;
pair<int,pair<int,int> > v [ 200002 ] ;
bool vis [ 200002 ] ;
struct Hull {
	deque<pii > v; deque <int> id ;
	db cross( pii l1, pii l2 ){ return db( l2.se - l1.se ) / db( l1.fi - l2.fi ) ; }
	void Insert ( ll m , ll b , int _id ) {
		pii line = make_pair(m,b);
		while ((int)v.size() > 1 && cross ( line , v.back() ) <= cross ( v.back() , v[v.size()-2] ) ) v.pop_back(), id.pop_back();
    v.push_back(line);
		id.push_back(_id);
	}
	void solve(){
		sort(id.begin(),id.end());
		for ( int i = 0 ; i < (int)id.size() ; i++ ) printf("%d ", id[i]);
		printf("\n");
	}
};
int main(){
	int n , rr ;
	scanf("%d", &n );
	for ( int i = 0 ; i < n ; i ++ ) scanf("%d%d", &v[i].fi , &v[i].se.fi) , v[i].se.se = i + 1 ;
	sort ( v , v + n ) ; rr = n - 1 ;
	Hull G ;
	vis [ rr ] = 1 ;
	for ( int i = n - 2 ; i >= 0 ; i -- ) if ( v[i].se.fi >= v[rr].se.fi ) vis [ i ] = 1 , rr = i ;
	for ( int i = 0 ; i < n ; i ++ ){
		if ( vis[i] ) {
			G.Insert ( db(v[i].se.fi - v[i].fi) / db (v[i].se.fi*v[i].fi), 1e6/db(v[i].se.fi), v[i].se.se ) ;
		}
	}
	G.solve();
}


#include<bits/stdc++.h>
#define pii pair<db,db>
#define fi first
#define db double
#define se second
#define ll db
using namespace std;
pair<int,pair<int,int> > v [ 200002 ] ;
bool vis [ 200002 ] ;
struct Hull {
	deque<pii > v; deque <int> id ;
	db cross( pii l1, pii l2 ){ return db( l2.se - l1.se ) / db( l1.fi - l2.fi ) ; }
	void Insert ( ll m , ll b , int _id ) {
		pii line = make_pair(m,b);
		while ((int)v.size() > 1 && cross ( line , v.back() ) <= cross ( v.back() , v[v.size()-2] ) ) v.pop_back(), id.pop_back();
    v.push_back(line);
		id.push_back(_id);
	}
	void solve(){
		sort(id.begin(),id.end());
		for ( int i = 0 ; i < (int)id.size() ; i++ ) printf("%d ", id[i]);
		printf("\n");
	}
};
int main(){
	int n , rr ;
	scanf("%d", &n );
	for ( int i = 0 ; i < n ; i ++ ) scanf("%d%d", &v[i].fi , &v[i].se.fi) , v[i].se.se = i + 1 ;
	sort ( v , v + n ) ; rr = n - 1 ;
	Hull G ;
	vis [ rr ] = 1 ;
	for ( int i = n - 2 ; i >= 0 ; i -- ) if ( v[i].se.fi > v[rr].se.fi ) vis [ i ] = 1 , rr = i ;
	for ( int i = 0 ; i < n ; i ++ ){
		if ( vis[i] ) {
			G.Insert ( db(v[i].se.fi - v[i].fi) / db (v[i].se.fi*v[i].fi), 1e6/db(v[i].se.fi), v[i].se.se ) ;
		}
	}
	G.solve();
}


#include<bits/stdc++.h>
#define pii pair<db,db>
#define fi first
#define db double
#define se second
#define ll db
using namespace std;
pair<int,pair<int,int> > v [ 200002 ] ;
bool vis [ 200002 ] ;
struct Hull {
	deque<pii > v; deque <int> id ;
	db cross( pii l1, pii l2 ){ return db( l2.se - l1.se ) / db( l1.fi - l2.fi ) ; }
	void Insert ( ll m , ll b , int _id ) {
		pii line = make_pair(m,b);
		while ((int)v.size() > 1 && cross ( line , v.back() ) <= cross ( v.back() , v[v.size()-2] ) -1e-10 ) v.pop_back(), id.pop_back();
    v.push_back(line);
		id.push_back(_id);
	}
	void solve(){
		sort(id.begin(),id.end());
		for ( int i = 0 ; i < (int)id.size() ; i++ ) printf("%d ", id[i]);
		printf("\n");
	}
};
int main(){
	int n , rr ;
	scanf("%d", &n );
	for ( int i = 0 ; i < n ; i ++ ) scanf("%d%d", &v[i].fi , &v[i].se.fi) , v[i].se.se = i + 1 ;
	sort ( v , v + n ) ; rr = n - 1 ;
	Hull G ;
	vis [ rr ] = 1 ;
	for ( int i = n - 2 ; i >= 0 ; i -- ) if ( v[i].se.fi > v[rr].se.fi || (v[i].fi == v[rr].fi && v[i].se.fi == v[rr].se.fi )) vis [ i ] = 1 , rr = i ;
	for ( int i = 0 ; i < n ; i ++ ){
		if ( vis[i] ) {
			G.Insert ( db(v[i].se.fi - v[i].fi) / db (v[i].se.fi*v[i].fi), 1e6/db(v[i].se.fi), v[i].se.se ) ;
		}
	}
	G.solve();
}


#include<bits/stdc++.h>
#define pii pair<db,db>
#define fi first
#define db double
#define se second
#define ll db
using namespace std;
pair<int,pair<int,int> > v [ 200002 ] ;
bool vis [ 200002 ] ;
struct Hull {
	deque<pii > v; deque <int> id ;
	db cross( pii l1, pii l2 ){ return db( l2.se - l1.se ) / db( l1.fi - l2.fi ) ; }
	void Insert ( ll m , ll b , int _id ) {
		pii line = make_pair(m,b);
		while ((int)v.size() > 1 && cross ( line , v.back() ) <= cross ( v.back() , v[v.size()-2] ) -1e10 ) v.pop_back(), id.pop_back();
    v.push_back(line);
		id.push_back(_id);
	}
	void solve(){
		sort(id.begin(),id.end());
		for ( int i = 0 ; i < (int)id.size() ; i++ ) printf("%d ", id[i]);
		printf("\n");
	}
};
int main(){
	int n , rr ;
	scanf("%d", &n );
	for ( int i = 0 ; i < n ; i ++ ) scanf("%d%d", &v[i].fi , &v[i].se.fi) , v[i].se.se = i + 1 ;
	sort ( v , v + n ) ; rr = n - 1 ;
	Hull G ;
	vis [ rr ] = 1 ;
	for ( int i = n - 2 ; i >= 0 ; i -- ) if ( v[i].se.fi > v[rr].se.fi || (v[i].fi == v[rr].fi && v[i].se.fi == v[rr].se.fi )) vis [ i ] = 1 , rr = i ;
	for ( int i = 0 ; i < n ; i ++ ){
		if ( vis[i] ) {
			G.Insert ( db(v[i].se.fi - v[i].fi) / db (v[i].se.fi*v[i].fi), 1e6/db(v[i].se.fi), v[i].se.se ) ;
		}
	}
	G.solve();
}


#include<bits/stdc++.h>
#define pii pair<db,db>
#define fi first
#define db double
#define se second
#define ll db
using namespace std;
pair<int,pair<int,int> > v [ 200002 ] ;
bool vis [ 200002 ] ;
struct Hull {
	deque<pii > v; deque <int> id ;
	db cross( pii l1, pii l2 ){ return db( l2.se - l1.se ) / db( l1.fi - l2.fi ) ; }
	void Insert ( ll m , ll b , int _id ) {
		pii line = make_pair(m,b);
		while ((int)v.size() > 1 && cross ( line , v.back() ) <= cross ( v.back() , v[v.size()-2] ) -1e-8 ) v.pop_back(), id.pop_back();
    v.push_back(line);
		id.push_back(_id);
	}
	void solve(){
		sort(id.begin(),id.end());
		for ( int i = 0 ; i < (int)id.size() ; i++ ) printf("%d ", id[i]);
		printf("\n");
	}
};
int main(){
	int n , rr ;
	scanf("%d", &n );
	for ( int i = 0 ; i < n ; i ++ ) scanf("%d%d", &v[i].fi , &v[i].se.fi) , v[i].se.se = i + 1 ;
	sort ( v , v + n ) ; rr = n - 1 ;
	Hull G ;
	vis [ rr ] = 1 ;
	for ( int i = n - 2 ; i >= 0 ; i -- ) if ( v[i].se.fi > v[rr].se.fi || (v[i].fi == v[rr].fi && v[i].se.fi == v[rr].se.fi )) vis [ i ] = 1 , rr = i ;
	for ( int i = 0 ; i < n ; i ++ ){
		if ( vis[i] ) {
			G.Insert ( db(v[i].se.fi - v[i].fi) / db (v[i].se.fi*v[i].fi), 1e6/db(v[i].se.fi), v[i].se.se ) ;
		}
	}
	G.solve();
}


#include<bits/stdc++.h>
#define pii pair<db,db>
#define fi first
#define db double
#define se second
#define ll db
using namespace std;
pair<int,pair<int,int> > v [ 200002 ] ;
bool vis [ 200002 ] ;
struct Hull {
	deque<pii > v; deque <int> id ;
	db cross( pii l1, pii l2 ){ return db( l2.se - l1.se ) / db( l1.fi - l2.fi ) ; }
	void Insert ( ll m , ll b , int _id ) {
		pii line = make_pair(m,b);
		while ((int)v.size() > 1 && cross ( line , v.back() ) <= cross ( v.back() , v[v.size()-2] ) -1e14 ) v.pop_back(), id.pop_back();
    v.push_back(line);
		id.push_back(_id);
	}
	void solve(){
		sort(id.begin(),id.end());
		for ( int i = 0 ; i < (int)id.size() ; i++ ) printf("%d ", id[i]);
		printf("\n");
	}
};
int main(){
	int n , rr ;
	scanf("%d", &n );
	for ( int i = 0 ; i < n ; i ++ ) scanf("%d%d", &v[i].fi , &v[i].se.fi) , v[i].se.se = i + 1 ;
	sort ( v , v + n ) ; rr = n - 1 ;
	Hull G ;
	vis [ rr ] = 1 ;
	for ( int i = n - 2 ; i >= 0 ; i -- ) if ( v[i].se.fi > v[rr].se.fi || (v[i].fi == v[rr].fi && v[i].se.fi == v[rr].se.fi )) vis [ i ] = 1 , rr = i ;
	for ( int i = 0 ; i < n ; i ++ ){
		if ( vis[i] ) {
			G.Insert ( db(v[i].se.fi - v[i].fi) / db (v[i].se.fi*v[i].fi), 1e6/db(v[i].se.fi), v[i].se.se ) ;
		}
	}
	G.solve();
}


#include<bits/stdc++.h>
#define pii pair<db,db>
#define fi first
#define db double
#define se second
#define ll db
using namespace std;
pair<int,pair<int,int> > v [ 200002 ] ;
bool vis [ 200002 ] ;
struct Hull {
	deque<pii > v; deque <int> id ;deque<int> id2 ;
	db cross( pii l1, pii l2 ){ return db( l2.se - l1.se ) / db( l1.fi - l2.fi ) ; }
	void Insert ( ll m , ll b , int _id , int id2_) {
		pii line = make_pair(m,b);
		while ((int)v.size() > 1 && cross ( line , v.back() ) <= cross ( v.back() , v[v.size()-2] )  ) v.pop_back(), id.pop_back(),id2.pop_back() ;
    v.push_back(line);
		id.push_back(_id);
		id2.push_back(id2_);
	}
	void solve(){
		sort(id.begin(),id.end());
		for ( int i = 0 ; i < (int)id.size() ; i++ ) printf("%d ", id[i]);
		printf("\n");
	}
	void add ( int x ) {
		id.push_back(x);
	}
};
int main(){
	int n , rr ;
	scanf("%d", &n );
	for ( int i = 0 ; i < n ; i ++ ) scanf("%d%d", &v[i].fi , &v[i].se.fi) , v[i].se.se = i + 1 ;
	sort ( v , v + n ) ; rr = n - 1 ;
	Hull G ;
	vis [ rr ] = 1 ;
	for ( int i = n - 2 ; i >= 0 ; i -- ) if ( v[i].se.fi > v[rr].se.fi ) vis [ i ] = 1 , rr = i ;
	for ( int i = 0 ; i < n ; i ++ ){
		if ( vis[i] ) {
			G.Insert ( db(v[i].se.fi - v[i].fi) / db (v[i].se.fi*v[i].fi), 1e6/db(v[i].se.fi), v[i].se.se, i ) ;
		}
	}
	for ( int i = 0 ; i < G.id2.size(); i ++ ) {
		int j = G.id2[i]- 1 , k = j + 1 ;
		while ( j >= 0 && v[j].se.fi == v[k].se.fi && v[j].fi == v[k].fi ) G.add(v[j].se.se), j -- ;
	}
	G.solve();
}


#include <iostream>
#include <cstdio>
#include <string>
#include <string.h>
#include <queue>
#include <math.h>
#include <cmath>
#include <map>
#include <set>
#include <vector>
#include <algorithm>
#include <bitset>
#include <ctype.h>
#include <cassert>
#include <stack>
#include <fstream>
#include <unordered_map>
#include <ctime>
#include <functional>

using namespace std;

#define snd second
#define fst first
#define mp make_pair
#define ll long long
#define ull unsigned long long
#define ld long double
#define pb push_back
#define left _left
#define right _right

const ld pi = 3.14159265359;

template < typename T > T abs(T x)
{
    return x > 0 ? x : -x;
}

template < typename T > T sqr(T x)
{
	return x * x;
}

ll sign(ll x)
{
	if (x > 0)
		return 1;
	else if (x == 0)
		return 0;
	else
		return -1;
}

struct R
{
	ll n, d;

	R()
	{
		n = 0, d = 1;
	}

	R(ll x)
	{
		n = x, d = 1;
	}

	R(ll _n, ll _d)
	{
		n = _n, d = _d;
		if (d < 0)
			n = -n, d = -d;
	}

	R operator + (const R &r) const
	{
		return R(n * r.d + r.n * d, d * r.d);
	}

	R operator - (const R &r) const
	{

		return R(n * r.d - r.n * d, d * r.d);
	}

	R operator * (const R &r) const
	{
		return R(n * r.n, d * r.d);
	}

	R operator / (const R &r) const
	{
		return R(n * r.d, d * r.n);
	}

	bool operator < (const R &r) const
	{
		return (ld)n / d < (ld)r.n / r.d - 1e-13;
		if (sign(n) != sign(r.n))
		{
			return n < r.n;
		}
		else
		{
			if (sign(n) == -1)
			{
				return R(-r.n, r.d) < R(-n, d);
			}
		}

		ll x = n / d;
		ll y = r.n / r.d;

		if (x < y)
			return true;
		else if (x == y)
		{
			ll n1 = n % d;
			ll n2 = r.n % r.d;
			if (n1 == 0)
			{
				if (n2 == 0)
					return false;
				return true;
			}
			else if (n2 == 0)
				return false;

			return R(r.d, n2) < R(d, n1);
		}
		else
		{
			return false;
		}
	}

	bool operator == (const R &r) const
	{
		return !(*this < r) && !(r < *this);
	}
};
/*
1/a + x * (1/b - 1/a) = 1/c + x * (1/d - 1/c)

(1/a - 1/c) / (1/d - 1/c - 1/b + 1/a) =
*/

struct line
{
	// a + (b - a) * x = 0;
	ll a, b;
	int idx;

	line()
	{

	}

	bool operator < (const line &l) const
	{
		return mp(R(1, b) - R(1, a), R(1, a)) < mp(R(1, l.b) - R(1, l.a), R(1, l.a));
	}

	//(a2 - a) * (b2 * b) / (a2 * b * a - b2 * b * a - a2 * b2 * a + a2 * b2 * b)

	R intersect(const line &l) const
	{
		return R((l.a - a) * (l.b * b), (l.a * b * a - l.b * b * a - l.a * l.b * a + l.a * l.b * b));
	}
};

int main()
{
	//srand(time(NULL));
	//gen();
//	freopen("a.in", "r", stdin);
//	freopen("a.out", "w", stdout);

	int n;
	scanf("%d", &n);
	//n = 200000;

	vector < line > a;

	for (int i = 1; i <= n; i++)
	{
		int x, y;
		scanf("%d %d", &x, &y);
		//x = rand() % 10000 + 1;
		//y = rand() % 10000 + 1;
		line l;
		l.a = x;
		l.b = y;
		l.idx = i;
		a.pb(l);
	}

	sort(a.begin(), a.end());
	reverse(a.begin(), a.end());

	vector < line > st;

	map < int, vector < int > > cc;
	int p = 0;
	for (int i = 0; i < n; i++)
	{
		int j = i;
		while (j < n && a[i].a == a[j].a && a[i].b == a[j].b)
		{
			j++;
		}

		for (int h = i; h < j; h++)
			cc[a[i].idx].pb(a[h].idx);

		a[p++] = a[i];
		//cerr << a[i].idx << endl;
		i = j - 1;
	}

	a.resize(p);

	for (auto l : a)
	{
		while (!st.empty())
		{
			if (R(1, st.back().b) - R(1, st.back().a) == R(1, l.b) - R(1, l.a))
				st.pop_back();
			else
				break;
		}

		while (st.size() > 1)
		{
			auto x1 = st[st.size() - 2].intersect(l);
			auto x2 = st.back().intersect(st[st.size() - 2]);

			if (x1 < x2)
				st.pop_back();
			else
				break;
		}

		st.pb(l);
	}

	vector < int > ans;

	for (int i = 0; i < st.size(); i++)
	{
		bool good = true;

		if (i)
		{
			good &= !(R(1, 1) < st[i - 1].intersect(st[i]));
		}

		if (i + 1 < st.size())
		{
			good &= !(st[i].intersect(st[i + 1]) < R(0, 1));
		}

		if (good)
		{
			for (int x : cc[st[i].idx])
				ans.pb(x);
		}
	}

	sort(ans.begin(), ans.end());

	for (int i = 0; i < ans.size(); i++)
	{
		if (i)
			printf(" ");
		printf("%d", ans[i]);
	}

	return 0;
}


#include <iostream>
#include <cstdio>
#include <string>
#include <string.h>
#include <queue>
#include <math.h>
#include <cmath>
#include <map>
#include <set>
#include <vector>
#include <algorithm>
#include <bitset>
#include <ctype.h>
#include <cassert>
#include <stack>
#include <fstream>
#include <unordered_map>
#include <ctime>
#include <functional>

using namespace std;

#define snd second
#define fst first
#define mp make_pair
#define ll long long
#define ull unsigned long long
#define ld long double
#define pb push_back
#define left _left
#define right _right

const ld pi = 3.14159265359;

template < typename T > T abs(T x)
{
    return x > 0 ? x : -x;
}

template < typename T > T sqr(T x)
{
	return x * x;
}

ll sign(ll x)
{
	if (x > 0)
		return 1;
	else if (x == 0)
		return 0;
	else
		return -1;
}

struct R
{
	ll n, d;

	R()
	{
		n = 0, d = 1;
	}

	R(ll x)
	{
		n = x, d = 1;
	}

	R(ll _n, ll _d)
	{
		n = _n, d = _d;
		if (d < 0)
			n = -n, d = -d;
	}

	R operator + (const R &r) const
	{
		return R(n * r.d + r.n * d, d * r.d);
	}

	R operator - (const R &r) const
	{

		return R(n * r.d - r.n * d, d * r.d);
	}

	R operator * (const R &r) const
	{
		return R(n * r.n, d * r.d);
	}

	R operator / (const R &r) const
	{
		return R(n * r.d, d * r.n);
	}

	bool operator < (const R &r) const
	{
		return (ld)n / d < (ld)r.n / r.d - 1e-13;
		if (sign(n) != sign(r.n))
		{
			return n < r.n;
		}
		else
		{
			if (sign(n) == -1)
			{
				return R(-r.n, r.d) < R(-n, d);
			}
		}

		ll x = n / d;
		ll y = r.n / r.d;

		if (x < y)
			return true;
		else if (x == y)
		{
			ll n1 = n % d;
			ll n2 = r.n % r.d;
			if (n1 == 0)
			{
				if (n2 == 0)
					return false;
				return true;
			}
			else if (n2 == 0)
				return false;

			return R(r.d, n2) < R(d, n1);
		}
		else
		{
			return false;
		}
	}

	bool operator == (const R &r) const
	{
		return !(*this < r) && !(r < *this);
	}
};
/*
1/a + x * (1/b - 1/a) = 1/c + x * (1/d - 1/c)

(1/a - 1/c) / (1/d - 1/c - 1/b + 1/a) =
*/

struct line
{
	// a + (b - a) * x = 0;
	ll a, b;
	int idx;

	line()
	{

	}

	bool operator < (const line &l) const
	{
		return mp(R(1, b) - R(1, a), R(1, a)) < mp(R(1, l.b) - R(1, l.a), R(1, l.a));
	}

	//(a2 - a) * (b2 * b) / (a2 * b * a - b2 * b * a - a2 * b2 * a + a2 * b2 * b)

	R intersect(const line &l) const
	{
		return R((l.a - a) * (l.b * b), (l.a * b * a - l.b * b * a - l.a * l.b * a + l.a * l.b * b));
	}
};

int main()
{
	//srand(time(NULL));
	//gen();
//	freopen("a.in", "r", stdin);
//	freopen("a.out", "w", stdout);

	int n;
	scanf("%d", &n);
	//n = 200000;

	vector < line > a;

	for (int i = 1; i <= n; i++)
	{
		int x, y;
		scanf("%d %d", &x, &y);
		//x = rand() % 10000 + 1;
		//y = rand() % 10000 + 1;
		line l;
		l.a = x;
		l.b = y;
		l.idx = i;
		a.pb(l);
	}

	auto y = a[0].intersect(a[2]);

	sort(a.begin(), a.end());
	reverse(a.begin(), a.end());

	vector < line > st;

	map < int, vector < int > > cc;
	int p = 0;
	for (int i = 0; i < n; i++)
	{
		int j = i;
		while (j < n && a[i].a == a[j].a && a[i].b == a[j].b)
		{
			j++;
		}

		for (int h = i; h < j; h++)
			cc[a[i].idx].pb(a[h].idx);

		a[p++] = a[i];
		//cerr << a[i].idx << endl;
		i = j - 1;
	}

	a.resize(p);

	for (auto l : a)
	{
		while (!st.empty())
		{
			if (st.back().b == l.b)
				st.pop_back();
			else
				break;
		}

		while (st.size() > 1)
		{
			auto x1 = st[st.size() - 2].intersect(l);
			auto x2 = st.back().intersect(st[st.size() - 2]);

			if (x1 < x2)
				st.pop_back();
			else
				break;
		}

		st.pb(l);
	}

	vector < int > ans;

	for (int i = 0; i < st.size(); i++)
	{
		bool good = true;

		if (i)
		{
			good &= !(R(1, 1) < st[i - 1].intersect(st[i]));
		}

		if (i + 1 < st.size())
		{
			good &= !(st[i].intersect(st[i + 1]) < R(0, 1));
		}

		if (good)
		{
			for (int x : cc[st[i].idx])
				ans.pb(x);
		}
	}

	sort(ans.begin(), ans.end());

	for (int i = 0; i < ans.size(); i++)
	{
		if (i)
			printf(" ");
		printf("%d", ans[i]);
	}

	return 0;
}


#include <iostream>
#include <cstdio>
#include <string>
#include <string.h>
#include <queue>
#include <math.h>
#include <cmath>
#include <map>
#include <set>
#include <vector>
#include <algorithm>
#include <bitset>
#include <ctype.h>
#include <cassert>
#include <stack>
#include <fstream>
#include <unordered_map>
#include <ctime>
#include <functional>

using namespace std;

#define snd second
#define fst first
#define mp make_pair
#define ll long long
#define ull unsigned long long
#define ld long double
#define pb push_back
#define left _left
#define right _right

const ld pi = 3.14159265359;

template < typename T > T abs(T x)
{
    return x > 0 ? x : -x;
}

template < typename T > T sqr(T x)
{
	return x * x;
}

ll sign(ll x)
{
	if (x > 0)
		return 1;
	else if (x == 0)
		return 0;
	else
		return -1;
}

struct R
{
	ll n, d;

	R()
	{
		n = 0, d = 1;
	}

	R(ll x)
	{
		n = x, d = 1;
	}

	R(ll _n, ll _d)
	{
		n = _n, d = _d;
		if (d < 0)
			n = -n, d = -d;
	}

	R operator + (const R &r) const
	{
		return R(n * r.d + r.n * d, d * r.d);
	}

	R operator - (const R &r) const
	{
		return R(n * r.d - r.n * d, d * r.d);
	}

	R operator * (const R &r) const
	{
		return R(n * r.n, d * r.d);
	}

	R operator / (const R &r) const
	{
		return R(n * r.d, d * r.n);
	}

	bool operator < (const R &r) const
	{
		if (sign(n) != sign(r.n))
		{
			return n < r.n;
		}
		else
		{
			if (sign(n) == -1)
			{
				return R(-r.n, r.d) < R(-n, d);
			}
		}

		ll x = n / d;
		ll y = r.n / r.d;

		if (x < y)
			return true;
		else if (x == y)
		{
			ll n1 = n % d;
			ll n2 = r.n % r.d;
			if (n1 == 0)
			{
				if (n2 == 0)
					return false;
				return true;
			}
			else if (n2 == 0)
				return false;

			return R(r.d, n2) < R(d, n1);
		}
		else
		{
			return false;
		}
	}

	bool operator == (const R &r) const
	{
		return !(*this < r) && !(r < *this);
	}
};

struct line
{
	// a + b * x = 0;
	R a, b;
	int idx;

	line()
	{
		a = R(0, 1);
		b = R(0, 1);
	}

	bool operator < (const line &l) const
	{
		return mp(b, a) < mp(l.b, l.a);
	}

	R intersect(const line &l) const
	{
		return (a - l.a) / (l.b - b);
	}
};

int main()
{
	//srand(time(NULL));
	//gen();
//	freopen("a.in", "r", stdin);
//	freopen("a.out", "w", stdout);

	int n;
	scanf("%d", &n);

	vector < line > a;

	for (int i = 1; i <= n; i++)
	{
		int x, y;
		scanf("%d %d", &x, &y);
		line l;
		l.a = R(1, x);
		l.b = R(1, y) - R(1, x);
		l.idx = i;
		a.pb(l);
	}

	sort(a.begin(), a.end());
	reverse(a.begin(), a.end());

	vector < line > st;

	map < int, vector < int > > cc;
	int p = 0;
	for (int i = 0; i < n; i++)
	{
		int j = i;
		while (j < n && a[i].a == a[j].a && a[i].b == a[j].b)
		{
			j++;
		}

		for (int h = i; h < j; h++)
			cc[a[i].idx].pb(a[h].idx);

		a[p++] = a[i];
		//cerr << a[i].idx << endl;
		i = j - 1;
	}

	a.resize(p);

	for (auto l : a)
	{
		while (!st.empty())
		{
			if (st.back().b == l.b)
				st.pop_back();
			else
				break;
		}

		while (st.size() > 1)
		{
			auto x1 = st[st.size() - 2].intersect(l);
			auto x2 = st.back().intersect(st[st.size() - 2]);

			if (x1 < x2)
				st.pop_back();
			else
				break;
		}

		st.pb(l);
	}

	vector < int > ans;

	for (int i = 0; i < st.size(); i++)
	{
		bool good = true;

		if (i)
		{
			good &= !(R(1, 1) < st[i - 1].intersect(st[i]));
		}

		if (i + 1 < st.size())
		{
			good &= !(st[i].intersect(st[i + 1]) < R(0, 1));
		}

		if (good)
		{
			for (int x : cc[st[i].idx])
				ans.pb(x);
		}
	}

	sort(ans.begin(), ans.end());

	for (int i = 0; i < ans.size(); i++)
	{
		if (i)
			printf(" ");
		printf("%d", ans[i]);
	}

	return 0;
}


#include <iostream>
#include <cstdio>
#include <string>
#include <string.h>
#include <queue>
#include <math.h>
#include <cmath>
#include <map>
#include <set>
#include <vector>
#include <algorithm>
#include <bitset>
#include <ctype.h>
#include <cassert>
#include <stack>
#include <fstream>
#include <unordered_map>
#include <ctime>
#include <functional>

using namespace std;

#define snd second
#define fst first
#define mp make_pair
#define ll long long
#define ull unsigned long long
#define ld long double
#define pb push_back
#define left _left
#define right _right

const ld pi = 3.14159265359;

template < typename T > T abs(T x)
{
    return x > 0 ? x : -x;
}

template < typename T > T sqr(T x)
{
	return x * x;
}

ll sign(ll x)
{
	if (x > 0)
		return 1;
	else if (x == 0)
		return 0;
	else
		return -1;
}

struct R
{
	ll n, d;

	R()
	{
		n = 0, d = 1;
	}

	R(ll x)
	{
		n = x, d = 1;
	}

	R(ll _n, ll _d)
	{
		n = _n, d = _d;
		if (d < 0)
			n = -n, d = -d;
	}

	R operator + (const R &r) const
	{
		return R(n * r.d + r.n * d, d * r.d);
	}

	R operator - (const R &r) const
	{
		return R(n * r.d - r.n * d, d * r.d);
	}

	R operator * (const R &r) const
	{
		return R(n * r.n, d * r.d);
	}

	R operator / (const R &r) const
	{
		return R(n * r.d, d * r.n);
	}

	bool operator < (const R &r) const
	{
		if (d == 0 && r.d == 0)
			return false;
		else if (d == 0)
			return false;
		else if (r.d == 0)
			return true;

		if (sign(n) != sign(r.n))
		{
			return n < r.n;
		}
		else
		{
			if (sign(n) == -1)
			{
				return R(-r.n, r.d) < R(-n, d);
			}
		}

		ll x = n / d;
		ll y = r.n / r.d;

		if (x < y)
			return true;
		else if (x == y)
		{
			return R(r.d, r.n % r.d) < R(d, n % d);
		}
		else
		{
			return false;
		}
	}

	bool operator == (const R &r) const
	{
		return !(*this < r) && !(r < *this);
	}
};

struct line
{
	// a + b * x = 0;
	R a, b;
	int idx;

	line()
	{
		a = R(0, 1);
		b = R(0, 1);
	}

	bool operator < (const line &l) const
	{
		return mp(b, a) < mp(l.b, l.a);
	}

	R intersect(const line &l) const
	{
		return (a - l.a) / (l.b - b);
	}
};

int main()
{
	//srand(time(NULL));
	//gen();
//	freopen("a.in", "r", stdin);
//	freopen("a.out", "w", stdout);

	int n;
	scanf("%d", &n);

	vector < line > a;

	for (int i = 1; i <= n; i++)
	{
		int x, y;
		scanf("%d %d", &x, &y);
		line l;
		l.a = R(1, x);
		l.b = R(1, y) - R(1, x);
		l.idx = i;
		a.pb(l);
	}

	sort(a.begin(), a.end());
	reverse(a.begin(), a.end());

	vector < line > st;

	map < int, vector < int > > cc;
	int p = 0;
	for (int i = 0; i < n; i++)
	{
		int j = i;
		while (j < n && a[i].a == a[j].a && a[i].b == a[j].b)
		{
			j++;
		}

		for (int h = i; h < j; h++)
			cc[a[i].idx].pb(a[h].idx);

		a[p++] = a[i];
		//cerr << a[i].idx << endl;
		i = j - 1;
	}

	a.resize(p);

	for (auto l : a)
	{
		while (!st.empty())
		{
			if (st.back().b == l.b)
				st.pop_back();
			else
				break;
		}

		while (st.size() > 1)
		{
			auto x1 = st[st.size() - 2].intersect(l);
			auto x2 = st.back().intersect(st[st.size() - 2]);

			if (x1 < x2)
				st.pop_back();
			else
				break;
		}

		st.pb(l);
	}

	vector < int > ans;

	for (int i = 0; i < st.size(); i++)
	{
		bool good = true;

		if (i)
		{
			good &= !(R(1, 1) < st[i - 1].intersect(st[i]));
		}

		if (i + 1 < st.size())
		{
			good &= !(st[i].intersect(st[i + 1]) < R(0, 1));
		}

		if (good)
		{
			for (int x : cc[st[i].idx])
				ans.pb(x);
		}
	}

	sort(ans.begin(), ans.end());

	for (int i = 0; i < ans.size(); i++)
	{
		if (i)
			printf(" ");
		printf("%d", ans[i]);
	}

	return 0;
}


#include <iostream>
#include <cstdio>
#include <string>
#include <string.h>
#include <queue>
#include <math.h>
#include <cmath>
#include <map>
#include <set>
#include <vector>
#include <algorithm>
#include <bitset>
#include <ctype.h>
#include <cassert>
#include <stack>
#include <fstream>
#include <unordered_map>
#include <ctime>
#include <functional>

using namespace std;

#define snd second
#define fst first
#define mp make_pair
#define ll long long
#define ull unsigned long long
#define ld long double
#define pb push_back
#define left _left
#define right _right

const ld pi = 3.14159265359;

template < typename T > T abs(T x)
{
    return x > 0 ? x : -x;
}

template < typename T > T sqr(T x)
{
	return x * x;
}

ll sign(ll x)
{
	if (x > 0)
		return 1;
	else if (x == 0)
		return 0;
	else
		return -1;
}

struct R
{
	ll n, d;

	R()
	{
		n = 0, d = 1;
	}

	R(ll x)
	{
		n = x, d = 1;
	}

	R(ll _n, ll _d)
	{
		n = _n, d = _d;
		if (d < 0)
			n = -n, d = -d;
	}

	R operator + (const R &r) const
	{
		return R(n * r.d + r.n * d, d * r.d);
	}

	R operator - (const R &r) const
	{
		return R(n * r.d - r.n * d, d * r.d);
	}

	R operator * (const R &r) const
	{
		return R(n * r.n, d * r.d);
	}

	R operator / (const R &r) const
	{
		return R(n * r.d, d * r.n);
	}

	bool operator < (const R &r) const
	{
		return (ld)n / d < (ld)r.n / r.d - 1e-13;
		if (sign(n) != sign(r.n))
		{
			return n < r.n;
		}
		else
		{
			if (sign(n) == -1)
			{
				return R(-r.n, r.d) < R(-n, d);
			}
		}

		ll x = n / d;
		ll y = r.n / r.d;

		if (x < y)
			return true;
		else if (x == y)
		{
			ll n1 = n % d;
			ll n2 = r.n % r.d;
			if (n1 == 0)
			{
				if (n2 == 0)
					return false;
				return true;
			}
			else if (n2 == 0)
				return false;

			return R(r.d, n2) < R(d, n1);
		}
		else
		{
			return false;
		}
	}

	bool operator == (const R &r) const
	{
		return !(*this < r) && !(r < *this);
	}
};

struct line
{
	// a + b * x = 0;
	R a, b;
	int idx;

	line()
	{
		a = R(0, 1);
		b = R(0, 1);
	}

	bool operator < (const line &l) const
	{
		return mp(b, a) < mp(l.b, l.a);
	}

	R intersect(const line &l) const
	{
		return (a - l.a) / (l.b - b);
	}
};

int main()
{
	//srand(time(NULL));
	//gen();
//	freopen("a.in", "r", stdin);
//	freopen("a.out", "w", stdout);

	int n;
	scanf("%d", &n);

	vector < line > a;

	for (int i = 1; i <= n; i++)
	{
		int x, y;
		scanf("%d %d", &x, &y);
		line l;
		l.a = R(1, x);
		l.b = R(1, y) - R(1, x);
		l.idx = i;
		a.pb(l);
	}

	sort(a.begin(), a.end());
	reverse(a.begin(), a.end());

	vector < line > st;

	map < int, vector < int > > cc;
	int p = 0;
	for (int i = 0; i < n; i++)
	{
		int j = i;
		while (j < n && a[i].a == a[j].a && a[i].b == a[j].b)
		{
			j++;
		}

		for (int h = i; h < j; h++)
			cc[a[i].idx].pb(a[h].idx);

		a[p++] = a[i];
		//cerr << a[i].idx << endl;
		i = j - 1;
	}

	a.resize(p);

	for (auto l : a)
	{
		while (!st.empty())
		{
			if (st.back().b == l.b)
				st.pop_back();
			else
				break;
		}

		while (st.size() > 1)
		{
			auto x1 = st[st.size() - 2].intersect(l);
			auto x2 = st.back().intersect(st[st.size() - 2]);

			if (x1 < x2)
				st.pop_back();
			else
				break;
		}

		st.pb(l);
	}

	vector < int > ans;

	for (int i = 0; i < st.size(); i++)
	{
		bool good = true;

		if (i)
		{
			good &= !(R(1, 1) < st[i - 1].intersect(st[i]));
		}

		if (i + 1 < st.size())
		{
			good &= !(st[i].intersect(st[i + 1]) < R(0, 1));
		}

		if (good)
		{
			for (int x : cc[st[i].idx])
				ans.pb(x);
		}
	}

	sort(ans.begin(), ans.end());

	for (int i = 0; i < ans.size(); i++)
	{
		if (i)
			printf(" ");
		printf("%d", ans[i]);
	}

	return 0;
}


#include <iostream>
#include <cstdio>
#include <string>
#include <string.h>
#include <queue>
#include <math.h>
#include <cmath>
#include <map>
#include <set>
#include <vector>
#include <algorithm>
#include <bitset>
#include <ctype.h>
#include <cassert>
#include <stack>
#include <fstream>
#include <unordered_map>
#include <ctime>
#include <functional>

using namespace std;

#define snd second
#define fst first
#define mp make_pair
#define ll long long
#define ull unsigned long long
#define ld long double
#define pb push_back
#define left _left
#define right _right

const ld pi = 3.14159265359;

template < typename T > T abs(T x)
{
    return x > 0 ? x : -x;
}

template < typename T > T sqr(T x)
{
	return x * x;
}

ll sign(ll x)
{
	if (x > 0)
		return 1;
	else if (x == 0)
		return 0;
	else
		return -1;
}

struct R
{
	ll n, d;

	R()
	{
		n = 0, d = 1;
	}

	R(ll x)
	{
		n = x, d = 1;
	}

	R(ll _n, ll _d)
	{
		n = _n, d = _d;
		if (d < 0)
			n = -n, d = -d;
	}

	R operator + (const R &r) const
	{
		return R(n * r.d + r.n * d, d * r.d);
	}

	R operator - (const R &r) const
	{
		return R(n * r.d - r.n * d, d * r.d);
	}

	R operator * (const R &r) const
	{
		return R(n * r.n, d * r.d);
	}

	R operator / (const R &r) const
	{
		return R(n * r.d, d * r.n);
	}

	bool operator < (const R &r) const
	{
		return (ld)n / d < (ld)r.n / r.d - 1e13;
		if (sign(n) != sign(r.n))
		{
			return n < r.n;
		}
		else
		{
			if (sign(n) == -1)
			{
				return R(-r.n, r.d) < R(-n, d);
			}
		}

		ll x = n / d;
		ll y = r.n / r.d;

		if (x < y)
			return true;
		else if (x == y)
		{
			ll n1 = n % d;
			ll n2 = r.n % r.d;
			if (n1 == 0)
			{
				if (n2 == 0)
					return false;
				return true;
			}
			else if (n2 == 0)
				return false;

			return R(r.d, n2) < R(d, n1);
		}
		else
		{
			return false;
		}
	}

	bool operator == (const R &r) const
	{
		return !(*this < r) && !(r < *this);
	}
};

struct line
{
	// a + b * x = 0;
	R a, b;
	int idx;

	line()
	{
		a = R(0, 1);
		b = R(0, 1);
	}

	bool operator < (const line &l) const
	{
		return mp(b, a) < mp(l.b, l.a);
	}

	R intersect(const line &l) const
	{
		return (a - l.a) / (l.b - b);
	}
};

int main()
{
	//srand(time(NULL));
	//gen();
//	freopen("a.in", "r", stdin);
//	freopen("a.out", "w", stdout);

	int n;
	scanf("%d", &n);

	vector < line > a;

	for (int i = 1; i <= n; i++)
	{
		int x, y;
		scanf("%d %d", &x, &y);
		line l;
		l.a = R(1, x);
		l.b = R(1, y) - R(1, x);
		l.idx = i;
		a.pb(l);
	}

	sort(a.begin(), a.end());
	reverse(a.begin(), a.end());

	vector < line > st;

	map < int, vector < int > > cc;
	int p = 0;
	for (int i = 0; i < n; i++)
	{
		int j = i;
		while (j < n && a[i].a == a[j].a && a[i].b == a[j].b)
		{
			j++;
		}

		for (int h = i; h < j; h++)
			cc[a[i].idx].pb(a[h].idx);

		a[p++] = a[i];
		//cerr << a[i].idx << endl;
		i = j - 1;
	}

	a.resize(p);

	for (auto l : a)
	{
		while (!st.empty())
		{
			if (st.back().b == l.b)
				st.pop_back();
			else
				break;
		}

		while (st.size() > 1)
		{
			auto x1 = st[st.size() - 2].intersect(l);
			auto x2 = st.back().intersect(st[st.size() - 2]);

			if (x1 < x2)
				st.pop_back();
			else
				break;
		}

		st.pb(l);
	}

	vector < int > ans;

	for (int i = 0; i < st.size(); i++)
	{
		bool good = true;

		if (i)
		{
			good &= !(R(1, 1) < st[i - 1].intersect(st[i]));
		}

		if (i + 1 < st.size())
		{
			good &= !(st[i].intersect(st[i + 1]) < R(0, 1));
		}

		if (good)
		{
			for (int x : cc[st[i].idx])
				ans.pb(x);
		}
	}

	sort(ans.begin(), ans.end());

	for (int i = 0; i < ans.size(); i++)
	{
		if (i)
			printf(" ");
		printf("%d", ans[i]);
	}

	return 0;
}


#include <iostream>
#include <cstdio>
#include <string>
#include <string.h>
#include <queue>
#include <math.h>
#include <cmath>
#include <map>
#include <set>
#include <vector>
#include <algorithm>
#include <bitset>
#include <ctype.h>
#include <cassert>
#include <stack>
#include <fstream>
#include <unordered_map>
#include <ctime>
#include <functional>

using namespace std;

#define snd second
#define fst first
#define mp make_pair
#define ll long long
#define ull unsigned long long
#define ld long double
#define pb push_back
#define left _left
#define right _right

const ld pi = 3.14159265359;

template < typename T > T abs(T x)
{
    return x > 0 ? x : -x;
}

template < typename T > T sqr(T x)
{
	return x * x;
}

ll sign(ll x)
{
	if (x > 0)
		return 1;
	else if (x == 0)
		return 0;
	else
		return -1;
}

struct R
{
	ll n, d;

	R()
	{
		n = 0, d = 1;
	}

	R(ll x)
	{
		n = x, d = 1;
	}

	R(ll _n, ll _d)
	{
		n = _n, d = _d;
		if (d < 0)
			n = -n, d = -d;
	}

	R operator + (const R &r) const
	{
		return R(n * r.d + r.n * d, d * r.d);
	}

	R operator - (const R &r) const
	{

		return R(n * r.d - r.n * d, d * r.d);
	}

	R operator * (const R &r) const
	{
		return R(n * r.n, d * r.d);
	}

	R operator / (const R &r) const
	{
		return R(n * r.d, d * r.n);
	}

	bool operator < (const R &r) const
	{
		return (ld)n / d < (ld)r.n / r.d - 1e-13;
		if (sign(n) != sign(r.n))
		{
			return n < r.n;
		}
		else
		{
			if (sign(n) == -1)
			{
				return R(-r.n, r.d) < R(-n, d);
			}
		}

		ll x = n / d;
		ll y = r.n / r.d;

		if (x < y)
			return true;
		else if (x == y)
		{
			ll n1 = n % d;
			ll n2 = r.n % r.d;
			if (n1 == 0)
			{
				if (n2 == 0)
					return false;
				return true;
			}
			else if (n2 == 0)
				return false;

			return R(r.d, n2) < R(d, n1);
		}
		else
		{
			return false;
		}
	}

	bool operator == (const R &r) const
	{
		return !(*this < r) && !(r < *this);
	}
};
/*
1/a + x * (1/b - 1/a) = 1/c + x * (1/d - 1/c)

(1/a - 1/c) / (1/d - 1/c - 1/b + 1/a) =
*/

struct line
{
	// a + (b - a) * x = 0;
	ll a, b;
	int idx;

	line()
	{

	}

	bool operator < (const line &l) const
	{
		return mp(R(1, b) - R(1, a), R(1, a)) < mp(R(1, l.b) - R(1, l.a), R(1, l.a));
	}

	//(a2 - a) * (b2 * b) / (a2 * b * a - b2 * b * a - a2 * b2 * a + a2 * b2 * b)

	R intersect(const line &l) const
	{
		return R((l.a - a) * (l.b * b), (l.a * b * a - l.b * b * a - l.a * l.b * a + l.a * l.b * b));
	}
};

int main()
{
	//srand(time(NULL));
	//gen();
//	freopen("a.in", "r", stdin);
//	freopen("a.out", "w", stdout);

	int n;
	scanf("%d", &n);
	//n = 200000;

	vector < line > a;

	for (int i = 1; i <= n; i++)
	{
		int x, y;
		scanf("%d %d", &x, &y);
		//x = rand() % 10000 + 1;
		//y = rand() % 10000 + 1;
		line l;
		l.a = x;
		l.b = y;
		l.idx = i;
		a.pb(l);
	}

	sort(a.begin(), a.end());
	reverse(a.begin(), a.end());

	vector < line > st;

	map < int, vector < int > > cc;
	int p = 0;
	for (int i = 0; i < n; i++)
	{
		int j = i;
		while (j < n && a[i].a == a[j].a && a[i].b == a[j].b)
		{
			j++;
		}

		for (int h = i; h < j; h++)
			cc[a[i].idx].pb(a[h].idx);

		a[p++] = a[i];
		//cerr << a[i].idx << endl;
		i = j - 1;
	}

	a.resize(p);

	for (auto l : a)
	{
		while (!st.empty())
		{
			if (R(1, st.back().b) - R(1, st.back().a) == R(1, l.b) - R(1, l.a))
				st.pop_back();
			else
				break;
		}

		while (st.size() > 1)
		{
			auto x1 = st[st.size() - 2].intersect(l);
			auto x2 = st.back().intersect(st[st.size() - 2]);

			if (x1 < x2)
				st.pop_back();
			else
				break;
		}

		st.pb(l);
	}

	vector < int > ans;

	for (int i = 0; i < st.size(); i++)
	{
		bool good = true;

		if (i)
		{
			good &= st[i - 1].intersect(st[i])) < R(1, 1);
		}

		if (i + 1 < st.size())
		{
			good &= R(0, 1) < st[i].intersect(st[i + 1]);
		}

		if (good)
		{
			for (int x : cc[st[i].idx])
				ans.pb(x);
		}
	}

	sort(ans.begin(), ans.end());

	for (int i = 0; i < ans.size(); i++)
	{
		if (i)
			printf(" ");
		printf("%d", ans[i]);
	}

	return 0;
}


#include <iostream>
#include <cstdio>
#include <string>
#include <string.h>
#include <queue>
#include <math.h>
#include <cmath>
#include <map>
#include <set>
#include <vector>
#include <algorithm>
#include <bitset>
#include <ctype.h>
#include <cassert>
#include <stack>
#include <fstream>
#include <unordered_map>
#include <ctime>
#include <functional>

using namespace std;

#define snd second
#define fst first
#define mp make_pair
#define ll long long
#define ull unsigned long long
#define ld long double
#define pb push_back
#define left _left
#define right _right

const ld pi = 3.14159265359;

template < typename T > T abs(T x)
{
    return x > 0 ? x : -x;
}

template < typename T > T sqr(T x)
{
	return x * x;
}

ll sign(ll x)
{
	if (x > 0)
		return 1;
	else if (x == 0)
		return 0;
	else
		return -1;
}

struct R
{
	ll n, d;

	R()
	{
		n = 0, d = 1;
	}

	R(ll x)
	{
		n = x, d = 1;
	}

	R(ll _n, ll _d)
	{
		n = _n, d = _d;
		if (d < 0)
			n = -n, d = -d;
	}

	R operator + (const R &r) const
	{
		return R(n * r.d + r.n * d, d * r.d);
	}

	R operator - (const R &r) const
	{

		return R(n * r.d - r.n * d, d * r.d);
	}

	R operator * (const R &r) const
	{
		return R(n * r.n, d * r.d);
	}

	R operator / (const R &r) const
	{
		return R(n * r.d, d * r.n);
	}

	bool operator < (const R &r) const
	{
		return (ld)n / d < (ld)r.n / r.d - 1e-13;
		if (sign(n) != sign(r.n))
		{
			return n < r.n;
		}
		else
		{
			if (sign(n) == -1)
			{
				return R(-r.n, r.d) < R(-n, d);
			}
		}

		ll x = n / d;
		ll y = r.n / r.d;

		if (x < y)
			return true;
		else if (x == y)
		{
			ll n1 = n % d;
			ll n2 = r.n % r.d;
			if (n1 == 0)
			{
				if (n2 == 0)
					return false;
				return true;
			}
			else if (n2 == 0)
				return false;

			return R(r.d, n2) < R(d, n1);
		}
		else
		{
			return false;
		}
	}

	bool operator == (const R &r) const
	{
		return !(*this < r) && !(r < *this);
	}
};
/*
1/a + x * (1/b - 1/a) = 1/c + x * (1/d - 1/c)

(1/a - 1/c) / (1/d - 1/c - 1/b + 1/a) =
*/

struct line
{
	// a + (b - a) * x = 0;
	ll a, b;
	int idx;

	line()
	{

	}

	bool operator < (const line &l) const
	{
		return mp(R(1, b) - R(1, a), R(1, a)) < mp(R(1, l.b) - R(1, l.a), R(1, l.a));
	}

	//(a2 - a) * (b2 * b) / (a2 * b * a - b2 * b * a - a2 * b2 * a + a2 * b2 * b)

	R intersect(const line &l) const
	{
		return R((l.a - a) * (l.b * b), (l.a * b * a - l.b * b * a - l.a * l.b * a + l.a * l.b * b));
	}
};

int main()
{
	//srand(time(NULL));
	//gen();
//	freopen("a.in", "r", stdin);
//	freopen("a.out", "w", stdout);

	int n;
	scanf("%d", &n);
	//n = 200000;

	vector < line > a;

	for (int i = 1; i <= n; i++)
	{
		int x, y;
		scanf("%d %d", &x, &y);
		//x = rand() % 10000 + 1;
		//y = rand() % 10000 + 1;
		line l;
		l.a = x;
		l.b = y;
		l.idx = i;
		a.pb(l);
	}

	sort(a.begin(), a.end());
	reverse(a.begin(), a.end());

	vector < line > st;

	map < int, vector < int > > cc;
	int p = 0;
	for (int i = 0; i < n; i++)
	{
		int j = i;
		while (j < n && a[i].a == a[j].a && a[i].b == a[j].b)
		{
			j++;
		}

		for (int h = i; h < j; h++)
			cc[a[i].idx].pb(a[h].idx);

		a[p++] = a[i];
		//cerr << a[i].idx << endl;
		i = j - 1;
	}

	a.resize(p);

	for (auto l : a)
	{
		while (!st.empty())
		{
			if (R(1, st.back().b) - R(1, st.back().a) == R(1, l.b) - R(1, l.a))
				st.pop_back();
			else
				break;
		}

		while (st.size() > 1)
		{
			auto x1 = st[st.size() - 2].intersect(l);
			auto x2 = st.back().intersect(st[st.size() - 2]);

			if (x1 < x2)
				st.pop_back();
			else
				break;
		}

		st.pb(l);
	}

	vector < int > ans;

	for (int i = 0; i < st.size(); i++)
	{
		bool good = true;

		if (i)
		{
			good &= st[i - 1].intersect(st[i]) < R(1, 1);
		}

		if (i + 1 < st.size())
		{
			good &= R(0, 1) < st[i].intersect(st[i + 1]);
		}

		if (good)
		{
			for (int x : cc[st[i].idx])
				ans.pb(x);
		}
	}

	sort(ans.begin(), ans.end());

	for (int i = 0; i < ans.size(); i++)
	{
		if (i)
			printf(" ");
		printf("%d", ans[i]);
	}

	return 0;
}


#include <iostream>
#include <cstdio>
#include <string>
#include <string.h>
#include <queue>
#include <math.h>
#include <cmath>
#include <map>
#include <set>
#include <vector>
#include <algorithm>
#include <bitset>
#include <ctype.h>
#include <cassert>
#include <stack>
#include <fstream>
#include <unordered_map>
#include <ctime>
#include <functional>

using namespace std;

#define snd second
#define fst first
#define mp make_pair
#define ll long long
#define ull unsigned long long
#define ld long double
#define pb push_back
#define left _left
#define right _right

const ld pi = 3.14159265359;

template < typename T > T abs(T x)
{
    return x > 0 ? x : -x;
}

template < typename T > T sqr(T x)
{
	return x * x;
}

ll sign(ll x)
{
	if (x > 0)
		return 1;
	else if (x == 0)
		return 0;
	else
		return -1;
}

struct R
{
	ll n, d;

	R()
	{
		n = 0, d = 1;
	}

	R(ll x)
	{
		n = x, d = 1;
	}

	R(ll _n, ll _d)
	{
		n = _n, d = _d;
		if (d < 0)
			n = -n, d = -d;
	}

	R operator + (const R &r) const
	{
		return R(n * r.d + r.n * d, d * r.d);
	}

	R operator - (const R &r) const
	{

		return R(n * r.d - r.n * d, d * r.d);
	}

	R operator * (const R &r) const
	{
		return R(n * r.n, d * r.d);
	}

	R operator / (const R &r) const
	{
		return R(n * r.d, d * r.n);
	}

	bool operator < (const R &r) const
	{
		if (sign(n) != sign(r.n))
		{
			return n < r.n;
		}
		else
		{
			if (sign(n) == -1)
			{
				return R(-r.n, r.d) < R(-n, d);
			}
		}

		ll x = n / d;
		ll y = r.n / r.d;

		if (x < y)
			return true;
		else if (x == y)
		{
			ll n1 = n % d;
			ll n2 = r.n % r.d;
			if (n1 == 0)
			{
				if (n2 == 0)
					return false;
				return true;
			}
			else if (n2 == 0)
				return false;

			return R(r.d, n2) < R(d, n1);
		}
		else
		{
			return false;
		}
	}

	bool operator == (const R &r) const
	{
		return !(*this < r) && !(r < *this);
	}
};
/*
1/a + x * (1/b - 1/a) = 1/c + x * (1/d - 1/c)

(1/a - 1/c) / (1/d - 1/c - 1/b + 1/a) =
*/

struct line
{
	// a + (b - a) * x = 0;
	ll a, b;
	int idx;

	line()
	{

	}

	bool operator < (const line &l) const
	{
		return mp(R(1, b) - R(1, a), R(1, a)) < mp(R(1, l.b) - R(1, l.a), R(1, l.a));
	}

	//(a2 - a) * (b2 * b) / (a2 * b * a - b2 * b * a - a2 * b2 * a + a2 * b2 * b)

	R intersect(const line &l) const
	{
		return R((l.a - a) * (l.b * b), (l.a * b * a - l.b * b * a - l.a * l.b * a + l.a * l.b * b));
	}
};

int main()
{
	//srand(time(NULL));
	//gen();
//	freopen("a.in", "r", stdin);
//	freopen("a.out", "w", stdout);

	int n;
	scanf("%d", &n);
	//n = 200000;

	vector < line > a;

	for (int i = 1; i <= n; i++)
	{
		int x, y;
		scanf("%d %d", &x, &y);
		//x = rand() % 10000 + 1;
		//y = rand() % 10000 + 1;
		line l;
		l.a = x;
		l.b = y;
		l.idx = i;
		a.pb(l);
	}

	sort(a.begin(), a.end());
	reverse(a.begin(), a.end());

	vector < line > st;

	map < int, vector < int > > cc;
	int p = 0;
	for (int i = 0; i < n; i++)
	{
		int j = i;
		while (j < n && a[i].a == a[j].a && a[i].b == a[j].b)
		{
			j++;
		}

		for (int h = i; h < j; h++)
			cc[a[i].idx].pb(a[h].idx);

		a[p++] = a[i];
		//cerr << a[i].idx << endl;
		i = j - 1;
	}

	a.resize(p);

	for (auto l : a)
	{
		while (!st.empty())
		{
			if (R(1, st.back().b) - R(1, st.back().a) == R(1, l.b) - R(1, l.a))
				st.pop_back();
			else
				break;
		}

		while (st.size() > 1)
		{
			auto x1 = st[st.size() - 2].intersect(l);
			auto x2 = st.back().intersect(st[st.size() - 2]);

			if (x1 < x2)
				st.pop_back();
			else
				break;
		}

		st.pb(l);
	}

	vector < int > ans;

	for (int i = 0; i < st.size(); i++)
	{
		bool good = true;

		if (i)
		{
			good &= st[i - 1].intersect(st[i]) < R(1, 1);
		}

		if (i + 1 < st.size())
		{
			good &= R(0, 1) < st[i].intersect(st[i + 1]);
		}

		if (good)
		{
			for (int x : cc[st[i].idx])
				ans.pb(x);
		}
	}

	sort(ans.begin(), ans.end());

	for (int i = 0; i < ans.size(); i++)
	{
		if (i)
			printf(" ");
		printf("%d", ans[i]);
	}

	return 0;
}


#include <bits/stdc++.h>
using namespace std;
#define sqr(x) ((x)*(x))
#define sz(v) int(v.size())
#define par make_pair
#define pb push_back
#define fi first
#define se second
#define endl '\n'
template<class X, class Y> void amax(X& x, const Y& y){if(x < y) x = y;}
template<class X, class Y> void amin(X& x, const Y& y){if(x > y) x = y;}
typedef vector<int> vi; typedef pair<int, int> ii; typedef long long ll; typedef long double ld;
const int INF = 1e9 + 10; const ll INFL = (ll)1e18 + 10;
const int MAX = 2e5 + 10;

struct point{
    int x, y;

    ii mp(){
        return par(x, y);
    }

    ii mp() const {
        return par(x, y);
    }

    ii mpr(){
        return par(y, x);
    }

    ii mpr() const {
        return par(y, x);
    }

    ll dist2(const point &p) {
        return sqr(x - p.x) + sqr(y - p.y);
    }

    ll dist2(const point &p) const {
        return sqr(x - p.x) + sqr(y - p.y);
    }
};

bool operator< (const point &ls, const point &rs){
    return ls.mp() < rs.mp();
}

bool operator== (const point &ls, const point &rs){
    return ls.mp() == rs.mp();
}

int n;
point a[MAX];
map<ii, vi> mp;
point o, l;

ll ccw(const point &p1, const point &p2, const point &p3){
    return (ll)(p1.x - p2.x)*(p1.y - p3.y)*p3.x*p2.y - (ll)(p1.y - p2.y)*(p1.x - p3.x)*p2.x*p3.y;
}

bool comp(const point &ls, const point &rs){
    ll x = ccw(o, ls, rs);
    if(x != 0) return x < 0;
    return o.dist2(ls) < o.dist2(rs);
}

bool dcomp(const point &ls, const point &rs){
    return ls.mpr() > rs.mpr();
}

bool lcomp(const point &ls, const point &rs){
    return ls.mp() > rs.mp();
}

void process(){
    cin >> n;
    for(int i = 1; i <= n; i++){
        cin >> a[i].x >> a[i].y;
        mp[a[i].mp()].pb(i);
    }

    sort(a + 1, a + n + 1);
    n = distance(a + 1, unique(a + 1, a + n + 1));

    o = *min_element(a + 1, a + n + 1, dcomp);
    l = *min_element(a + 1, a + n + 1, lcomp);

    if(n == 1){
        for(auto x : mp[a[1].mp()]) cout << x << " ";
        return;
    }

    if(o == l){
        for(auto x : mp[o.mp()]) cout << x << " ";
        return;
    }

    sort(a + 1, a + n + 1, comp);

    vector<point> ch;
    ch.pb(a[1]); ch.pb(a[2]);
    for(int i = 3; i <= n; i++){
        if(ch.back() == l) break;
        while(sz(ch) > 1 && ccw(ch[sz(ch) - 2], ch[sz(ch) - 1], a[i]) > 0) ch.pop_back();
        ch.pb(a[i]);
    }

    vi ans;
    for(auto p : ch)
    for(auto x : mp[p.mp()]) ans.pb(x);

    sort(ans.begin(), ans.end());

    for(auto x : ans) cout << x << " ";
}

int main(){
    ios_base::sync_with_stdio(false);
    //~ cin.tie(nullptr);
    //~ cout << fixed; cout.precision(10);
    //~ freopen("c.in", "r", stdin);
    process();
}


#include <bits/stdc++.h>
using namespace std;
#define sqr(x) ((x)*(x))
#define sz(v) int(v.size())
#define par make_pair
#define pb push_back
#define fi first
#define se second
#define endl '\n'
template<class X, class Y> void amax(X& x, const Y& y){if(x < y) x = y;}
template<class X, class Y> void amin(X& x, const Y& y){if(x > y) x = y;}
typedef vector<int> vi; typedef pair<int, int> ii; typedef long long ll; typedef long double ld;
const int INF = 1e9 + 10; const ll INFL = (ll)1e18 + 10;
const int MAX = 2e5 + 10;

struct ctt{
    int x, y;
    int id;
};

int n;
ctt a[MAX];

ll ccw(const ctt &p1, const ctt &p2, const ctt &p3){
    return (ll)(p1.x - p2.x)*(p1.y - p3.y)*p3.x*p2.y - (ll)(p1.y - p2.y)*(p1.x - p3.x)*p2.x*p3.y;
}

bool comp(const ctt &ls, const ctt &rs){
    return ccw(a[1], ls, rs) > 0;
}

void process(){
    cin >> n;
    for(int i = 1; i <= n; i++){
        cin >> a[i].x >> a[i].y;
        a[i].id = i;
    }

    if(n == 1){
        cout << 1;
        return;
    }

    for(int i = 2; i <= n; i++){
        if(par(a[i].y, a[i].x) >= par(a[1].y, a[1].x)) swap(a[i], a[1]);
    }
    sort(a + 2, a + n + 1, comp);

    vector<ctt> ch;
    ch.pb(a[1]); ch.pb(a[2]);
    for(int i = 3; i <= n; i++){
        while(sz(ch) > 1 && ccw(ch[sz(ch) - 2], ch[sz(ch) - 1], a[i]) < 0) ch.pop_back();
        ch.pb(a[i]);
    }

    vi ans;
    for(int i = 0; i < sz(ch); i++) if(par(ch[i].x, ch[i].y) == par(ch[0].x, ch[0].y)) ans.pb(ch[i].id);

    int pos = 0;
    for(int i = 1; i < sz(ch); i++)
    if(par(ch[i].x, ch[i].y) > par(ch[pos].x, ch[pos].y)){
        pos = i;
    }
    if(pos != 0){
        for(int i = pos; i < sz(ch); i++) ans.pb(ch[i].id);
    }
    sort(ans.begin(), ans.end());
    ans.resize(distance(ans.begin(), unique(ans.begin(), ans.end())));

    for(auto x : ans) cout << x << " ";
}

int main(){
    ios_base::sync_with_stdio(false);
    //~ cin.tie(nullptr);
    //~ cout << fixed; cout.precision(10);
    //~ freopen("c.in", "r", stdin);
    process();
}


#include <bits/stdc++.h>
using namespace std;
#define sqr(x) ((x)*(x))
#define sz(v) int(v.size())
#define par make_pair
#define pb push_back
#define fi first
#define se second
#define endl '\n'
template<class X, class Y> void amax(X& x, const Y& y){if(x < y) x = y;}
template<class X, class Y> void amin(X& x, const Y& y){if(x > y) x = y;}
typedef vector<int> vi; typedef pair<int, int> ii; typedef long long ll; typedef long double ld;
const int INF = 1e9 + 10; const ll INFL = (ll)1e18 + 10;
const int MAX = 2e5 + 10;

int n, m;
pair<ii, int> a[MAX];
bool res[MAX];
int fe[MAX];

void update(int p, int val){
    for(; p <= m; p += p & -p) amax(fe[p], val);
}

int query(int p){
    int res = 0;
    for(; p >= 1; p -= p & -p) amax(res, fe[p]);
    return res;
}

void process(){
    cin >> n;
    for(int i = 1; i <= n; i++){
        a[i].se = i;
        cin >> a[i].fi.fi >> a[i].fi.se;
        amax(m, a[i].fi.fi);
    }
    sort(a + 1, a + n + 1, greater<pair<ii, int>>());

    for(int go = 1; go <= n; ){
        int to = go;
        while(to < n && a[to + 1].fi == a[go].fi) to++;

        int x = query(m - a[go].fi.fi + 1);
        if(x < a[go].fi.se){
            for(int i = go; i <= to; i++) res[a[i].se] = true;
        }
        update(m - a[go].fi.fi + 1, a[go].fi.se);

        go = to + 1;
    }

    for(int i = 1; i <= n; i++) if(res[i]) cout << i << " ";
}

int main(){
    ios_base::sync_with_stdio(false);
    //~ cin.tie(nullptr);
    //~ cout << fixed; cout.precision(10);
    //~ freopen("c.in", "r", stdin);
    process();
}


#include <bits/stdc++.h>
using namespace std;
#define sqr(x) ((x)*(x))
#define sz(v) int(v.size())
#define par make_pair
#define pb push_back
#define fi first
#define se second
#define endl '\n'
template<class X, class Y> void amax(X& x, const Y& y){if(x < y) x = y;}
template<class X, class Y> void amin(X& x, const Y& y){if(x > y) x = y;}
typedef vector<int> vi; typedef pair<int, int> ii; typedef long long ll; typedef long double ld;
const int INF = 1e9 + 10; const ll INFL = (ll)1e18 + 10;
const int MAX = 2e5 + 10;

struct ctt{
    int x, y;
    int id;

    int dist2(const point &p){
        return sqr(x - p.x) + sqr(y - p.y);
    }

    int dist2(const point &p) const{
        return sqr(x - p.x) + sqr(y - p.y);
    }
};

int n;
ctt a[MAX];

ll ccw(const ctt &p1, const ctt &p2, const ctt &p3){
    return (ll)(p1.x - p2.x)*(p1.y - p3.y)*p3.x*p2.y - (ll)(p1.y - p2.y)*(p1.x - p3.x)*p2.x*p3.y;
}

bool comp(const ctt &ls, const ctt &rs){
    ll x = ccw(a[1], ls, rs);
    if(x != 0) return x > 0;
    return a[1].dist2(ls) < a[1].dist2(rs);
}

void process(){
    cin >> n;
    for(int i = 1; i <= n; i++){
        cin >> a[i].x >> a[i].y;
        a[i].id = i;
    }

    if(n == 1){
        cout << 1;
        return;
    }

    for(int i = 2; i <= n; i++){
        if(par(a[i].y, a[i].x) >= par(a[1].y, a[1].x)) swap(a[i], a[1]);
    }
    sort(a + 2, a + n + 1, comp);

    vector<ctt> ch;
    ch.pb(a[1]); ch.pb(a[2]);
    for(int i = 3; i <= n; i++){
        while(sz(ch) > 1 && ccw(ch[sz(ch) - 2], ch[sz(ch) - 1], a[i]) < 0) ch.pop_back();
        ch.pb(a[i]);
    }

    vi ans;
    for(int i = 0; i < sz(ch); i++) if(par(ch[i].x, ch[i].y) == par(ch[0].x, ch[0].y)) ans.pb(ch[i].id);

    int pos = 0;
    for(int i = 1; i < sz(ch); i++)
    if(par(ch[i].x, ch[i].y) > par(ch[pos].x, ch[pos].y)){
        pos = i;
    }
    if(pos != 0){
        for(int i = pos; i < sz(ch); i++) ans.pb(ch[i].id);
    }
    sort(ans.begin(), ans.end());
    ans.resize(distance(ans.begin(), unique(ans.begin(), ans.end())));

    for(auto x : ans) cout << x << " ";
}

int main(){
    ios_base::sync_with_stdio(false);
    //~ cin.tie(nullptr);
    //~ cout << fixed; cout.precision(10);
    //~ freopen("c.in", "r", stdin);
    process();
}


#include <bits/stdc++.h>
using namespace std;
#define sqr(x) ((x)*(x))
#define sz(v) int(v.size())
#define par make_pair
#define pb push_back
#define fi first
#define se second
#define endl '\n'
template<class X, class Y> void amax(X& x, const Y& y){if(x < y) x = y;}
template<class X, class Y> void amin(X& x, const Y& y){if(x > y) x = y;}
typedef vector<int> vi; typedef pair<int, int> ii; typedef long long ll; typedef long double ld;
const int INF = 1e9 + 10; const ll INFL = (ll)1e18 + 10;
const int MAX = 2e5 + 10;

struct ctt{
    int x, y;
    int id;
};

int n;
ctt a[MAX];

ll ccw(const ctt &p1, const ctt &p2, const ctt &p3){
    return (ll)(p1.x - p2.x)*(p1.y - p3.y)*p3.x*p2.y - (ll)(p1.y - p2.y)*(p1.x - p3.x)*p2.x*p3.y;
}

bool comp(const ctt &ls, const ctt &rs){
    return ccw(a[1], ls, rs) > 0;
}

void process(){
    cin >> n;
    for(int i = 1; i <= n; i++){
        cin >> a[i].x >> a[i].y;
        a[i].id = i;
    }

    if(n == 1){
        cout << 1;
        return;
    }
    if(n == 2){
        ii p1 = par(a[1].x, a[1].y), p2 = par(a[2].x, a[2].y);
        if(p1 > p2){
            cout << 1;
            return;
        }else if(p1 < p2){
            cout << 2;
            return;
        }else{
            cout << "1 2";
            return;
        }
    }

    for(int i = 2; i <= n; i++){
        if(par(a[i].y, a[i].x) >= par(a[1].y, a[1].x)) swap(a[i], a[1]);
    }
    sort(a + 2, a + n + 1, comp);

    vector<ctt> ch;
    ch.pb(a[1]); ch.pb(a[2]);
    for(int i = 3; i <= n; i++){
        while(sz(ch) > 1 && ccw(ch[sz(ch) - 2], ch[sz(ch) - 1], a[i]) < 0) ch.pop_back();
        ch.pb(a[i]);
    }

    vi ans;
    for(int i = 0; i < sz(ch); i++) if(par(ch[i].x, ch[i].y) == par(ch[0].x, ch[0].y)) ans.pb(ch[i].id);

    int pos = 0;
    for(int i = 1; i < sz(ch); i++)
    if(par(ch[i].x, ch[i].y) > par(ch[pos].x, ch[pos].y)){
        pos = i;
    }
    for(int i = pos; i < sz(ch); i++) ans.pb(ch[i].id);
    sort(ans.begin(), ans.end());
    ans.resize(distance(ans.begin(), unique(ans.begin(), ans.end())));

    for(auto x : ans) cout << x << " ";
}

int main(){
    ios_base::sync_with_stdio(false);
    //~ cin.tie(nullptr);
    //~ cout << fixed; cout.precision(10);
    //~ freopen("c.in", "r", stdin);
    process();
}


#include <bits/stdc++.h>
using namespace std;
#define sqr(x) ((x)*(x))
#define sz(v) int(v.size())
#define par make_pair
#define pb push_back
#define fi first
#define se second
#define endl '\n'
template<class X, class Y> void amax(X& x, const Y& y){if(x < y) x = y;}
template<class X, class Y> void amin(X& x, const Y& y){if(x > y) x = y;}
typedef vector<int> vi; typedef pair<int, int> ii; typedef long long ll; typedef long double ld;
const int INF = 1e9 + 10; const ll INFL = (ll)1e18 + 10;
const int MAX = 2e5 + 10;

struct ctt{
    int x, y;
    int id;
};

int n;
ctt a[MAX];

ll ccw(const ctt &p1, const ctt &p2, const ctt &p3){
    return (ll)(p1.x - p2.x)*(p1.y - p3.y)*p3.x*p2.y - (ll)(p1.y - p2.y)*(p1.x - p3.x)*p2.x*p3.y;
}

bool comp(const ctt &ls, const ctt &rs){
    return ccw(a[1], ls, rs) > 0;
}

void process(){
    cin >> n;
    for(int i = 1; i <= n; i++){
        cin >> a[i].x >> a[i].y;
        a[i].id = i;
    }

    if(n == 1){
        cout << 1;
        return;
    }
    if(n == 2){
        ii p1 = par(a[1].x, a[1].y), p2 = par(a[2].x, a[2].y);
        if(p1 > p2){
            cout << 1;
            return;
        }else if(p1 < p2){
            cout << 2;
            return;
        }else{
            cout << "1 2";
            return;
        }
    }

    for(int i = 2; i <= n; i++){
        if(par(a[i].y, a[i].x) >= par(a[1].y, a[1].x)) swap(a[i], a[1]);
    }
    sort(a + 2, a + n + 1, comp);

    vector<ctt> ch;
    ch.pb(a[1]); ch.pb(a[2]);
    for(int i = 3; i <= n; i++){
        int len = sz(ch);
        while(len > 1 && ccw(ch[len - 2], ch[len - 1], a[i]) < 0) ch.pop_back();
        ch.pb(a[i]);
    }

    vi ans;
    for(int i = 0; i < sz(ch); i++) if(par(ch[i].x, ch[i].y) == par(ch[0].x, ch[0].y)) ans.pb(ch[i].id);

    int pos = 0;
    for(int i = 1; i < sz(ch); i++)
    if(par(ch[i].x, ch[i].y) > par(ch[pos].x, ch[pos].y)){
        pos = i;
    }
    for(int i = pos; i < sz(ch); i++) ans.pb(ch[i].id);
    sort(ans.begin(), ans.end());
    ans.resize(distance(ans.begin(), unique(ans.begin(), ans.end())));

    for(auto x : ans) cout << x << " ";
}

int main(){
    ios_base::sync_with_stdio(false);
    //~ cin.tie(nullptr);
    //~ cout << fixed; cout.precision(10);
    //~ freopen("c.in", "r", stdin);
    process();
}


#include <bits/stdc++.h>
using namespace std;
#define sqr(x) ((x)*(x))
#define sz(v) int(v.size())
#define par make_pair
#define pb push_back
#define fi first
#define se second
#define endl '\n'
template<class X, class Y> void amax(X& x, const Y& y){if(x < y) x = y;}
template<class X, class Y> void amin(X& x, const Y& y){if(x > y) x = y;}
typedef vector<int> vi; typedef pair<int, int> ii; typedef long long ll; typedef long double ld;
const int INF = 1e9 + 10; const ll INFL = (ll)1e18 + 10;
const int MAX = 2e5 + 10;

struct point{
    int x, y;

    ii mp(){
        return par(x, y);
    }

    ii mp() const {
        return par(x, y);
    }

    ii mpr(){
        return par(y, x);
    }

    ii mpr() const {
        return par(y, x);
    }
};

bool operator< (const point &ls, const point &rs){
    return ls.mp() < rs.mp();
}

bool operator== (const point &ls, const point &rs){
    return ls.mp() == rs.mp();
}

int n;
point a[MAX];
map<ii, vi> mp;
point o, l;

ll ccw(const point &p1, const point &p2, const point &p3){
    return (ll)(p1.x - p2.x)*(p1.y - p3.y)*p3.x*p2.y - (ll)(p1.y - p2.y)*(p1.x - p3.x)*p2.x*p3.y;
}

bool comp(const point &ls, const point &rs){
    return ccw(o, ls, rs) < 0;
}

bool dcomp(const point &ls, const point &rs){
    return ls.mpr() > rs.mpr();
}

bool lcomp(const point &ls, const point &rs){
    return ls.mp() > rs.mp();
}

void process(){
    cin >> n;
    for(int i = 1; i <= n; i++){
        cin >> a[i].x >> a[i].y;
        mp[a[i].mp()].pb(i);
    }

    sort(a + 1, a + n + 1);
    n = distance(a + 1, unique(a + 1, a + n + 1));

    o = *min_element(a + 1, a + n + 1, dcomp);
    l = *min_element(a + 1, a + n + 1, lcomp);

    if(n == 1){
        for(auto x : mp[a[1].mp()]) cout << x << " ";
        return;
    }

    if(o == l){
        for(auto x : mp[o.mp()]) cout << x << " ";
        return;
    }

    for(int i = 2; i <= n; i++) if(dcomp(a[i], a[1])) swap(a[i], a[1]);

    sort(a + 1, a + n + 1, comp);

    //~ for(int i = 1; i <= n; i++) cout << a[i].x << " " << a[i].y << endl;

    //~ cout << ccw(a[3], a[2], a[1]) << endl;

    vector<point> ch;
    ch.pb(a[1]); ch.pb(a[2]);
    for(int i = 3; i <= n; i++){
        if(ch.back() == l) break;
        while(sz(ch) > 1 && ccw(ch[sz(ch) - 2], ch[sz(ch) - 1], a[i]) > 0) ch.pop_back();
        ch.pb(a[i]);
    }

    vi ans;
    for(auto p : ch)
    for(auto x : mp[p.mp()]) ans.pb(x);

    sort(ans.begin(), ans.end());

    for(auto x : ans) cout << x << " ";
}

int main(){
    ios_base::sync_with_stdio(false);
    //~ cin.tie(nullptr);
    //~ cout << fixed; cout.precision(10);
    //~ freopen("c.in", "r", stdin);
    process();
}


#include <bits/stdc++.h>
using namespace std;
#define sqr(x) ((x)*(x))
#define sz(v) int(v.size())
#define par make_pair
#define pb push_back
#define fi first
#define se second
#define endl '\n'
template<class X, class Y> void amax(X& x, const Y& y){if(x < y) x = y;}
template<class X, class Y> void amin(X& x, const Y& y){if(x > y) x = y;}
typedef vector<int> vi; typedef pair<int, int> ii; typedef long long ll; typedef long double ld;
const int INF = 1e9 + 10; const ll INFL = (ll)1e18 + 10;
const int MAX = 2e5 + 10;

struct ctt{
    int x, y;
    int id;

    int dist2(const ctt &p){
        return sqr(x - p.x) + sqr(y - p.y);
    }

    int dist2(const ctt &p) const{
        return sqr(x - p.x) + sqr(y - p.y);
    }
};

int n;
ctt a[MAX];

ll ccw(const ctt &p1, const ctt &p2, const ctt &p3){
    return (ll)(p1.x - p2.x)*(p1.y - p3.y)*p3.x*p2.y - (ll)(p1.y - p2.y)*(p1.x - p3.x)*p2.x*p3.y;
}

bool comp(const ctt &ls, const ctt &rs){
    ll x = ccw(a[1], ls, rs);
    if(x != 0) return x > 0;
    return a[1].dist2(ls) < a[1].dist2(rs);
}

void process(){
    cin >> n;
    for(int i = 1; i <= n; i++){
        cin >> a[i].x >> a[i].y;
        a[i].id = i;
    }

    if(n == 1){
        cout << 1;
        return;
    }

    for(int i = 2; i <= n; i++){
        if(par(a[i].y, a[i].x) >= par(a[1].y, a[1].x)) swap(a[i], a[1]);
    }
    sort(a + 2, a + n + 1, comp);

    vector<ctt> ch;
    ch.pb(a[1]); ch.pb(a[2]);
    for(int i = 3; i <= n; i++){
        while(sz(ch) > 1 && ccw(ch[sz(ch) - 2], ch[sz(ch) - 1], a[i]) < 0) ch.pop_back();
        ch.pb(a[i]);
    }

    vi ans;
    for(int i = 0; i < sz(ch); i++) if(par(ch[i].x, ch[i].y) == par(ch[0].x, ch[0].y)) ans.pb(ch[i].id);

    int pos = 0;
    for(int i = 1; i < sz(ch); i++)
    if(par(ch[i].x, ch[i].y) > par(ch[pos].x, ch[pos].y)){
        pos = i;
    }
    if(pos != 0){
        for(int i = pos; i < sz(ch); i++) ans.pb(ch[i].id);
    }
    sort(ans.begin(), ans.end());
    ans.resize(distance(ans.begin(), unique(ans.begin(), ans.end())));

    for(auto x : ans) cout << x << " ";
}

int main(){
    ios_base::sync_with_stdio(false);
    //~ cin.tie(nullptr);
    //~ cout << fixed; cout.precision(10);
    //~ freopen("c.in", "r", stdin);
    process();
}


#include <cstdio>
#include <cmath>
#include <cstring>
#include <cstdlib>
#include <climits>
#include <ctime>
#include <queue>
#include <stack>
#include <algorithm>
#include <list>
#include <vector>
#include <set>
#include <map>
#include <iostream>
#include <deque>
#include <complex>
#include <string>
#include <iomanip>
#include <sstream>
#include <bitset>
#include <valarray>
#include <iterator>
#include <assert.h>
using namespace std;
typedef long long int ll;
typedef unsigned int uint;
typedef unsigned char uchar;
typedef unsigned long long ull;
typedef pair<int, int> pii;
typedef pair<ll, ll> pll;
typedef vector<int> vi;

#define REP(i,x) for(int i=0;i<(int)(x);i++)
#define REPS(i,x) for(int i=1;i<=(int)(x);i++)
#define RREP(i,x) for(int i=((int)(x)-1);i>=0;i--)
#define RREPS(i,x) for(int i=((int)(x));i>0;i--)
#define FOR(i,c) for(__typeof((c).begin())i=(c).begin();i!=(c).end();i++)
#define RFOR(i,c) for(__typeof((c).rbegin())i=(c).rbegin();i!=(c).rend();i++)
#define ALL(container) (container).begin(), (container).end()
#define RALL(container) (container).rbegin(), (container).rend()
#define SZ(container) ((int)container.size())
#define mp(a,b) make_pair(a, b)
#define pb push_back
#define eb emplace_back
#define UNIQUE(v) sort(ALL(v)); v.erase( unique(v.begin(), v.end()), v.end() );

template<class T> bool chmax(T &a, const T &b) { if (a<b) { a=b; return 1; } return 0; }
template<class T> bool chmin(T &a, const T &b) { if (a>b) { a=b; return 1; } return 0; }
template<class T> ostream& operator<<(ostream &os, const vector<T> &t) {
os<<"["; FOR(it,t) {if(it!=t.begin()) os<<","; os<<*it;} os<<"]"; return os;
}
template<class T> ostream& operator<<(ostream &os, const set<T> &t) {
os<<"{"; FOR(it,t) {if(it!=t.begin()) os<<","; os<<*it;} os<<"}"; return os;
}
template<class S, class T> ostream& operator<<(ostream &os, const pair<S,T> &t) { return os<<"("<<t.first<<","<<t.second<<")";}
template<class S, class T> pair<S,T> operator+(const pair<S,T> &s, const pair<S,T> &t){ return pair<S,T>(s.first+t.first, s.second+t.second);}
template<class S, class T> pair<S,T> operator-(const pair<S,T> &s, const pair<S,T> &t){ return pair<S,T>(s.first-t.first, s.second-t.second);}
typedef long long RInteger;
struct Rational{
	RInteger p,q;
	Rational(RInteger pp=1,RInteger qq=1):p(pp),q(qq){
		if(q==0)p=1;else if(p==0)q=1;
		else{
			if(q<0)q=-q,p=-p;
			RInteger g=__gcd(abs(p),q);
			p/=g;q/=g;
		}
	};
};
Rational operator+(const Rational &a,const Rational &b){
	return Rational(a.p*b.q+b.p*a.q,a.q*b.q);
}
Rational operator-(const Rational &a){
	return Rational(-a.p,a.q);
}
Rational operator-(const Rational &a,const Rational &b){
	return Rational(a.p*b.q-b.p*a.q,a.q*b.q);
}
Rational operator*(const Rational &a,const Rational &b){
	ll g1=__gcd(a.p, b.q);
	ll g2=__gcd(a.q, b.p);
	return Rational((a.p/g1)*(b.p/g2),(a.q/g2)*(b.q/g1));
}
Rational operator/(const Rational &a,const Rational &b){
	ll g1=__gcd(a.p, b.p);
	ll g2=__gcd(a.q, b.q);
	return Rational((a.p/g1)*(b.q/g2),(a.q/g2)*(b.p/g1));
}
bool operator==(const Rational &a,const Rational &b){
	return (a.p==b.p)&&(a.q==b.q);
}
bool operator<(const Rational &a,const Rational &b){
	return a.p*b.q<b.p*a.q;
}
bool operator>(const Rational &a,const Rational &b){return b<a;}
bool operator<=(const Rational &a,const Rational &b){return (a<b)||(a==b);}
bool operator>=(const Rational &a,const Rational &b){return (a>b)||(a==b);}
bool operator!=(const Rational &a,const Rational &b){return !(b==a);}

typedef pair<Rational, Rational> P;

int n, m;

Rational outp(const P &x, const P &y){
	return x.first*y.second - x.second*y.first;
}

main(){
	ios::sync_with_stdio(0);
	cin.tie(0);
	scanf("%d", &n);
	vector<P> d;
	int mx = 0, my = 0;
	REP(i, n){
		int x, y;
		scanf("%d%d", &x, &y);
		d.eb(Rational(1, x), Rational(1, y));
	}
	vector<P> g = d;
	g.eb(10, 0);
	g.eb(0, 10);
	sort(ALL(g), [](const P &p, const P &q){
		if(p.first == q.first) return p.second > q.second;
		return p.first < q.first;
	});
	UNIQUE(g);
	vector<P> st;
	REP(i, g.size()){
		while(st.size()>1 && outp(st.back()-st[st.size()-2], g[i]-st[st.size()-2]) < 0) st.pop_back();
		st.pb(g[i]);
	}

	set<P> p;
	REP(i, st.size()) p.insert(st[i]);
	vi ans;
//	REP(i, n) if(p.count(d[i]) || !sig((R)1/mx - d[i].X) || !sig((R)1/my - d[i].Y)) ans.pb(i+1);
	REP(i, n) if(p.count(d[i])) ans.pb(i+1);
	sort(ALL(ans));
	REP(i, ans.size()) cout << ans[i] << " \n"[i+1==ans.size()];
	return 0;
}


#include <cstdio>
#include <cmath>
#include <cstring>
#include <cstdlib>
#include <climits>
#include <ctime>
#include <queue>
#include <stack>
#include <algorithm>
#include <list>
#include <vector>
#include <set>
#include <map>
#include <iostream>
#include <deque>
#include <complex>
#include <string>
#include <iomanip>
#include <sstream>
#include <bitset>
#include <valarray>
#include <iterator>
#include <assert.h>
using namespace std;
typedef long long int ll;
typedef unsigned int uint;
typedef unsigned char uchar;
typedef unsigned long long ull;
typedef pair<int, int> pii;
typedef pair<ll, ll> pll;
typedef vector<int> vi;

#define REP(i,x) for(int i=0;i<(int)(x);i++)
#define REPS(i,x) for(int i=1;i<=(int)(x);i++)
#define RREP(i,x) for(int i=((int)(x)-1);i>=0;i--)
#define RREPS(i,x) for(int i=((int)(x));i>0;i--)
#define FOR(i,c) for(__typeof((c).begin())i=(c).begin();i!=(c).end();i++)
#define RFOR(i,c) for(__typeof((c).rbegin())i=(c).rbegin();i!=(c).rend();i++)
#define ALL(container) (container).begin(), (container).end()
#define RALL(container) (container).rbegin(), (container).rend()
#define SZ(container) ((int)container.size())
#define mp(a,b) make_pair(a, b)
#define pb push_back
#define eb emplace_back
#define UNIQUE(v) sort(ALL(v)); v.erase( unique(v.begin(), v.end()), v.end() );

template<class T> bool chmax(T &a, const T &b) { if (a<b) { a=b; return 1; } return 0; }
template<class T> bool chmin(T &a, const T &b) { if (a>b) { a=b; return 1; } return 0; }
template<class T> ostream& operator<<(ostream &os, const vector<T> &t) {
os<<"["; FOR(it,t) {if(it!=t.begin()) os<<","; os<<*it;} os<<"]"; return os;
}
template<class T> ostream& operator<<(ostream &os, const set<T> &t) {
os<<"{"; FOR(it,t) {if(it!=t.begin()) os<<","; os<<*it;} os<<"}"; return os;
}
template<class S, class T> ostream& operator<<(ostream &os, const pair<S,T> &t) { return os<<"("<<t.first<<","<<t.second<<")";}
template<class S, class T> pair<S,T> operator+(const pair<S,T> &s, const pair<S,T> &t){ return pair<S,T>(s.first+t.first, s.second+t.second);}
template<class S, class T> pair<S,T> operator-(const pair<S,T> &s, const pair<S,T> &t){ return pair<S,T>(s.first-t.first, s.second-t.second);}
typedef long long RInteger;
struct Rational{
	RInteger p,q;
	Rational(RInteger pp=1,RInteger qq=1):p(pp),q(qq){
		if(q==0)p=1;else if(p==0)q=1;
		else{
			if(q<0)q=-q,p=-p;
			RInteger g=__gcd(abs(p),q);
			p/=g;q/=g;
		}
	};
};
Rational operator+(const Rational &a,const Rational &b){
	return Rational(a.p*b.q+b.p*a.q,a.q*b.q);
}
Rational operator-(const Rational &a){
	return Rational(-a.p,a.q);
}
Rational operator-(const Rational &a,const Rational &b){
	return Rational(a.p*b.q-b.p*a.q,a.q*b.q);
}
Rational operator*(const Rational &a,const Rational &b){
	return Rational((a.p)*(b.p),(a.q)*(b.q));
}
Rational operator/(const Rational &a,const Rational &b){
	return Rational((a.p)*(b.q),(a.q)*(b.p));
}
bool operator==(const Rational &a,const Rational &b){
	return (a.p==b.p)&&(a.q==b.q);
}
bool cmp(const Rational &a,const Rational &b){
	return (long double)(a.p)*(b.q)<(long double)(a.q)*(b.p);
}
bool operator<(const Rational &a,const Rational &b){
	return (a.p)*(b.q)<(a.q)*(b.p);
}
bool operator>(const Rational &a,const Rational &b){return b<a;}
bool operator<=(const Rational &a,const Rational &b){return (a<b)||(a==b);}
bool operator>=(const Rational &a,const Rational &b){return (a>b)||(a==b);}
bool operator!=(const Rational &a,const Rational &b){return !(b==a);}

typedef pair<Rational, Rational> P;

int n, m;

int cw(const P &x, const P &y){
	return cmp(x.first*y.second, x.second*y.first);
}

main(){
	ios::sync_with_stdio(0);
	cin.tie(0);
	scanf("%d", &n);
	vector<P> d;
	REP(i, n){
		int x, y;
		scanf("%d%d", &x, &y);
		d.eb(Rational(1, x), Rational(1, y));
	}
	vector<P> g = d;
	g.eb(10, 0);
	g.eb(0, 10);
	sort(ALL(g));
	UNIQUE(g);
	vector<P> st;
	REP(i, g.size()){
		while(st.size()>1 && cw(st.back()-st[st.size()-2], g[i]-st[st.size()-2])) st.pop_back();
		st.pb(g[i]);
	}

	set<P> p;
	REP(i, st.size()) p.insert(st[i]);
	vi ans;
	REP(i, n) if(p.count(d[i])) ans.pb(i+1);
	sort(ALL(ans));
	REP(i, ans.size()) cout << ans[i] << " \n"[i+1==ans.size()];
	return 0;
}


#include <cstdio>
#include <cmath>
#include <cstring>
#include <cstdlib>
#include <climits>
#include <ctime>
#include <queue>
#include <stack>
#include <algorithm>
#include <list>
#include <vector>
#include <set>
#include <map>
#include <iostream>
#include <deque>
#include <complex>
#include <string>
#include <iomanip>
#include <sstream>
#include <bitset>
#include <valarray>
#include <iterator>
#include <assert.h>
using namespace std;
typedef long long int ll;
typedef unsigned int uint;
typedef unsigned char uchar;
typedef unsigned long long ull;
typedef pair<int, int> pii;
typedef pair<ll, ll> pll;
typedef vector<int> vi;

#define REP(i,x) for(int i=0;i<(int)(x);i++)
#define REPS(i,x) for(int i=1;i<=(int)(x);i++)
#define RREP(i,x) for(int i=((int)(x)-1);i>=0;i--)
#define RREPS(i,x) for(int i=((int)(x));i>0;i--)
#define FOR(i,c) for(__typeof((c).begin())i=(c).begin();i!=(c).end();i++)
#define RFOR(i,c) for(__typeof((c).rbegin())i=(c).rbegin();i!=(c).rend();i++)
#define ALL(container) (container).begin(), (container).end()
#define RALL(container) (container).rbegin(), (container).rend()
#define SZ(container) ((int)container.size())
#define mp(a,b) make_pair(a, b)
#define pb push_back
#define eb emplace_back
#define UNIQUE(v) sort(ALL(v)); v.erase( unique(v.begin(), v.end()), v.end() );

template<class T> bool chmax(T &a, const T &b) { if (a<b) { a=b; return 1; } return 0; }
template<class T> bool chmin(T &a, const T &b) { if (a>b) { a=b; return 1; } return 0; }
template<class T> ostream& operator<<(ostream &os, const vector<T> &t) {
os<<"["; FOR(it,t) {if(it!=t.begin()) os<<","; os<<*it;} os<<"]"; return os;
}
template<class T> ostream& operator<<(ostream &os, const set<T> &t) {
os<<"{"; FOR(it,t) {if(it!=t.begin()) os<<","; os<<*it;} os<<"}"; return os;
}
template<class S, class T> ostream& operator<<(ostream &os, const pair<S,T> &t) { return os<<"("<<t.first<<","<<t.second<<")";}
template<class S, class T> pair<S,T> operator+(const pair<S,T> &s, const pair<S,T> &t){ return pair<S,T>(s.first+t.first, s.second+t.second);}
template<class S, class T> pair<S,T> operator-(const pair<S,T> &s, const pair<S,T> &t){ return pair<S,T>(s.first-t.first, s.second-t.second);}

namespace geom{
#define X real()
#define Y imag()
#define at(i) ((*this)[i])
#define SELF (*this)
    enum {TRUE = 1, FALSE = 0, BORDER = -1};
    typedef int BOOL;
    typedef long double R;
    const R INF = 10;
    R EPS = 0;
    const R PI = 3.1415926535897932384626;
    inline int sig(const R &x) { return (abs(x) < EPS ? 0 : x > 0 ? 1 : -1); }
    inline BOOL less(const R &x, const R &y) {return sig(x-y) ? x < y : BORDER;}
    typedef complex<R> P;
    inline R norm(const P &p){return p.X*p.X+p.Y*p.Y;}
    inline R inp(const P& a, const P& b){return (conj(a)*b).X;}
    inline R outp(const P& a, const P& b){return (conj(a)*b).Y;}
    inline P unit(const P& p){return p/abs(p);}
    inline P proj(const P &s, const P &t){return t*inp(s, t)/norm(t);}
    inline int ccw(const P &s, const P &t, const P &p, int adv=0){
        int res = sig(outp(t-s, p-s));
        if(res || !adv) return res;
        if(sig(inp(t-s, p-s)) < 0) return -2;   // p-s-t
        if(sig(inp(s-t, p-t)) < 0) return 2;    // s-t-p
        return 0;                               // s-p-t
    }
    struct L : public vector<P>{    // line
        L(const P &p1, const P &p2){this->push_back(p1);this->push_back(p2);}
        L(){}
        P dir()const {return at(1) - at(0);}
        BOOL online(const P &p)const {return !sig(outp(p-at(0), dir()));}
    };
    struct S : public L{    // segment
        S(const P &p1, const P &p2):L(p1, p2){}
        S(){}
        BOOL online(const P &p)const {
            if(!sig(norm(p - at(0))) || !sig(norm(p - at(1)))) return BORDER;
            // 座標の二乗とEPSの差が大きすぎないように注意
            return !sig(outp(p-at(0), dir())) && inp(p-at(0), dir()) > EPS && inp(p-at(1), -dir()) > -EPS;
            //return !sig(abs(at(0)-p) + abs(at(1) - p) - abs(at(0) - at(1)));
        }
    };
    struct G : public vector<P>{
        G(size_type size=0):vector(size){}
        S edge(int i)const {return S(at(i), at(i+1 == size() ? 0 : i+1));}
        BOOL contains(const P &p)const {
            R sum = .0;
            REP(i, size()){
                if(S(at(i), at((i+1)%size())).online(p)) return BORDER; // online
                sum += arg((at(i) - p) / (at((i+1)%size()) - p));
            }
            return !!sig(sum);
        }
        G convex_hull(bool online = false) {
            if(size() < 2) return *this;
            sort(ALL(*this)); UNIQUE((*this));
            G r;
            r.resize((int)size()*2);
            int k=0;
            for(int i=0;i<size();r[k++]=at(i++))
                while(k>1 && ccw(r[k-2], r[k-1], at(i)) < 1-online) k--;
            int t = k;
            for(int i=(int)size()-1;i>=0;r[k++]=at(i--))
                while(k>t && ccw(r[k-2], r[k-1], at(i)) < 1-online) k--;
            r.resize(k-1);
            return r;
        }
    };
#undef SELF
#undef at
}

using namespace geom;

int f = 0;
namespace std{
    bool operator<(const P &a, const P &b){return sig(a.X-b.X) ? a.X < b.X : a.Y > b.Y+EPS;}
    bool operator==(const P &a, const P &b){return abs(a-b) < EPS;}
}

int n, m;

main(){
    ios::sync_with_stdio(0);
    cin.tie(0);
    scanf("%d", &n);
    vector<P> d(n);
    G g;
    int mx = 0, my = 0;
    REP(i, n){
        int x, y;
        scanf("%d%d", &x, &y);
        mx = max(mx, x);
        my = max(my, y);
        d[i] = P((R)1/x, (R)1/y);
        g.eb((R)1/x, (R)1/y);
    }
    g.eb(INF, 0);
    g.eb(0, INF);
    g = g.convex_hull(1);
    set<P> p;
    REP(i, g.size()) p.insert(g[i]);
    vi ans;
//  REP(i, n) if(p.count(d[i]) || !sig((R)1/mx - d[i].X) || !sig((R)1/my - d[i].Y)) ans.pb(i+1);
    REP(i, n) if(p.count(d[i])) ans.pb(i+1);
    sort(ALL(ans));
    REP(i, ans.size()) cout << ans[i] << " \n"[i+1==ans.size()];
    return 0;
}


#include <cstdio>
#include <cmath>
#include <cstring>
#include <cstdlib>
#include <climits>
#include <ctime>
#include <queue>
#include <stack>
#include <algorithm>
#include <list>
#include <vector>
#include <set>
#include <map>
#include <iostream>
#include <deque>
#include <complex>
#include <string>
#include <iomanip>
#include <sstream>
#include <bitset>
#include <valarray>
#include <iterator>
#include <assert.h>
using namespace std;
typedef long long int ll;
typedef unsigned int uint;
typedef unsigned char uchar;
typedef unsigned long long ull;
typedef pair<int, int> pii;
typedef pair<ll, ll> pll;
typedef vector<int> vi;

#define REP(i,x) for(int i=0;i<(int)(x);i++)
#define REPS(i,x) for(int i=1;i<=(int)(x);i++)
#define RREP(i,x) for(int i=((int)(x)-1);i>=0;i--)
#define RREPS(i,x) for(int i=((int)(x));i>0;i--)
#define FOR(i,c) for(__typeof((c).begin())i=(c).begin();i!=(c).end();i++)
#define RFOR(i,c) for(__typeof((c).rbegin())i=(c).rbegin();i!=(c).rend();i++)
#define ALL(container) (container).begin(), (container).end()
#define RALL(container) (container).rbegin(), (container).rend()
#define SZ(container) ((int)container.size())
#define mp(a,b) make_pair(a, b)
#define pb push_back
#define eb emplace_back
#define UNIQUE(v) sort(ALL(v)); v.erase( unique(v.begin(), v.end()), v.end() );

template<class T> bool chmax(T &a, const T &b) { if (a<b) { a=b; return 1; } return 0; }
template<class T> bool chmin(T &a, const T &b) { if (a>b) { a=b; return 1; } return 0; }
template<class T> ostream& operator<<(ostream &os, const vector<T> &t) {
os<<"["; FOR(it,t) {if(it!=t.begin()) os<<","; os<<*it;} os<<"]"; return os;
}
template<class T> ostream& operator<<(ostream &os, const set<T> &t) {
os<<"{"; FOR(it,t) {if(it!=t.begin()) os<<","; os<<*it;} os<<"}"; return os;
}
template<class S, class T> ostream& operator<<(ostream &os, const pair<S,T> &t) { return os<<"("<<t.first<<","<<t.second<<")";}
template<class S, class T> pair<S,T> operator+(const pair<S,T> &s, const pair<S,T> &t){ return pair<S,T>(s.first+t.first, s.second+t.second);}
template<class S, class T> pair<S,T> operator-(const pair<S,T> &s, const pair<S,T> &t){ return pair<S,T>(s.first-t.first, s.second-t.second);}
typedef long long RInteger;
struct Rational{
	RInteger p,q;
	Rational(RInteger pp=1,RInteger qq=1):p(pp),q(qq){
		if(q==0)p=1;else if(p==0)q=1;
		else{
			if(q<0)q=-q,p=-p;
			RInteger g=__gcd(abs(p),q);
			p/=g;q/=g;
		}
	};
};
Rational operator+(const Rational &a,const Rational &b){
	return Rational(a.p*b.q+b.p*a.q,a.q*b.q);
}
Rational operator-(const Rational &a){
	return Rational(-a.p,a.q);
}
Rational operator-(const Rational &a,const Rational &b){
	return Rational(a.p*b.q-b.p*a.q,a.q*b.q);
}
Rational operator*(const Rational &a,const Rational &b){
	return Rational((a.p)*(b.p),(a.q)*(b.q));
}
Rational operator/(const Rational &a,const Rational &b){
	return Rational((a.p)*(b.q),(a.q)*(b.p));
}
bool operator==(const Rational &a,const Rational &b){
	return (a.p==b.p)&&(a.q==b.q);
}
bool cmp(const Rational &a,const Rational &b){
	return (long double)(a.p)*(b.q)<(long double)(a.q)*(b.p);
}
bool operator<(const Rational &a,const Rational &b){
	return (a.p)*(b.q)<(a.q)*(b.p);
}
bool operator>(const Rational &a,const Rational &b){return b<a;}
bool operator<=(const Rational &a,const Rational &b){return (a<b)||(a==b);}
bool operator>=(const Rational &a,const Rational &b){return (a>b)||(a==b);}
bool operator!=(const Rational &a,const Rational &b){return !(b==a);}

typedef pair<Rational, Rational> P;

int n, m;

int cw(const P &x, const P &y){
	return cmp(x.first*y.second, x.second*y.first);
}

main(){
	ios::sync_with_stdio(0);
	cin.tie(0);
	scanf("%d", &n);
	vector<P> d;
	REP(i, n){
		int x, y;
		scanf("%d%d", &x, &y);
		d.eb(Rational(1, x), Rational(1, y));
	}
	vector<P> g = d;
	g.eb(1000, 0);
	g.eb(0, 1000);
	sort(ALL(g));
	UNIQUE(g);
	vector<P> st;
	REP(i, g.size()){
		while(st.size()>1 && cw(st.back()-st[st.size()-2], g[i]-st[st.size()-2])) st.pop_back();
		st.pb(g[i]);
	}

	set<P> p;
	REP(i, st.size()) p.insert(st[i]);
	vi ans;
	REP(i, n) if(p.count(d[i])) ans.pb(i+1);
	sort(ALL(ans));
	REP(i, ans.size()) cout << ans[i] << " \n"[i+1==ans.size()];
	return 0;
}