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;
bool sortbysec(const pair<int, int> &a, const pair<int, int> &b) {
  return (a.second < b.second);
}
bool prime[1000000 + 1];
void seive() {
  long long int N = 1e6 + 1;
  memset(prime, true, sizeof(prime));
  prime[0] = false;
  prime[1] = false;
  for (long long int i = 2; i * i <= N; i++) {
    if (prime[i]) {
      for (long long int j = i * i; j <= N; j += i) {
        prime[j] = false;
      }
    }
  }
}
bool isPowerOfTwo(int x) { return (x && !(x & (x - 1))); }
bool is_prime(int n) {
  if (n == 1) return false;
  for (int i = 2; i <= sqrt(n); i++) {
    if (n % i == 0) {
      return false;
    }
  }
  return true;
}
long long int ans = 1;
int const G = 100005;
int vst[G];
vector<int> edge[G];
long long int ar[G];
long long int bfs(int sv) {
  queue<int> pn;
  pn.push(sv);
  vst[sv] = 1;
  long long int temp = ar[sv];
  while (!pn.empty()) {
    int x = pn.front();
    vst[x] = 1;
    pn.pop();
    for (int i = 0; i < edge[x].size(); i++) {
      if (!vst[edge[x][i]]) {
        pn.push(edge[x][i]);
        temp = ((temp > ar[edge[x][i]]) ? ar[edge[x][i]] : temp);
      }
    }
  }
  return temp;
}
void hemant() {
  int n;
  cin >> n;
  vector<pair<int, int>> ar;
  ar.push_back({0, 0});
  for (int i = 1; i <= n; i++) {
    int x;
    cin >> x;
    ar.push_back({x, i});
  }
  sort(ar.begin(), ar.end());
  int l = n + 1;
  int r = 0;
  for (int i = 1; i <= n; i++) {
    l = ((l > ar[i].second) ? ar[i].second : l);
    r = (r < ar[i].second ? ar[i].second : r);
    long long int k = r - l + 1;
    if (k == i)
      cout << "1";
    else
      cout << "0";
  }
  cout << "\n";
}
int main() {
  int t = 1;
  cin >> t;
  while (t--) {
    hemant();
  }
  return 0;
}
