You have an array a of length n. For every positive integer x you are going to perform the following operation during the x-th second:

  * Select some distinct indices i_{1}, i_{2}, …, i_{k} which are between 1 and n inclusive, and add 2^{x-1} to each corresponding position of a. Formally, a_{i_{j}} := a_{i_{j}} + 2^{x-1} for j = 1, 2, …, k. Note that you are allowed to not select any indices at all.



You have to make a nondecreasing as fast as possible. Find the smallest number T such that you can make the array nondecreasing after at most T seconds.

Array a is nondecreasing if and only if a_{1} ≤ a_{2} ≤ … ≤ a_{n}.

You have to answer t independent test cases.

Input

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

The first line of each test case contains single integer n (1 ≤ n ≤ 10^{5}) — the length of array a. It is guaranteed that the sum of values of n over all test cases in the input does not exceed 10^{5}.

The second line of each test case contains n integers a_{1}, a_{2}, …, a_{n} (-10^{9} ≤ a_{i} ≤ 10^{9}).

Output

For each test case, print the minimum number of seconds in which you can make a nondecreasing.

Example

Input


3
4
1 7 6 5
5
1 2 3 4 5
2
0 -4


Output


2
0
3

Note

In the first test case, if you select indices 3, 4 at the 1-st second and 4 at the 2-nd second, then a will become [1, 7, 7, 8]. There are some other possible ways to make a nondecreasing in 2 seconds, but you can't do it faster.

In the second test case, a is already nondecreasing, so answer is 0.

In the third test case, if you do nothing at first 2 seconds and select index 2 at the 3-rd second, a will become [0, 0].
import java.io.*;
import java.util.*;
 
public class Temp{
    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; 
        } 
    } 
    static int getgcd(int n1,int n2){
        while(n1 != n2)
        {
            if(n1 > n2)
                n1 -= n2;
            else
                n2 -= n1;
        }
        return n1;
    }
    public static void main(String[] args) throws NumberFormatException, IOException {
        FastReader s=new FastReader(); 
        int t=s.nextInt();
        int n,min,max,maxi,mini,ans;
        boolean test;
        while(t>0){
            test=true;
            min=1000000001;ans=0;max=0;maxi=0;mini=0;
            n=s.nextInt();
            int[] arr = new int[n];
            arr[0]=s.nextInt();max=arr[0];
            for(int i=1;i<n;i++){
                arr[i]=s.nextInt();
                if(arr[i]>max){
                    max=arr[i];
                    maxi=i;
                }
                if(arr[i]<arr[i-1]) test=false;
            }
            if(!test){
                for(int i=1;i<n;i++){
                    // if(i<maxi && arr[i]<arr[i-1]){
                    //     //int temp=arr[i-1];
                    //     // while(i<n&&arr[i]<arr[i-1]) i++;
                    //     // i--;
                    //     min=arr[i-1]-arr[i];
                    //     int j=0,temp=0;
                    //     while(min>0){
                    //         min-=Math.pow(2, j);
                    //         if(++temp>ans) ans++;
                    //         j++;
                    //     }
                    // }
                    // else if(arr[i]<arr[i-1]){
                    //     min=arr[i];
                    //     for(int k=i+1;k<n;k++){
                    //         if(arr[k]<min) min=arr[k];
                    //     }
                    //     min=max-min;
                    //     int j=0,temp=0;
                    //     while(min>0){
                    //         min-=Math.pow(2, j);
                    //         if(++temp>ans) ans++;
                    //         j++;
                    //     }
                    //     break;
                    // }
                    if(arr[i]<arr[i-1]){
                        min=arr[i-1]-arr[i];
                        int j=0,temp=0;
                        while(min>0){
                            min-=Math.pow(2, j);
                            if(++temp>ans) ans++;
                            j++;
                        }
                        arr[i]=arr[i-1];
                    }
                }
            }
            System.out.println(ans);
            t--;
        }
    }
}