#pragma GCC optimize ("O3")
#pragma GCC optimize ("unroll-loops")
#include <vector>
#pragma GCC target ("avx2")

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

typedef long long int ll;
typedef long double ld;
typedef pair<ll, ll> pl;
typedef vector<ll> vl;
#define FD(i, r, l) for(ll i = r; i > (l); --i)

#define K first
#define V second
#define G(x) ll x; cin >> x;
#define GD(x) ld x; cin >> x;
#define GS(s) string s; cin >> s;
#define EX(x) { cout << x << '\n'; exit(0); }
#define A(a) (a).begin(), (a).end()
#define F(i, l, r) for (ll i = l; i < (r); ++i)

template<typename A, typename B>
A& chmax(A &a, B b) { return a < b ? (a=b): a; }

template<typename A, typename B>
A& chmin(A &a, B b) { return a > b ? (a=b): a; }

const ll N = 5e5 + 10;
const ll NN = N;
const ll L = 20;
ll len[N]; 
ll pos[N]; // position of index in ord
vector<pair<pl, ll>> ord; // intervals sorted according to greedy order

namespace seg_active { // just sum of active things in interval
    typedef ll T;
    T id=0;
    T f(T a, T b) {return a+b;}

    T t[2 * NN];
    ll n=NN;  // array size

    void modify(ll p, T value) {  // set value at position p
      for (p+=n, t[p] = value; p /= 2;) t[p] = f(t[2*p], t[2*p+1]);
    }

    T query(ll l, ll r) { // fold f on interval [l, r)
      T resl=id, resr=id;
      for (l += n, r += n; l < r; l /= 2, r /= 2) {
        if (l&1) resl = f(resl, t[l++]);
        if (r&1) resr = f(t[--r], resr);
      }
      return f(resl, resr);
    }
}


namespace lztree { // segtree of active intervals, maintains candidate set
    typedef pl T;
    typedef ll U;

    T idT = {1e17, -1}, t[2 * N];
    U idU = 0, d[N];
    ll x = (fill_n(d, N, idU), 0);

    // combining segtree nodes a and b
    T f(T a, T b) { 
        if (a == idT) return b;
        if (b == idT) return a;
        if (a.K != b.K) return min(a, b);
        return {a.K, ord[a.V].V < ord[b.V].V ? a.V : b.V }; // note that wthe actual index is ord_idx (the segtree index), but we sort by origianl indcies
    }
    // applying updates a and b (in that order)
    U g(U b, U a) { return a + b; }
    // applying update b to segtree node a
    T h(U b, T a) { return {a.K + b, a.V}; }

    void calc(ll p) { t[p] = h(d[p], f(t[p * 2], t[p * 2 + 1])); }

    void apply(ll p, U v) {
        t[p] = h(v, t[p]);
        if(p < N) d[p] = g(v, d[p]);
    }

    void push(ll p) {
        p += N;
        FD(s, L, 0) {
            ll i = p >> s;
            if(d[i] != idU) {
                apply(i * 2, d[i]);
                apply(i * 2 + 1, d[i]);
                d[i] = idU;
            }
        }
    }

    void modify(ll p, T v) {
        push(p);
        t[p += N] = v;
        while(p > 1) calc(p /= 2);
    }

    void modify(ll l, ll r, U v) {
        push(l), push(r - 1);
        bool cl = false, cr = false;
        for(l += N, r += N; l < r; l /= 2, r /= 2) {
            if(cl) calc(l - 1);
            if(cr) calc(r);
            if(l & 1) apply(l++, v), cl = true;
            if(r & 1) apply(--r, v), cr = true;
        }
        for(--l; r; l /= 2, r /= 2) {
            if(cl) calc(l);
            if(cr) calc(r);
        }
    }

    T query(ll l, ll r) {
        push(l), push(r - 1);
        T resl = idT, resr = idT;
        for(l += N, r += N; l < r; l /= 2, r /= 2) {
            if(l & 1) resl = f(resl, t[l++]);
            if(r & 1) resr = f(t[--r], resr);
        }
        return f(resl, resr);
    }
}

namespace candidate_mins { // Maintains suffix mins 
    typedef ll T;
    T id=1e17;
    T f(T a, T b) {return min(a,b);}

    T t[2 * NN];
    ll n=NN;  // array size

    void modify(ll p, T value) {  // set value at position p
      for (p+=n, t[p] = value; p /= 2;) t[p] = f(t[2*p], t[2*p+1]);
    }

    T query(ll l, ll r) { // fold f on interval [l, r)
      T resl=id, resr=id;
      for (l += n, r += n; l < r; l /= 2, r /= 2) {
        if (l&1) resl = f(resl, t[l++]);
        if (r&1) resr = f(t[--r], resr);
      }
      return f(resl, resr);
    }

