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.*; 

import java.util.*;
import java.util.Map.Entry;


public class  Beautiful_Numbers     
{ 
    
    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 long changeme(long b,int i,int fin,long num)
    {
        return ((b>>i)|(b<<(fin-i)))&num;
    }
    static long power(long x, long y, long m)  
    { 
        if (y == 0) 
            return 1; 
          
        long p = power(x, y / 2, m) % m; 
        p = (p * p) % m; 
      
        if (y % 2 == 0) 
            return p%m; 
        else
            return (x * p) % m; 
    } 
    static long modInverse(long a,long m) 
    { 
        return power(a, m - 2, m);  
    } 
    static long gcd(long a,long b)  
    { 
        if (a == 0) 
            return b; 
        return gcd(b % a, a); 
    } 
    static int kFactors(long n,long k) 
    { 
        ArrayList<Long> P = new ArrayList<Long>(); 
      
        // Insert all 2's in list 
        while (n % 2 == 0) 
        { 
            P.add(2l); 
            n /= 2; 
        } 
        for (int i = 3; i * i <= n; i = i + 2) 
        { 
            while (n % i == 0) 
            { 
                n = n / i; 
                P.add((long)i); 
            } 
        } 
        if (n > 2) 
            P.add(n); 
        if (P.size() < k) 
        {  
            return 0; 
        } 
        else
        {
            return 1;
        }
    } 
    
    public static void main(String[] args) throws java.lang.Exception
    { 
        FastReader sc=new FastReader(); 
        PrintWriter pw=new PrintWriter(System.out);
        
        int t=sc.nextInt();
        while(t-->0)
        {
            int n=sc.nextInt();
            int arr[]=new int[n+1];
            
            int max[]=new int[n+1];
            int min[]=new int[n+1];
            for(int i=0;i<n;i++)
                arr[sc.nextInt()]=i+1;

            max[1]=arr[1];
            min[1]=arr[1];
            int cur_max=arr[1];
            int cur_min=arr[1];
            for(int i=1;i<n+1;i++)
            {
                if(cur_max<arr[i])
                    cur_max=arr[i];
                max[i]=cur_max;

                if(cur_min>arr[i])
                    cur_min=arr[i];
                min[i]=cur_min;
            }

            for(int i=1;i<n+1;i++)
            {
                if(max[i]-min[i]+1==i)
                    pw.print(1);
                else
                    pw.print(0);
            }
            pw.println();
        }
        pw.flush();
    }

} 