Problem: Information technologies are developing and are increasingly penetrating into all spheres of human activity. Incredible as it is, the most modern technology are used in farming!

A large farm has a meadow with grazing sheep. Overall there are n sheep and each of them contains a unique number from 1 to n — because the sheep need to be distinguished and you need to remember information about each one, and they are so much alike! The meadow consists of infinite number of regions numbered from 1 to infinity. It's known that sheep i likes regions from li to ri.

There are two shepherds taking care of the sheep: First and Second. First wakes up early in the morning and leads the sheep graze on the lawn. Second comes in the evening and collects all the sheep.

One morning, First woke up a little later than usual, and had no time to lead the sheep graze on the lawn. So he tied together every two sheep if there is a region they both like. First thought that it would be better — Second would have less work in the evening, because sheep won't scatter too much, being tied to each other!

In the evening Second came on the lawn, gathered the sheep and tried to line them up in a row. But try as he might, the sheep wouldn't line up as Second want! Second had neither the strength nor the ability to untie the sheep so he left them as they are, but with one condition: he wanted to line up the sheep so that the maximum distance between two tied sheep was as small as possible. The distance between the sheep is the number of sheep in the ranks that are between these two.

Help Second find the right arrangement.

Input

The first input line contains one integer n (1 ≤ n ≤ 2000). Each of the following n lines contains two integers li and ri (1 ≤ li, ri ≤ 109; li ≤ ri).

Output

In the single output line print n space-separated numbers — the sought arrangement of the sheep. The i-th value in the line must represent the number of the sheep that took the i-th place from left in the optimal arrangement line. 

If there are multiple optimal arrangements, print any of them.

Examples

Input

3
1 3
5 7
2 4


Output

1 3 2

Input

5
1 5
2 4
3 6
1 7
2 6


Output

2 1 3 5 4

Input

4
1 3
4 6
5 7
2 3


Output

1 4 2 3

Solution (in CPP):

Solution:
#include <bits/stdc++.h>
using namespace std;
int N;
inline bool int_less_than(int a, int b) { return a < b; }
bool interval_less_than(const pair<pair<int, int>, int> &lhs,
                        const pair<pair<int, int>, int> &rhs) {
  if (lhs.first.second == rhs.first.second) {
    return int_less_than(lhs.first.first, rhs.first.first);
  }
  return int_less_than(lhs.first.second, rhs.first.second);
}
bool overlap(const pair<int, int> &lhs, const pair<int, int> &rhs) {
  return max(lhs.first, rhs.first) <= min(lhs.second, rhs.second);
}
vector<int> solve(vector<pair<pair<int, int>, int> > &interval, int K) {
  int current = 0;
  vector<int> order, max_pos(N), pos(N);
  int subsum[N];
  for (int i = 0; i < N; i++) {
    max_pos[i] = N - 1;
    pos[i] = -1;
  }
  for (int count = 0; count < N; count++) {
    pos[current] = count;
    memset(subsum, 0, sizeof(subsum));
    for (int i = 0; i < N; i++) {
      if (pos[i] < 0) {
        if (overlap(interval[i].first, interval[current].first)) {
          max_pos[i] = min(max_pos[i], pos[current] + K);
        }
        ++subsum[max_pos[i]];
      }
    }
    for (int jj = count + 1; jj < N; jj++) subsum[jj] += subsum[jj - 1];
    int j = 1, min_j = -1;
    while (count + j < N) {
      if (subsum[count + j] > j) {
        return order;
      }
      if (subsum[count + j] == j && min_j < 0) {
        min_j = j;
      }
      ++j;
    }
    current = -1;
    for (int i = 0; i < N; i++) {
      if (pos[i] < 0 && max_pos[i] <= count + min_j) {
        current = i;
        break;
      }
    }
  }
  order.resize(N);
  for (int i = 0; i < N; i++) {
    order[pos[i]] = interval[i].second;
  }
  return order;
}
int main(const int argc, const char **argv) {
  (cin >> N);
  {
    vector<pair<pair<int, int>, int> > interval(N);
    for (int i = 0; i < N; i++) {
      cin >> interval[i].first.first >> interval[i].first.second;
      interval[i].second = i + 1;
    }
    sort(interval.begin(), interval.end(), interval_less_than);
    int st = 1, ed = N - 1, mid;
    vector<int> result;
    while (st <= ed) {
      int mid = (st + ed) / 2;
      vector<int> order = solve(interval, mid);
      if (order.size() > 0) {
        result = order;
        ed = mid - 1;
      } else {
        st = mid + 1;
      }
    }
    for (int i = 0; i < N; i++) cout << result[i] << " ";
    cout << endl;
  }
  return 0;
}