You are given a permutation p=[p_1, p_2, …, p_n] of integers from 1 to n. Let's call the number m (1 ≤ m ≤ n) beautiful, if there exists two indices l, r (1 ≤ l ≤ r ≤ n), such that the numbers [p_l, p_{l+1}, …, p_r] is a permutation of numbers 1, 2, …, m.

For example, let p = [4, 5, 1, 3, 2, 6]. In this case, the numbers 1, 3, 5, 6 are beautiful and 2, 4 are not. It is because:

  * if l = 3 and r = 3 we will have a permutation [1] for m = 1; 
  * if l = 3 and r = 5 we will have a permutation [1, 3, 2] for m = 3; 
  * if l = 1 and r = 5 we will have a permutation [4, 5, 1, 3, 2] for m = 5; 
  * if l = 1 and r = 6 we will have a permutation [4, 5, 1, 3, 2, 6] for m = 6; 
  * it is impossible to take some l and r, such that [p_l, p_{l+1}, …, p_r] is a permutation of numbers 1, 2, …, m for m = 2 and for m = 4. 



You are given a permutation p=[p_1, p_2, …, p_n]. For all m (1 ≤ m ≤ n) determine if it is a beautiful number or not.

Input

The first line contains the only integer t (1 ≤ t ≤ 1000) — the number of test cases in the input. The next lines contain the description of test cases.

The first line of a test case contains a number n (1 ≤ n ≤ 2 ⋅ 10^5) — the length of the given permutation p. The next line contains n integers p_1, p_2, …, p_n (1 ≤ p_i ≤ n, all p_i are different) — the given permutation p.

It is guaranteed, that the sum of n from all test cases in the input doesn't exceed 2 ⋅ 10^5.

Output

Print t lines — the answers to test cases in the order they are given in the input. 

The answer to a test case is the string of length n, there the i-th character is equal to 1 if i is a beautiful number and is equal to 0 if i is not a beautiful number.

Example

Input


3
6
4 5 1 3 2 6
5
5 3 1 2 4
4
1 4 3 2


Output


101011
11111
1001

Note

The first test case is described in the problem statement.

In the second test case all numbers from 1 to 5 are beautiful:

  * if l = 3 and r = 3 we will have a permutation [1] for m = 1; 
  * if l = 3 and r = 4 we will have a permutation [1, 2] for m = 2; 
  * if l = 2 and r = 4 we will have a permutation [3, 1, 2] for m = 3; 
  * if l = 2 and r = 5 we will have a permutation [3, 1, 2, 4] for m = 4; 
  * if l = 1 and r = 5 we will have a permutation [5, 3, 1, 2, 4] for m = 5. 
#include <bits/stdc++.h>
using namespace std;
void RI() {}
template <typename... T>
void RI(int& head, T&... tail) {
  scanf("%d", &head);
  RI(tail...);
}
template <typename T>
void _dump(const char* s, T&& head) {
  cerr << s << "=" << head << endl;
}
template <typename T, typename... Args>
void _dump(const char* s, T&& head, Args&&... tail) {
  int c = 0;
  while (*s != ',' || c != 0) {
    if (*s == '(' || *s == '[' || *s == '{') c++;
    if (*s == ')' || *s == ']' || *s == '}') c--;
    cerr << *s++;
  }
  cerr << "=" << head << ", ";
  _dump(s + 1, tail...);
}
template <typename Iter>
ostream& _out(ostream& s, Iter b, Iter e) {
  s << "[";
  for (auto it = b; it != e; it++) s << (it == b ? "" : " ") << *it;
  s << "]";
  return s;
}
template <typename A, typename B>
ostream& operator<<(ostream& s, const pair<A, B>& p) {
  return s << "(" << p.first << "," << p.second << ")";
}
template <typename T>
ostream& operator<<(ostream& s, const vector<T>& c) {
  return _out(s, begin(c), end(c));
}
template <typename T>
ostream& operator<<(ostream& s, const set<T>& c) {
  return _out(s, begin(c), end(c));
}
template <typename A, typename B>
ostream& operator<<(ostream& s, const map<A, B>& c) {
  return _out(s, begin(c), end(c));
}
const int MAX_N = 200005;
int n_, n;
int a[MAX_N], idx[MAX_N], seg[(1 << 19) - 1];
void input() {
  RI(n_);
  for (int i = 0; i < (int)(n_); i++) {
    RI(a[i]);
    idx[a[i]] = i;
  }
}
void add(int k, int val) {
  k += n - 1;
  seg[k] = val;
  while (k > 0) {
    k = (k - 1) / 2;
    seg[k] = max(seg[k * 2 + 1], seg[k * 2 + 2]);
  }
}
int query(int a, int b, int k, int l, int r) {
  if (r <= a || b <= l) return -1;
  if (a <= l && r <= b) return seg[k];
  return max(query(a, b, k * 2 + 1, l, (l + r) / 2),
             query(a, b, k * 2 + 2, (l + r) / 2, r));
}
void build() {
  n = 1;
  while (n < n_) {
    n <<= 1;
  }
  for (int i = 0; i < (int)(n_); i++) {
    add(i, a[i]);
  }
}
bool ans[MAX_N];
void search(int a, int b) {
  if (b - a == 1) {
    ans[0] = 1;
    return;
  }
  int k = query(a, b, 0, 0, n);
  if (k == b - a) ans[k - 1] = 1;
  if (idx[k] < idx[1]) {
    search(idx[k] + 1, b);
  } else {
    search(a, idx[k]);
  }
}
void solve() {
  build();
  memset(ans, 0, sizeof(ans[0]) * n_);
  search(0, n_);
  for (int i = 0; i < (int)(n_); i++) {
    cout << ans[i];
  }
  cout << '\n';
}
int main(int argc, char* argv[]) {
  int n_case;
  RI(n_case);
  for (int i = 0; i < (int)(n_case); i++) {
    input();
    solve();
  }
  return 0;
}