    ll next_candidate_index(ll idx, ll n) { // first index < idx s.t. it's different than the current suffix min 
        auto suff = query(idx, n); 

        static vl nodes[2];
        nodes[0].reserve(32), nodes[1].reserve(32);
        nodes[0].clear(), nodes[1].clear();
        ll l = 0, r = idx;
        for (l += n, r += n; l < r; l /= 2, r /= 2) {
            if (l&1) nodes[0].push_back(l++); 
            if (r&1) nodes[1].push_back(--r);
        } 
        nodes[0].insert(nodes[0].end(), nodes[1].rbegin(), nodes[1].rend());
        for (auto it = nodes[0].rbegin(); it != nodes[0].rend(); ++it) {
            auto root = *it; if (t[root] < suff) {
                while (root < n) {
                    if (t[root * 2 + 1] < suff) root = root * 2 + 1;
                    else root = root * 2;
                }
                return root - n;
            }
        }
        return -1;
    }
}


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

    ios_base::sync_with_stdio(false); cin.tie(0);
    cout << fixed << setprecision(20);
    G(n)
    ll m = 0;
    {
        map<ll, ll> rr;
        F(i, 0, n) {
            G(x) G(y) ord.emplace_back(pair(x, y), i);
            rr[x], rr[y];
        }   
        m = rr.size() - 1;
        ll x = 0;
        ll prev = 0;
        for (auto &[k, v]: rr) {
            if (x) len[x-1] = k - prev; 
            prev = k;
            v=x++;   
        }
        for (auto &[x, y]: ord) {
            x.K = rr[x.K], x.V = rr[x.V];
        }    
        sort(A(ord), [&](auto x, auto y) {
            if (x.K.K != y.K.K) return x.K.K < y.K.K;
            if (x.K.V!= y.K.V) return x.K.V > y.K.V;
            return x.V > y.V;
        });
        //F(i, 0, n) pos[ord[i].V] = i;
    }

    set<ll> active_intervals;

    F(i, 0, n) {
        candidate_mins::modify(i, ord[i].K.V), lztree::modify(i, lztree::idT);
    }
    F(i, 0, m) seg_active::modify(i, len[i]), active_intervals.insert(i);

    set<pl> lefts, rights; // {l, r} -> ord_idx
    set<ll> here; // ord_idx active

    auto ins = [&] (ll ord_idx) { 
        auto [range, i] = ord[ord_idx];
        auto [l, r] = range;
        auto initial_len = seg_active::query(l, r);
        lztree::modify(ord_idx, {initial_len, ord_idx}); // needs to be ord_idx so we can do range subtractions

        here.insert(ord_idx);
        lefts.emplace(l, ord_idx);
        rights.emplace(r, ord_idx);
    };

    auto del = [&](ll ord_idx) {
        auto [range, i] = ord[ord_idx];
        auto [l, r] = range;

        lztree::modify(ord_idx, lztree::idT); // useless again 
        candidate_mins::modify(ord_idx, candidate_mins::id); 

        // recursively find any suffix mins that changed, add to candidate

        ll cur = ord_idx;
        while (1) {
            cur = candidate_mins::next_candidate_index(cur, n);
            if (cur == -1 || here.count(cur)) break;
            ins(cur);
        }
    };

    auto sub = [&](ll idx) {
        // find the first interval with r > idx
        auto it = rights.lower_bound(pl{idx, 1e9});
        // find the first interval with l > idx  
        auto it2 = lefts.lower_bound(pl{idx, 1e9});

        ll len = seg_active::query(idx, idx + 1); assert(len);
        seg_active::modify(idx, 0);
        
        active_intervals.erase(idx);

        ll lp = it == rights.end() ? n : it->V;
        ll rp = it2 == lefts.end() ? n : it2->V;

        lztree::modify(lp, rp, -len);
    };

    {
        ll mn = 1e18;
        FD(i, n-1, -1) if (mn > ord[i].K.V) {
            mn = ord[i].K.V;          
            ins(i);      
        }
    }

    vl res;

    F(it, 0, n) {
        auto get = lztree::query(0, n);
        assert(get.V != -1);
        auto [range, idx] = ord[get.V];
        res.push_back(idx + 1);
        auto [l, r] = range;
        while (1) {
            auto it = active_intervals.lower_bound(l);
            if (it != active_intervals.end() and *it < r) {
                sub(*it);
            } else break;
        } 
        del(get.V);
    }

    for (auto x: res) cout << x << " "; cout << endl;
}