#include <iostream>
#include <vector>
#include <queue>
#include <stack>
#include <set>
#include <map>
#include <limits.h>
#include <algorithm>
#include <math.h>

using namespace std;

struct City
{
	int slaves, gold, index;

	bool operator<(const City other) const
	{
		return slaves < other.slaves;
	}

	bool operator==(const City other) const
	{
		return slaves == other.slaves;
	}
};

vector<set<City>> stairs = { { { -1, -1, -1} } };

bool fits_on_top(int index, City& city)
{
	auto it = stairs[index].lower_bound(city); //(get strictly smaller step by slaves) <- prev()!!!

	if (it == stairs[index].begin()) return false; //if it doesn't exists, the city won't fit on top
	
	if (prev(it).operator*().gold < city.gold) return true; //if the step is smaller in gold too, the city fits on top of it
	else return false;
}

void del(int index, City& city)
{
	auto it = stairs[index].lower_bound(city);
	while (it != stairs[index].end() && city.gold <= it.operator*().gold)
	{
		stairs[index].erase(*it);
		it = stairs[index].lower_bound(city);
	}
}

void insert_to_stair(int index, City& city)
{
	auto before = stairs[index].upper_bound(city); //(get smaller or equal step by slaves) <- prev()!!!

	if (before == stairs[index].begin()) //if the city has the least slaves
	{
		del(index, city);
		stairs[index].insert(city);
		return;
	}
	before = prev(before);

	auto after = stairs[index].lower_bound(city); //get bigger or equal step by slaves

	if (after == stairs[index].end()) //if the city has the most slaves
	{
		if (city.gold < prev(stairs[index].end()).operator*().gold)
		{
			stairs[index].insert(city);
		}
		return;
	}

	if (after == before) //if step is equal by slaves
	{
		if (city.slaves < after.operator*().gold)
		{
			del(index, city);
			stairs[index].insert(city);
		}
		return;
	}

	if (city.slaves == max(after.operator*().slaves, before.operator*().slaves) || city.gold == max(after.operator*().gold, before.operator*().gold))
	{
		return;
	}

	del(index, city);
	stairs[index].insert(city);
}

void process(City city)
{
	//binary search for the right stair
	int l = 0, r = stairs.size() - 1, m = 0;
	
	while (l < r)
	{
		m = (l + r) / 2;

		if (fits_on_top(m, city)) l = m + 1;
		else r = m;
	}

	//m is the index of the stair after the last it would fit on top of
	//m is the index of the stair where the current city should be put

	if (l == stairs.size() - 1 && fits_on_top(stairs.size()-1, city)) //needs a new stair
	{
		stairs.push_back({ city });
	}
	else
	{
		insert_to_stair(l, city);
	}
}

int main()
{
	iostream::sync_with_stdio(0);
	cin.tie(0);

	int n, i, j, slave, gold;
	cin >> n;


	for (int i = 0; i < n; i++)
	{
		cin >> slave >> gold;

		process({ slave, gold, i });
	}

	//backtracking, answering

	City current = stairs[stairs.size() - 1].begin().operator*();
	vector<int> out = {current.index};
	out.reserve(stairs.size());

	for (int i = stairs.size() - 2; i >= 1; i--)
	{
		current = prev(stairs[i].lower_bound(current)).operator*();
		out.push_back(current.index);
	}

	cout << out.size() << '\n';

	for (int i = out.size() - 1; i >= 0; i--)
	{
		cout << out[i]+1 << ' ';
	}
}