On the competitive programming platform CodeCook, every person has a rating graph described by an array of integers a of length n. You are now updating the infrastructure, so you've created a program to compress these graphs.

The program works as follows. Given an integer parameter k, the program takes the minimum of each contiguous subarray of length k in a.

More formally, for an array a of length n and an integer k, define the k-compression array of a as an array b of length n-k+1, such that $$$b_j =min_{j≤ i≤ j+k-1}a_i$$$

For example, the 3-compression array of [1, 3, 4, 5, 2] is [min\{1, 3, 4\}, min\{3, 4, 5\}, min\{4, 5, 2\}]=[1, 3, 2].

A permutation of length m is an array consisting of m distinct integers from 1 to m in arbitrary order. For example, [2,3,1,5,4] is a permutation, but [1,2,2] is not a permutation (2 appears twice in the array) and [1,3,4] is also not a permutation (m=3 but there is 4 in the array).

A k-compression array will make CodeCook users happy if it will be a permutation. Given an array a, determine for all 1≤ k≤ n if CodeCook users will be happy after a k-compression of this array or not.

Input

The first line contains a single integer t (1≤ t≤ 10^4) — the number of test cases.

The first line of the description of each test case contains a single integer n (1≤ n≤ 3⋅ 10^5) — the length of the array.

The second line of the description of each test case contains n integers a_1,…,a_n (1≤ a_i≤ n) — the elements of the array.

It is guaranteed, that the sum of n for all test cases does not exceed 3⋅ 10^5.

Output

For each test case, print a binary string of length n. 

The k-th character of the string should be 1 if CodeCook users will be happy after a k-compression of the array a, and 0 otherwise. 

Example

Input


5
5
1 5 3 4 2
4
1 3 2 1
5
1 3 3 3 2
10
1 2 3 4 5 6 7 8 9 10
3
3 3 2


Output


10111
0001
00111
1111111111
000

Note

In the first test case, a=[1, 5, 3, 4, 2].

  * The 1-compression of a is [1, 5, 3, 4, 2] and it is a permutation. 
  * The 2-compression of a is [1, 3, 3, 2] and it is not a permutation, since 3 appears twice. 
  * The 3-compression of a is [1, 3, 2] and it is a permutation. 
  * The 4-compression of a is [1, 2] and it is a permutation. 
  * The 5-compression of a is [1] and it is a permutation. 
//Jo Hack Kiya Wo M.......D
import java.util.List;
import java.io.BufferedReader;
import java.io.IOException;
import java.io.InputStreamReader;
import java.io.PrintWriter;
import java.util.ArrayDeque;
import java.util.ArrayList;
import java.util.Arrays;
import java.util.Collections;
import java.util.Comparator;
import java.util.Deque;
import java.util.HashMap;
import java.util.HashSet;
import java.util.Iterator;
import java.util.LinkedHashSet;
import java.util.LinkedList;
import java.util.Map;
import java.util.PriorityQueue;
import java.util.Queue;
import java.util.Scanner;
import java.util.Stack;
import java.util.StringTokenizer;
import java.util.TreeMap;
import java.util.TreeSet;
import java.util.Vector;

/* Name of the class has to be "Main" only if the class is public. */
public class Cp
{
	
	 //	Template For Fast i/o copied From Gfg
		static class FastReader 
	    { 
	        BufferedReader br; 
	        StringTokenizer st; 
	  
	        public FastReader() 
	        { 
	            br = new BufferedReader(new
	                     InputStreamReader(System.in)); 
	        } 
	  
	        String next() 
	        { 
	            while (st == null || !st.hasMoreElements()) 
	            { 
	                try
	                { 
	                    st = new StringTokenizer(br.readLine()); 
	                } 
	                catch (IOException  e) 
	                { 
	                    e.printStackTrace(); 
	                } 
	            } 
	            return st.nextToken(); 
	        } 
	  
	        int nextInt() 
	        { 
	            return Integer.parseInt(next()); 
	        } 
	        long nextLong() 
	        { 
	            return Long.parseLong(next()); 
	        } 
	  
	        double nextDouble() 
	        { 
	            return Double.parseDouble(next()); 
	        } 
	  
	        String nextLine() 
	        { 
	            String str = ""; 
	            try
	            { 
	                str = br.readLine(); 
	            } 
	            catch (IOException e) 
	            { 
	                e.printStackTrace(); 
	            } 
	            return str; 
	        } 
	    }
		
	public static void main(String[] args) {
	   FastReader obj=new FastReader();
       PrintWriter out=new PrintWriter(System.out);
       int t=obj.nextInt();
       while(t-->0)
       {
    	   int n=obj.nextInt();
    	   int []a=new int[n];
    	   for(int i=0;i<n;i++)
    	   {
    		   a[i]=obj.nextInt();
    	   }
    	   char s[]=new char[n];
    	   for(int i=0;i<n;i++)
    	   {
    		   s[i]='0';
    	   }
    	   int []freq=new int[n+1];
    	   for(int i=0;i<n;i++)
    	   {
    		   freq[a[i]]++;
    	   }
    	   int start=0, end=n-1;
           for(int i=0;i<n;i++)
           {
               if(freq[i+1]>0)
                   s[n-i-1]='1';
               else 
                   break;
               if(freq[i+1]>1)
                   break;
               if(a[start]==i+1)
                   start++;
               else if(a[end]==i+1)
                   end--;
               else
                       break;
           }
           HashSet<Integer> set=new HashSet<>();
           for(int i=0;i<n;i++)
           {
        	   set.add(a[i]);
           }
           if(set.size()==n)
           {
        	   s[0]='1';
           }
    	   for(int i=0;i<n;i++)
    	   {
    		   out.print(s[i]);
    	   }
    	   out.println();
    	   out.flush();
       }
	}
	public static void print(char mat[][])
	{
		PrintWriter out=new PrintWriter(System.out);
		for(int i=0;i<mat.length;i++)
		{
			for(int j=0;j<mat[0].length;j++)
			{
				out.print(mat[i][j]);
			}
			out.println();
		}
		out.flush();
	}
	public static boolean check(char mat[][],int n)
	{
		for(int i=0;i<n;i++)
		{
			int count=0;
			for(int j=0;j<n;j++)
			{
				if(mat[i][j]=='X')
				{
					count++;
				}
				else 
				{
					count=0;
				}
				if(count==3)
				{
					return false;
				}
			}
		}
		for(int j=0;j<n;j++)
		{
			int count=0;
			for(int i=0;i<n;i++)
			{
				if(mat[i][j]=='X')
				{
					count++;
				}
				else 
				{
					count=0;
				}
				if(count==3)
				{
					return false;
				}
			}
		}
		return true;
	}
}



