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.text.*;
import java.lang.*;
import java.math.*;
 
public class Myclass{
    static ArrayList[] a=new ArrayList[30];
     public void solve () throws FileNotFoundException  {
    	InputReader in = new InputReader(System.in);
        PrintWriter pw = new PrintWriter(System.out);
        int t = in.nextInt();
        while(t -- >0) {
        	int n  = in.nextInt();
        	int a[] = new int [n];
        	int idx[] = new int [n + 5];
        	for(int i = 0 ; i < n ; i ++) {
        		a[i] = in.nextInt();
        		idx[a[i]] = i;
        	}
        	int ans [] = new int [n + 1];
        	ans[1] = 1;
        	int l = idx[1];
        	int r =idx[1];
        	for(int i = 2 ; i <= n ; i++) {
        		l = Math.min(l, idx[i]);
        		r = Math.max(r, idx[i]);
        		if(r - l + 1 == i)
        			ans[i] = 1;
        	}
        	for(int i = 1 ; i <= n ; i++) {
        		pw.print(ans[i]);
        	}
        	pw.println();
        }
        pw.flush();
        pw.close();
    }
    public static void main(String[] args) throws Exception {
        
        
        new Thread(null,new Runnable() {
            public void run() {
                    try {
						new Myclass().solve();
					} catch (FileNotFoundException e) {
						// TODO Auto-generated catch block
						e.printStackTrace();
					}
            }
        },"1",1<<26).start();
        
        
    }
   
    static void debug(Object... o) {
        System.out.println(Arrays.deepToString(o));
        }
        
        static class InputReader 
        {
        private final InputStream stream;
        private final byte[] buf = new byte[8192];
        private int curChar, snumChars;
        private SpaceCharFilter filter;
 
        public InputReader(InputStream stream) 
        {
            this.stream = stream;
        }
        public int snext() 
        {
            if (snumChars == -1)
                throw new InputMismatchException();
            if (curChar >= snumChars) 
            {
                curChar = 0;
                try 
                {
                    snumChars = stream.read(buf);
                } 
                catch (IOException e) 
                {
                    throw new InputMismatchException();
                }
                if (snumChars <= 0)
                    return -1;
            }
            return buf[curChar++];
        }
 
        public int nextInt() 
        {
            int c = snext();
            while (isSpaceChar(c)) 
            {
                c = snext();
            }
            int sgn = 1;
            if (c == '-')
            {
                sgn = -1;
                c = snext();
            }
            int res = 0;
            do 
            {
                if (c < '0' || c > '9')
                    throw new InputMismatchException();
                res *= 10;
                res += c - '0';
                c = snext();
            } while (!isSpaceChar(c));
            return res * sgn;
        }
 
        public long nextLong()
        {
            int c = snext();
            while (isSpaceChar(c)) 
            {
                c = snext();
            }
            int sgn = 1;
            if (c == '-') 
            {
                sgn = -1;
                c = snext();
            }
            long res = 0;
            do 
            {
                if (c < '0' || c > '9')
                    throw new InputMismatchException();
                res *= 10;
                res += c - '0';
                c = snext();
            } while (!isSpaceChar(c));
            return res * sgn;
        }
 
        public int[] nextIntArray(int n) 
        {
            int a[] = new int[n];
            for (int i = 0; i < n; i++) 
            {
                a[i] = nextInt();
            }
            return a;
        }
 
        public String readString()
        {
            int c = snext();
            while (isSpaceChar(c)) 
            {
                c = snext();
            }
            StringBuilder res = new StringBuilder();
            do 
            {
                res.appendCodePoint(c);
                c = snext();
            } while (!isSpaceChar(c));
            return res.toString();
        }
 
        public String nextLine() 
        {
            int c = snext();
            while (isSpaceChar(c))
                c = snext();
            StringBuilder res = new StringBuilder();
            do 
            {
                res.appendCodePoint(c);
                c = snext();
            } while (!isEndOfLine(c));
            return res.toString();
        }
 
        public boolean isSpaceChar(int c) 
        {
            if (filter != null)
                return filter.isSpaceChar(c);
            return c == ' ' || c == '\n' || c == '\r' || c == '\t' || c == -1;
        }
 
        private boolean isEndOfLine(int c) 
        {
            return c == '\n' || c == '\r' || c == -1;
        }
 
        public interface SpaceCharFilter
        {
            public boolean isSpaceChar(int ch);
        }
    }
        public static long mod = 1000000007;
        public static int d;
        public static int p;
        public static int q;
        public void extended(int a,int b) {
            if(b==0) {
                d=a;
                p=1;
                q=0;
            }
            else
            {
                extended(b,a%b);
                int temp=p;
                p=q;
                q=temp-(a/b)*q;
            }
        }
       
        
        public static long binaryExponentiation(long x,long n)
        {
            long result=1;
            while(n>0)
            {
                if(n % 2 ==1)
                    result=result * x;
                x=x*x;
                n=n/2;
            }
            return result;
        }
        
        public static long[] shuffle(long[] a,Random gen)
        {
            int n = a.length;
            for(int i=0;i<n;i++)
            {
                int ind = gen.nextInt(n-i)+i;
                long temp = a[ind];
                a[ind] = a[i];
                a[i] = temp;
            }
            return a;
        }
        
        public static void swap(int a, int b){
            int temp = a;
            a = b;
            b = temp;
        }
        
        public static HashSet<Integer> primeFactorization(int n)
        {
            HashSet<Integer> a =new HashSet<Integer>();
            for(int i=2;i*i<=n;i++)
            {
                while(n%i==0)
                {
                    a.add(i);
                    n/=i;
                }
            }
            if(n!=1)
                a.add(n);
            return a;
        }
        
