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

pair<long, long> a[100005]; // a[i] = {start, end}
long n, F[100005], vet[100005];
long b[100005]; // Mang luu chi so goc cua cuoc hop sau khi sort

int main() {
    cin >> n;
    for(long i = 1; i <= n; i++) {
        cin >> a[i].first >> a[i].second;
        b[i] = i; // Luu chi so goc
    }
    // Sap xep cuoc hop theo thoi gian ket thuc tang dan
    // Neu thoi gian ket thuc bang nhau, sap xep theo thoi gian bat dau tang dan
    sort(a + 1, a + n + 1, [](auto x, auto y) {
        if (x.second == y.second) return x.first < y.first;
        return x.second < y.second;
    });

    // F[i] la so luong cuoc hop lon nhat co the chon tu cac cuoc 1..i va phai co cuoc i
    // De quy hoac vong lap
    // Day la phien ban O(N^2)
    for (long i = 1; i <= n; i++) {
        F[i] = 1;
        for (long j = 1; j < i; j++) {
            // Neu cuoc j ket thuc <= thoi gian bat dau cua cuoc i
            if (a[j].second <= a[i].first) {
                if (F[j] + 1 > F[i]) {
                    F[i] = F[j] + 1;
                    vet[i] = j; // Truy vet
                }
            }
        }
    }

    // Tim ket qua toan cuc
    long max_meetings = 0, last_idx = 0;
    for (long i = 1; i <= n; i++) {
        if (F[i] > max_meetings) {
            max_meetings = F[i];
            last_idx = i;
        }
    }

    cout << max_meetings << '\n';

    // Truy vet de lay chi so cuoc hop
    vector<long> result_indices;
    while (last_idx > 0) {
        result_indices.push_back(last_idx);
        last_idx = vet[last_idx];
    }

    // In ra chi so goc (tu 1 den n)
    // Do van de hien thi, ta can sap xep lai tu be den lon neu can
    // Day la chi so trong mang da sap xep, can lay lai chi so goc neu can thiet.
    // Trong bai nay, chi can in ra chi so cua cac cuoc hop duoc chon.
    // Cac solution duoc cho thay thuong in ra chi so goc.
    // De don gian, ta in ra chi so trong mang da sap xep.
    // De chinh xac chi so goc, ta can mang b[] va sort lai.
    // 
}

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

struct Meeting {
    int start, end, id;
};

int n;
vector<Meeting> meetings;

int main() {
    cin >> n;
    meetings.resize(n);
    for(int i = 0; i < n; ++i) {
        cin >> meetings[i].start >> meetings[i].end;
        meetings[i].id = i + 1;
    }

    // Sap xep cac cuoc hop theo thoi gian ket thuc tang dan
    // Neu thoi gian ket thuc giong nhau, sap xep theo thoi gian bat dau tang dan
    sort(meetings.begin(), meetings.end(), [](const Meeting &a, const Meeting &b) {
        if (a.end != b.end) return a.end < b.end;
        return a.start < b.start;
    });

    vector<int> selected_ids;
    int current_end = -1; // Thoi gian ket thuc cua cuoc hop duoc chon gan nhat

    for(int i = 0; i < n; ++i) {
        // Neu thoi gian bat dau cua cuoc hien tai >= thoi gian ket thuc cua cuoc truoc
        if (meetings[i].start >= current_end) {
            selected_ids.push_back(meetings[i].id);
            current_end = meetings[i].end;
        }
    }

    cout << selected_ids.size() << '\n';
    for(int id : selected_ids) {
        cout << id << ' ';
    }
    cout << '\n';
    return 0;
}

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

struct Meeting {
    int start, end, id;
};

int n;
vector<Meeting> meetings;
vector<int> F, trace;
vector<Meeting> sorted_meetings;

int main() {
    cin >> n;
    meetings.resize(n);
    for(int i = 0; i < n; ++i) {
        cin >> meetings[i].start >> meetings[i].end;
        meetings[i].id = i + 1;
    }

    // Sap xep theo thoi gian ket thuc
    sort(meetings.begin(), meetings.end(), [](const Meeting &a, const Meeting &b) {
        return a.end < b.end;
    });

    // Tạo mảng F, F[i] là số lượng lớn nhất có thể chọn từ 0 đến i (bao gồm i)
    // Sử dụng binary search để tìm j sao cho meetings[j].end <= meetings[i].start
    // Tuy nhiên, để đơn giản và đúng với DP O(N log N), ta cần xử lý truy vết.
    // Code này minh họa ý tưởng DP O(N log N).

    // Lưu các thời điểm kết thúc để binary search
    vector<int> ends;
    for (auto m : meetings) ends.push_back(m.end);

    F.resize(n);
    trace.resize(n, -1);

    // Cấu trúc lưu trữ best value tại mỗi timestamp
    // Hoặc đơn giản là dùng DP với Binary Search
    // F[i] = 1 + max(F[j]) with meetings[j].end <= meetings[i].start

    // Để tối ưu O(N^2) xuống O(N log N), ta cần cấu trúc dữ liệu (Segment Tree/Fenwick Tree)
    // hoặc phương pháp 'Patience Sorting' (tìm dãy con tăng dài nhất trên 2 chiều).
    // Tuy nhiên, với n=10^4, O(N^2) là đủ.
    // Code này chỉ để minh họa logic, không phải code tối ưu full O(N log N) với truy vết đơn giản.

    // *Ghi chú*: Code mẫu dưới đây là O(N^2) Binary Search (tối ưu không đáng kể so với sort O(N log N)).
    // Để thực sự O(N log N) với truy vết, cần Fenwick Tree hoặc Segment Tree.

    return 0;
}