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. 

/*
                       _oo0oo_
                      o8888888o
                      88" . "88
                      (| -_- |)
                      0\  =  /0
                    ___/`---'\___
                  .' \\|     |// '.
                 / \\|||  :  |||// \
                / _||||| -:- |||||- \
               |   | \\\  -  /// |   |
               | \_|  ''\---/''  |_/ |
               \  .-\__  '-'  ___/-. /
             ___'. .'  /--.--\  `. .'___
          ."" '<  `.___\_<|>_/___.' >' "".
         | | :  `- \`.;`\ _ /`;.`/ - ` : | |
         \  \ `_.   \_ __\ /__ _/   .-` /  /
     =====`-.____`.___ \_____/___.-`___.-'=====
                       `=---='
 
*/
import java.util.function.Consumer;
import java.util.*;
import java.math.BigDecimal;
import java.math.BigInteger;
import java.math.RoundingMode;
import java.text.DecimalFormat;
import java.io.*;
import java.lang.Math.*;
 public class KickStart2020{
	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());}
        float nextFloat() {return Float.parseFloat(next());}
        String nextLine() {
            String str = "";
            try {str = br.readLine();}
            catch (IOException e) { e.printStackTrace();}
            return str; }}
	static boolean isBracketSequence(String s, int a, int b) {
		Stack<Character> ss = new Stack<>();
		boolean hachu = true;
		for(int i = a; i <= b; i++) {
			if(s.charAt(i) == ')' && ss.isEmpty()) {hachu = false; break;}
			if(s.charAt(i) == '(') ss.add('(');
			else ss.pop();
		}
		return ss.empty() && hachu;
	}
	static String reverseOfString(String a) {
		StringBuilder ssd = new StringBuilder();
		for(int i = a.length() - 1; i >= 0; i--) {
			ssd.append(a.charAt(i));
		}
		return ssd.toString();
	}
	static char[] reverseOfChar(char a[]) {
		char b[] = new char[a.length];
		int j = 0;
		for(int i = a.length - 1; i >= 0; i--) {
			b[i] = a[j];
			j++;
		}
		return b;
	}
	static boolean isPalindrome(char a[]) {
		boolean hachu = true;
		for(int i = 0; i <= a.length / 2; i++) {
			if(a[i] != a[a.length - 1 - i]) {
				hachu = false;
				break;
			}
		}
		return hachu;
	} 
	static long gcd(long a, long b)
	{
	    if (b == 0)
	        return a;
	    return gcd(b, a % b);
	     
	}
	static long power(long x, long y, long mod){
	    long ans = 1;
	    x = x % mod; 
	    if (x == 0)
	      return 0; 
	    int i = 1;
	    while (y > 0){
	      if ((y & 1) != 0)
	        ans = (ans * x) % mod;
	      y = y >> 1; 
	      x = (x * x) % mod;
	    }
	    return ans;
	  }
	static boolean check(String a) {
		boolean hachu = true;
		for(int i = 0; i < a.length(); i++) {
			if(a.charAt(0) != a.charAt(i)) {hachu = false; break;}
		}
		return hachu;
	}
	 public static class Pair implements Comparable<Pair> {
	        public final int index;
	        public final int value;
	 
	        public Pair(int index, int value) {
	            this.index = index;
	            this.value = value;
	        }
	        @Override
	        public int compareTo(Pair other) {
	            //multiplied to -1 as the author need descending sort order
	            return  -1 * Integer.valueOf(this.value).compareTo(other.value);
	        }
	 }
	 static boolean equalString(int i, int j, int arr[], String b) {
		 int brr[] = new int[26];
		 for(int k = i; k <= j; k++) brr[b.charAt(k) - 'a']++;
		 for(int k = 0; k < 26; k++) {
			 if(arr[k] != brr[k]) return false;
		 }
		 return true;
	 }
	 static boolean cequalArray(String a, String b) {
		  int count[] = new int[26];
		  int count1[] = new int[26];
		  for(int i = 0; i < a.length(); i++) count[a.charAt(i) - 'a']++;
		  for(int i = 0; i < a.length(); i++) count1[b.charAt(i) - 'a']++;
		  for(int i = 0; i < 26; i++) if(count[i] != count1[i]) return false;
		  return true;
	 }
	 
		public static void main(String[] args) throws Exception{
			FastReader sc = new FastReader();
			PrintWriter out = new PrintWriter(System.out);
            int t = sc.nextInt();
            outerloop:
             while(t-- > 0) {
             int n = sc.nextInt();
             int arr[] = new int[n];
             HashMap<Integer, Integer> ss = new HashMap<>();
             for(int i = 0; i < n; i++) {
            	 arr[i] = sc.nextInt();
            	 ss.put(arr[i], i);
             }
             TreeSet<Integer> ssd = new TreeSet<>();
             for(int i = n; i >= 2; i--) {
            	 if(!ssd.isEmpty() && ssd.contains(i)) continue;
            	 else {
            		 if(ss.get(i) > ss.get(1)) {
            			 if(!ssd.isEmpty() && ssd.first() < i) ssd.add(i);
            			 arr[ss.get(i)] = 0;
            			 for(int j = ss.get(i) + 1; j < n; j++) {
            				 if(arr[j] == 0) break;
            				 ssd.add(arr[j]);
            				 arr[j] = 0;
            			 }
            		 }
            		 else {
            			 if(!ssd.isEmpty() && ssd.first() < i) ssd.add(i);
            			 arr[ss.get(i)] = 0;
            			 for(int j = ss.get(i) - 1; j >= 0; j--) {
            				 if(arr[j] == 0) break;
            				 ssd.add(arr[j]);
            				 arr[j] = 0;
            			 } 
            		 }
            	 }
             }
             for(int i = 1; i <= n; i++) {
            	 if(ssd.contains(i)) out.print("0");
            	 else out.print("1");
             }
             out.println();
             }
                 out.close();
			}
		}