        public static void sieve(boolean[] isPrime,int n)
        {
            for(int i=1;i<n;i++)
                isPrime[i] = true;
            
            isPrime[0] = false;
            isPrime[1] = false;
            
            for(int i=2;i*i<n;i++)
            {
                if(isPrime[i] == true)
                {
                    for(int j=(2*i);j<n;j+=i)
                        isPrime[j] = false;
                }
            }
        }
        
        public static long GCD(long n,long m)
        {
            if(m==0)
                return n;
            else
                return GCD(m,n%m);
        }
        public static long LCM (long a,long b) {
            return ((a*b)/(GCD(a,b)));
        }
        
        static class pair implements Comparable<pair>
        {
           Long x, y;
            
            pair(long seg,long minValue)
            {
                this.x=seg;
                this.y=minValue;
            }

            public int compareTo(pair o) {
                int result = x.compareTo(o.x);
                if(result==0)
                    result = y.compareTo(o.y);
                
                return result;
            }  
            
            public String toString()
            {
                return x+" "+y;
            }
            
            public boolean equals(Object o)
            {
                if (o instanceof pair)
                {
                    pair p = (pair)o;
                    return p.x == x && p.y == y ;
                }
                return false;
            }
            
            public int hashCode()
            {
                return new Double(x).hashCode()*31 + new Long(y).hashCode();
            }
        }
        public static int binaryExponentiation(int x,int n)
        {
            int result=1;
            while(n>0)
            {
                if(n % 2 ==1)
                    result=result * x;
                x=x*x;
                n=n/2;
            }
            return result;
        }
        
       
        
        public static int modularExponentiation(int x,int n,int M)
        {
            int result=1;
            while(n>0)
            {
                if(n % 2 ==1)
                    result=(result * x)%M;
                x=(x%M*x)%M;
                n=n/2;
            }
            return result;
        }
        
        public static long modularExponentiation(long x,long n,long M)
        {
            long result=1;
            while(n>0)
            {
                if(n % 2 ==1)
                    result=(result%M * x%M)%M;
                x=(x%M * x%M)%M;
                n=n/2;
            }
            return result;
        }
        
        public static long modInverse(int A,int M)
        {
            return modularExponentiation(A,M-2,M);
        }
        
        public static long modInverse(long A,long M)
        {
            return modularExponentiation(A,M-2,M);
        }
        static class Segment{ 
        	long seg[][]; 
        	long a[];
        	long lazy[];
            Segment (int n){
        		seg=new long[4*n][2];
        		lazy=new long[4*n];
        	}
            public void build(int node,int start,int end) {
            	if(start==end) {
            		seg[node][0]=0L;
            		seg[node][1] = 0L;
            		return ;
            	}
            	int mid=(start+end)/2;
            	build(2*node+1,start,mid);
            	build(2*node+2,mid+1,end);
            }
            /*public void update(int node,int start,int end,int id,int val) {
            	if(start==end) {
            		seg[node][]=a[start]=val;
            		return;
            	}
            	int mid=(start+end)/2;
            	if(id>=start && id<=mid) {
            		update(2*node+1,start,mid,id,val);
            	}
            	else
            		update(2*node+2,mid+1,end,id,val);
            	seg[node]=seg[2*node+1]+seg[2*node+2];
            }
            public long query(int node,int start,int end,int l,int r) {
            	if(l>end || r<start)
            		return 0;
            	if(start>=l && end<=r)
            		return seg[node];
            	
            	int  mid=(start+end)/2;
            	return query(2*node+1,start,mid,l,r) + query(2*node+2,mid+1,end,l,r);
            }*/
            public void updateRange(int node,int start,int end,int l,int r,int val) {
        
            	if(lazy[node]!=0) {
            		seg[node][0]+=lazy[node];
            		seg[node][1]+=lazy[node];

            		if(start!=end) {
            			lazy[2*node+1]+=lazy[node];
            			lazy[2*node+2]+=lazy[node];
            		}
            		lazy[node]=0;
            	}
            	if(l>end || r<start)
            		return ;
            	if(start>=l && end<=r) {
            		seg[node][0]+=val;
            		seg[node][1]+=val;
            		if(start!=end) {
            			lazy[2*node+1]+=val;
            			lazy[2*node+2]+=val;
            		}
            		lazy[node]=0;
            		return ;
            	}
            	int mid=(start+end)/2;
            	updateRange(2*node+1,start,mid,l,r,val);
            	updateRange(2*node+2,mid+1,end,l,r,val);
            	seg[node][0]=Math.min(seg[2*node+1][0] , seg[2*node+2][0]);
            	seg[node][1]=Math.max(seg[2*node+1][1] , seg[2*node+2][1]);

            }
            public pair queryRange(int node,int start,int end,int l,int r) {
            	if(l>end || r<start)
            		return new pair(Long.MAX_VALUE,Long.MIN_VALUE);
            	if(lazy[node]!=0) {
            		seg[node][0]+=lazy[node];
            		seg[node][1]+=lazy[node];
            		if(start!=end) {
            			lazy[2*node+1]+=lazy[node];
            			lazy[2*node+2]+=lazy[node];
            		}
            		lazy[node]=0;
            	}
            	if(start>=l && end<=r)
            		return new pair(seg[node][0],seg[node][1]);
            	
            	int  mid=(start+end)/2;
            	pair p1 = queryRange(2*node+1,start,mid,l,r);
            	pair p2 = queryRange(2*node+2,mid+1,end,l,r);
            	return new pair(Math.min(p1.x, p2.x) , Math.max(p1.y, p2.y));
            }
            
        }

        
         
}
