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 math
import sys

def diff_test(set, k):
    for i in range(k):
        increased_one=False
        curmax=set[0]
        for j in range(len(set)):
            if j==0:
                continue
            if set[j] < curmax:
                increased_one=True
                d=curmax-set[j]
                if d & 1<<i:
                    set[j]=set[j]+2**i
            if set[j] > curmax:
                curmax=set[j]
        if increased_one == False:
            print(f'SRINI:did not increase anything in this cycle : i: {i} k: {k} BAD set:')
        print(f'SRINI:diff_test: i{i}: set : {set}')
    # verify it is a monotonically increasing sequence
    for j in range(len(set)):
        if j==0:
            continue
        if set[j] < set[j-1]:
            print(f'SRINI: BAD sequence: in set {set} TEST FAILED')
            sys.exit(1)

def find_powered_addition(set):
#    print(f'SRINI: input set is {set})')
    diff=[]
    maxi=set[0]
    min=maxi
#    print(f'SRINI: max {maxi} min {min}')
    for i in set:
        if i > maxi:
            diff.append(maxi-min)
#            maxi=2**(math.ceil(math.log2(i-maxi)))
            maxi=i
            min=i
#            print(f'SRINI: max {maxi} min {min}')
        if i < min:
            min = i
#            print(f'SRINI:  min {min}')
    diff.append(maxi-min)
#    print(f'SRINI:diff is {diff}')
    max_diff = max(diff)
#    print(f'SRINI: max in diff is {max_diff}')
    k=0
    while max_diff > 0:
        max_diff = max_diff - (2**k)
#        print (f'SRINI:maxdiff is {max_diff} k value is {k} 2 power kis {(2^k)}')
        k=k+1

#    print(f'iterations {k}')
    print(f'{k}')
#    diff_test(set,k)
    #if k>0:
    #    k=k-1

#    if max_diff != 0:
#        k=math.log2(max_diff)
#    else:
#        k=0
#    print(f'iterations {math.ceil(k+1)}')

total_sets=int(input())
#print(f'No. of input sets {total_sets}')

nset=[]
set=[]
for i in range(total_sets):
    nelements=int(input())
    nset.append(nelements)
#    print(f'no. of elements {nset[i]}')
    elements=input()
    el_list=[]
    for el in elements.split():
        el_list.append(int(el))
    set.append(el_list)
#    print(f'elements in set {i} is {set[i]}')

#print(f'Total elements {nset}')
#print (f'Entire set is {set}')


for i in range(len(set)):
    find_powered_addition(set[i])
