You are given P, a permutation of (1,\ 2,\ ...\ N).

A string S of length N consisting of `0` and `1` is a good string when it meets the following criterion:

* The sequences X and Y are constructed as follows:
* First, let X and Y be empty sequences.
* For each i=1,\ 2,\ ...\ N, in this order, append P_i to the end of X if S_i= `0`, and append it to the end of Y if S_i= `1`.
* If X and Y have the same number of high elements, S is a good string. Here, the i-th element of a sequence is called high when that element is the largest among the elements from the 1-st to i-th element in the sequence.



Determine if there exists a good string. If it exists, find the lexicographically smallest such string.

Constraints

* 1 \leq N \leq 2 \times 10^5
* 1 \leq P_i \leq N
* P_1,\ P_2,\ ...\ P_N are all distinct.
* All values in input are integers.

Input

Input is given from Standard Input in the following format:


N
P_1 P_2 ... P_N


Output

If a good string does not exist, print `-1`. If it exists, print the lexicographically smallest such string.

Examples

Input

6
3 1 4 6 2 5


Output

001001


Input

5
1 2 3 4 5


Output

-1


Input

7
1 3 2 5 6 4 7


Output

0001101


Input

30
1 2 6 3 5 7 9 8 11 12 10 13 16 23 15 18 14 24 22 26 19 21 28 17 4 27 29 25 20 30


Output

000000000001100101010010011101
#include <bits/stdc++.h>

using namespace std;

const int inf = 0x3f3f3f3f;

int main() {
#ifdef wxh010910
  freopen("input.txt", "r", stdin);
#endif
  int n;
  cin >> n;
  vector<int> a(n);
  vector<bool> b(n);
  int prefix = -1, q = 0;
  for (int i = 0; i < n; ++i) {
    cin >> a[i];
    --a[i];
    if (a[i] > prefix) {
      prefix = a[i];
      b[i] = true;
      ++q;
    }
  }
  
  vector<int> fenw_even(n, 0), fenw_odd(n, -inf);
  stack<pair<int*, int>> memory;

  auto modify = [&](vector<int> &fenw, int x, int value) {
    while (x < n) {
      if (fenw[x] < value) {
        memory.emplace(&fenw[x], fenw[x]);
        fenw[x] = value;
      }
      x |= x + 1;
    }
  };

  auto query = [&](vector<int> &fenw, int x) {
    int result = -inf;
    while (x >= 0) {
      result = max(result, fenw[x]);
      x = (x & x + 1) - 1;
    }
    return result;
  };

  vector<int> size(n);
  for (int i = n - 1; ~i; --i) {
    int even = -inf, odd = -inf;
    size[i] = memory.size();
    if (b[i]) {
      even = query(fenw_even, n - a[i] - 1) + 2;
      odd = query(fenw_odd, n - a[i] - 1) + 2;
    } else {
      even = query(fenw_odd, n - a[i] - 1) + 1;
      odd = query(fenw_even, n - a[i] - 1) + 1;
    }
    if (even >= 0) {
      modify(fenw_even, n - a[i] - 1, even);
    }
    if (odd >= 0) {
      modify(fenw_odd, n - a[i] - 1, odd);
    }
  }

  auto check = [&](int x, int need) {
    if (need < 0) {
      return false;
    }
    if (need & 1) {
      return query(fenw_odd, n - x - 1) >= need;
    } else {
      return query(fenw_even, n - x - 1) >= need;
    }
  };

  auto valid = [&](int max0, int max1, int diff, int q) {
    return check(max0, q - diff) || check(max1, q + diff);
  };

  int max0 = 0, max1 = 0;
  if (!check(0, q)) {
    puts("-1");
    return 0;
  }
  int diff = 0;
  for (int i = 0; i < n; ++i) {
    if (b[i]) {
      --q;
    }
    while (memory.size() > size[i]) {
      *memory.top().first = memory.top().second;
      memory.pop();
    }
    if (max0 <= a[i]) {
      if (valid(a[i], max1, diff + 1, q)) {
        cout << 0;
        max0 = a[i];
        ++diff;
      } else {
        cout << 1;
        if (max1 <= a[i]) {
          max1 = a[i];
          --diff;
        }
      }
    } else {
      if (valid(max0, max1, diff, q)) {
        cout << 0;
      } else {
        cout << 1;
        if (max1 <= a[i]) {
          max1 = a[i];
          --diff;
        }
      }
    }
  }
  cout << endl;

  return 0;
}
