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.*;
import java.math.*;
import java.lang.*;
 
import static java.lang.Math.*;
 
public class codeforces implements Runnable
{
static class InputReader
{
private InputStream stream;
private byte[] buf = new byte[1024];
private int curChar;
private int numChars;
private SpaceCharFilter filter;
private BufferedReader br = new BufferedReader(new InputStreamReader(System.in));
 
public InputReader(InputStream stream)
{
this.stream = stream;
}
 
public int read()
{
if (numChars==-1)
throw new InputMismatchException();
if (curChar >= numChars)
{
curChar = 0;
try
{
numChars = stream.read(buf);
}
catch (IOException e)
{
throw new InputMismatchException();
}
               
if(numChars <= 0)              
return -1;
}
return buf[curChar++];
}
     
public String nextLine()
{
String str = "";
try
{
str = br.readLine();
}
catch (IOException e)
{
e.printStackTrace();
}
return str;
}
public int nextInt()
{
int c = read();
           
while(isSpaceChar(c))
c = read();
 
int sgn = 1;
       
if (c == '-')
{
sgn = -1;
c = read();
}
           
int res = 0;
do
{
if(c<'0'||c>'9')
throw new InputMismatchException();
res *= 10;
res += c - '0';
c = read();
}
while (!isSpaceChar(c));
       
return res * sgn;
}
       
public long nextLong()
{
int c = read();
while (isSpaceChar(c))
c = read();
int sgn = 1;
if (c == '-')
{
sgn = -1;
c = read();
}
long res = 0;
 
do
{
if (c < '0' || c > '9')
throw new InputMismatchException();
res *= 10;
res += c - '0';
c = read();
}
while (!isSpaceChar(c));
return res * sgn;
}
 
public double nextDouble()
{
int c = read();
while (isSpaceChar(c))
c = read();
int sgn = 1;
if (c == '-')
{
sgn = -1;
c = read();
}
double res = 0;
while (!isSpaceChar(c) && c != '.')
{
if (c == 'e' || c == 'E')
return res * Math.pow(10, nextInt());
if (c < '0' || c > '9')
throw new InputMismatchException();
res *= 10;
res += c - '0';
c = read();
}
if (c == '.')
{
c = read();
double m = 1;
while (!isSpaceChar(c))
{
if (c == 'e' || c == 'E')
return res * Math.pow(10, nextInt());
if (c < '0' || c > '9')
throw new InputMismatchException();
m /= 10;
res += (c - '0') * m;
c = read();
}
}
return res * sgn;
}
   
public String readString()
{
int c = read();
while (isSpaceChar(c))
c = read();
StringBuilder res = new StringBuilder();
do
{
res.appendCodePoint(c);
c = read();
}
while (!isSpaceChar(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;
}
     
public String next()
{
return readString();
}
       
public interface SpaceCharFilter
{
public boolean isSpaceChar(int ch);
}
}
public static void main(String args[]) throws Exception
{
new Thread(null, new codeforces(),"Main",1<<27).start();
}
 
public static long gcd(long a, long b)
{
if (a == 0)
return b;
return gcd(b % a, a);
}
 
public static long findGCD(long arr[], int n)
{
long result = arr[0];
for (int i = 1; i < n; i++)
result = gcd(arr[i], result);
return result;
}
 
static void sortbycolomn(long arr[][], int col)
    {
         
        Arrays.sort(arr, new Comparator<long[]>() {
           
          @Override              
           
          public int compare(final long[] entry1,  
                             final long[] entry2) {
 
           
            if (entry1[col] > entry2[col])
                return 1;
            else
                return -1;
          }
        });  
    }
public long no(int i,long sum,int cntr, long arr[],int N)
{
    if(i==N)
    {
        if(sum != 1 && cntr>0)
            return 1;
        else
            return 0;
    }
    long count = 0;
    count += no(i + 1, sum, cntr, arr, N); 
    count += no(i + 1, sum + arr[i],cntr+1,arr,N);
    return count;
}
public void run()
{
InputReader scan = new InputReader(System.in);
PrintWriter write = new PrintWriter(System.out);
int test_case=scan.nextInt();
while(test_case-->0){
  int N = scan.nextInt();
  int i = 0;
  int a[] = new int[N];
  int b[] = new int[N];
  for( i = 0; i < N; i++)
  {
    a[i] = scan.nextInt();
  }
  int current = a[0];
  b[0] = 0;
  for( i = 1; i < N ; i++)
  {
      int count = 0;
      if(current > a[i])
      {
          int diff = current - a[i];
           while(diff!=0)
           {
                diff = diff >> 1;
                count++;
           }
           b[i] = count;
      }
      else{
        b[i] = 0;
        current = a[i];
      }
  }
  Arrays.sort(b);
  write.println(b[N-1]);
}
write.flush();
write.close();
}
}
