#include <bits/stdc++.h>

using i64 = long long;

template <typename T>
struct Fenwick {
    int n;
    std::vector<T> a;
    
    Fenwick(int n = 0) {
        init(n);
    }
    
    void init(int n) {
        this->n = n;
        a.assign(n, T());
    }
    
    void add(int x, T v) {
        for (int i = x + 1; i <= n; i += i & -i) {
            a[i - 1] += v;
        }
    }
    
    T sum(int x) {
        auto ans = T();
        for (int i = x; i > 0; i -= i & -i) {
            ans += a[i - 1];
        }
        return ans;
    }
    
    T rangesum(int l, int r) {
        return sum(r) - sum(l);
    }
    
    int kth(T k) {
        int x = 0;
        for (int i = 1 << std::__lg(n); i; i /= 2) {
            if (x + i <= n && k >= a[x + i - 1]) {
                x += i;
                k -= a[x - 1];
            }
        }
        return x;
    }
};

constexpr int N = 500010;

int cnt;
int id[N * 4], deg[N * 40];
std::vector<int> adj[N * 40];

void addEdge(int u, int v) {
    // std::cerr << u << " " << v << "\n";
    deg[v] ++ ;
    adj[u].push_back(v);
}

void build(int p, int l, int r) {
    id[p] = cnt ++ ;
    if (l == r) {
        return;
    }
    int m = (l + r) / 2;
    build(p * 2, l, m);
    build(p * 2 + 1, m + 1, r);
    addEdge(id[p * 2], id[p]);
    addEdge(id[p * 2 + 1], id[p]);
}

void add(int p, int l, int r, int x, int y, int z) {
    if (l > y || r < x) {
        return;
    }
    if (l >= x && r <= y) {
        addEdge(id[p], z);
        return;
    }

    int m = (l + r) / 2;
    add(p * 2, l, m, x, y, z);
    add(p * 2 + 1, m + 1, r, x, y, z);
}

void modify(int p, int l, int r, int x, int y) {
    if (l == r) {
        int New = cnt ++ ;
        addEdge(id[p], New);
        addEdge(y, New);
        id[p] = New;
        return;
    }

    int m = (l + r) / 2;
    if (x <= m) {
        modify(p * 2, l, m, x, y);
        int New = cnt ++ ;
        addEdge(id[p], New);
        addEdge(id[p * 2], New);
        id[p] = New;
    } else {
        modify(p * 2 + 1, m + 1, r, x, y);
        int New = cnt ++ ;
        addEdge(id[p], New);
        addEdge(id[p * 2 + 1], New);
        id[p] = New;
    }
}

int main() {
    std::ios::sync_with_stdio(false);
    std::cin.tie(nullptr);

    int n;
    std::cin >> n;

    std::vector<int> b(n * 2);
    std::vector<std::array<int, 3>> a(n);
    for (int i = 0; i < n; i ++ ) {
        std::cin >> a[i][0] >> a[i][1];
        a[i][2] = i;
        b[i * 2] = a[i][0];
        b[i * 2 + 1] = a[i][1];
    }

    std::sort(b.begin(), b.end());
    b.erase(std::unique(b.begin(), b.end()), b.end());
    int m = b.size();
    for (int i = 0; i < n; i ++ ) {
        a[i][0] = lower_bound(b.begin(), b.end(), a[i][0]) - b.begin();
        a[i][1] = lower_bound(b.begin(), b.end(), a[i][1]) - b.begin();
    }

    std::sort(a.begin(), a.end(), 
        [&](std::array<int, 3> i, std::array<int, 3> j) {
            return i[0] != j[0] ? i[0] > j[0] : i[2] < j[2];
        });
    std::set<int> s;
    Fenwick<int> fen(m - 1);
    for (int i = 0; i < m - 1; i ++ ) {
        s.insert(i);
        fen.add(i, b[i + 1] - b[i]);
    }

    auto update = [&](int l, int r) {
        auto itl = s.lower_bound(l);
        auto itr = s.upper_bound(r);
        for (auto it = itl; it != itr; it ++ ) {
            fen.add(*it, b[*it] - b[*it + 1]);
        }
        s.erase(itl, itr);
    };

    auto query = [&](int i) {
        return fen.sum(a[i][1]) - fen.sum(a[i][0]);
    };

    // for (int i = 0; i < n; i ++ ) {
    //     std::cerr << a[i][0] << " " << a[i][1] << "\n";
    //     std::cerr << query(i) << "\n";
    // }

    cnt = n;
    build(1, 0, m - 1);
    for (int i = 0; i < n; i ++ ) {
        add(1, 0, m - 1, 0, a[i][1], i);
        modify(1, 0, m - 1, a[i][1], i);
    }

    std::queue<int> q;
    for (int i = 0; i < cnt; i ++ ) {
        if (!deg[i]) {
            q.push(i);
        }
    }

    std::vector<bool> vis(n);
    std::priority_queue<std::array<int, 3>, std::vector<std::array<int, 3>>, std::greater<>> h;
    std::set<std::pair<int, int>> seg;
    for (int i = 0; i < n; i ++ ) {
        while (!q.empty()) {
            int x = q.front();
            q.pop();
            if (x < n) {
                // std::cerr << x << "\n";
                h.push({query(x), a[x][2], x});
                seg.emplace(a[x][0], x);
            } else {
                for (auto y : adj[x]) {
                    if ( -- deg[y] == 0) {
                        q.push(y);
                    }
                }
            }
        }

        assert(!h.empty());
            while (vis[h.top()[1]]) {
                h.pop();
            }
            assert(!h.empty());
            auto [_, x, y] = h.top();
            h.pop();
            std::cout << x + 1 << " \n"[i == n - 1];
            vis[x] = true;

            update(a[y][0], a[y][1] - 1);
            seg.erase({a[y][0], y});

            // for (int i = 0; i < n; i ++ ) {
            //     std::cerr << query(i) << " \n"[i == n - 1];
            // }

            if (!seg.empty()) {
            int t = 1E9;
            auto it = seg.lower_bound({a[y][0], 0});
            while (true) {
                if (it == seg.end() || it->first >= a[y][1]) {
                    break;
                }
                int x = it->second;
                int w = query(x);
                if (t < w) {
                    break;
                }
                // std::cerr << i << " " << x << "\n";
                h.push({w, a[x][2], x});
                t = w;
                it ++ ;
            }
            t = 1E9;
            it = seg.lower_bound({a[y][0], 0});
            while (true) {
                if (it == seg.begin() || a[(--it)->second][1] <= a[y][0]) {
                    break;
                }
                int x = it->second;
                int w = query(x);
                if (t < w) {
                    break;
                }
                // std::cerr << i << " " << x << "\n";
                h.push({w, a[x][2], x});
                t = w;
            }
        }

        for (auto z : adj[y]) {
            if ( -- deg[z] == 0) {
                q.push(z);
            }
        }
    }

    return 0;
}