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. 
import java.io.BufferedReader;
import java.io.BufferedWriter;
import java.io.IOException;
import java.io.InputStreamReader;
import java.io.OutputStreamWriter;

public class B_Beautiful_Numbers {
	int st[]; // The array that stores segment tree nodes 

	/* Constructor to construct segment tree from given array. This 
       constructor  allocates memory for segment tree and calls 
       constructSTUtil() to  fill the allocated memory */
	B_Beautiful_Numbers(int arr[], int n) 
	{ 
		// Allocate memory for segment tree 
		//Height of segment tree 
		int x = (int) (Math.ceil(Math.log(n) / Math.log(2))); 

		//Maximum size of segment tree 
		int max_size = 2 * (int) Math.pow(2, x) - 1; 

		st = new int[max_size]; // Memory allocation 

		constructSTUtil(arr, 0, n - 1, 0); 
	} 

	// A utility function to get the middle index from corner indexes. 
	int getMid(int s, int e) { 
		return s + (e - s) / 2; 
	} 

	/*  A recursive function to get the sum of values in given range 
        of the array.  The following are parameters for this function. 

      st    --> Pointer to segment tree 
      si    --> Index of current node in the segment tree. Initially 
                0 is passed as root is always at index 0 
      ss & se  --> Starting and ending indexes of the segment represented 
                    by current node, i.e., st[si] 
      qs & qe  --> Starting and ending indexes of query range */
	int getSumUtil(int ss, int se, int qs, int qe, int si) 
	{ 
		// If segment of this node is a part of given range, then return 
		// the sum of the segment 
		if (qs <= ss && qe >= se) 
			return st[si]; 

		// If segment of this node is outside the given range 
		if (se < qs || ss > qe) 
			return 0; 

		// If a part of this segment overlaps with the given range 
		int mid = getMid(ss, se); 
		return getSumUtil(ss, mid, qs, qe, 2 * si + 1) + 
				getSumUtil(mid + 1, se, qs, qe, 2 * si + 2); 
	} 

	/* A recursive function to update the nodes which have the given  
       index in their range. The following are parameters 
        st, si, ss and se are same as getSumUtil() 
        i    --> index of the element to be updated. This index is in 
                 input array. 
       diff --> Value to be added to all nodes which have i in range */
	void updateValueUtil(int ss, int se, int i, int diff, int si) 
	{ 
		// Base Case: If the input index lies outside the range of  
		// this segment 
		if (i < ss || i > se) 
			return; 

		// If the input index is in range of this node, then update the 
		// value of the node and its children 
		st[si] = st[si] + diff; 
		if (se != ss) { 
			int mid = getMid(ss, se); 
			updateValueUtil(ss, mid, i, diff, 2 * si + 1); 
			updateValueUtil(mid + 1, se, i, diff, 2 * si + 2); 
		} 
	} 

	// The function to update a value in input array and segment tree. 
	// It uses updateValueUtil() to update the value in segment tree 
	void updateValue(int arr[], int n, int i, int new_val) 
	{ 
		// Check for erroneous input index 
		if (i < 0 || i > n - 1) { 
			System.out.println("Invalid Input"); 
			return; 
		} 

		// Get the difference between new value and old value 
		int diff = new_val - arr[i]; 

		// Update the value in array 
		arr[i] = new_val; 

		// Update the values of nodes in segment tree 
		updateValueUtil(0, n - 1, i, diff, 0); 
	} 

	// Return sum of elements in range from index qs (quey start) to 
	// qe (query end).  It mainly uses getSumUtil() 
	int getSum(int n, int qs, int qe) 
	{ 
		// Check for erroneous input values 
		if (qs < 0 || qe > n - 1 || qs > qe) { 
			System.out.println("Invalid Input"); 
			return -1; 
		} 
		return getSumUtil(0, n - 1, qs, qe, 0); 
	} 

	// A recursive function that constructs Segment Tree for array[ss..se]. 
	// si is index of current node in segment tree st 
	int constructSTUtil(int arr[], int ss, int se, int si) 
	{ 
		// If there is one element in array, store it in current node of 
		// segment tree and return 
		if (ss == se) { 
			st[si] = arr[ss]; 
			return arr[ss]; 
		} 

		// If there are more than one elements, then recur for left and 
		// right subtrees and store the sum of values in this node 
		int mid = getMid(ss, se); 
		st[si] = constructSTUtil(arr, ss, mid, si * 2 + 1) + 
				constructSTUtil(arr, mid + 1, se, si * 2 + 2); 
		return st[si]; 
	}

	public static void main(String[] args) throws IOException {
		BufferedReader br = new BufferedReader(new InputStreamReader(System.in));
		BufferedWriter bw = new BufferedWriter(new OutputStreamWriter(System.out));

		int t = Integer.parseInt(br.readLine());
		while(t>0) {
			br.readLine();
			String[] parts = br.readLine().split(" ");
			int[] values = new int[parts.length];
			for (int i = 0; i < values.length; i++) {
				values[Integer.parseInt(parts[i])-1] = i;
			}
			int[] segTree = new int[values.length];
			B_Beautiful_Numbers segT = new B_Beautiful_Numbers(segTree,values.length);
			int min = values[0];
			int max = min;
			for (int i = 0; i < values.length; i++) {
				//bw.write(Arrays.toString(segTree)+"\n");
				segT.updateValue(segTree, values.length, values[i], 1);
				//bw.write(Arrays.toString(segTree)+"\n");
				if(min>values[i]) min = values[i];
				if(max<values[i]) max = values[i];
				//bw.write("min:"+min+"\n");
				//bw.write("max:"+max+"\n");
				int sumInterval = segT.getSum(values.length,min,max);
				if(sumInterval<max-min+1) {
					bw.write("0");
				}else {
					bw.write("1");					
				}
			}
			bw.write("\n");
			t--;
		}

		br.close();
		bw.close();
	}

}
