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 pp1 {
    FastScanner in;
    PrintWriter out;
    class Graph{
        int V;
        ArrayList<Integer> adjlist[];
        Graph(int n){
            this.V = n;
            this.adjlist = new ArrayList[n];
            for(int i=0;i<this.V;i++){
                adjlist[i] = new ArrayList<>();
            }
        }
        void addEdge(int u, int v){
            adjlist[u].add(v);
            adjlist[v].add(u);
        }
        int dfs(int start, int dest, boolean[] vis, List<Integer> happy){
            vis[start]=true;
            int sum=0;
            boolean flag=false;
            for(int i=0;i<adjlist[start].size();i++){
                int b = adjlist[start].get(i);
                if(!vis[b]){
                    flag=true;
                    sum+=dfs(b, dest+1,vis, happy );
                }
            }
            int remain = dest-sum;
            happy.add(remain);
            return sum+1;
        }



    }

    List<Integer> []al;
    boolean [] visited;
    int [] parent;

    void bfs(int src,int dest,List<Integer> [] list){
        Queue<Integer> queue=new LinkedList<>();
        queue.add(src);
        parent[src]=-1;
        visited[src]=true;
        while(!queue.isEmpty()){
            int u=queue.poll();

            for(int v : al[u]){
                if(!visited[v]){
                    queue.add(v);
                    parent[v]=u;
                    visited[v]=true;
                    if(v==dest){
                        break;
                    }
                }
            }
        }
        List<Integer> edge=new ArrayList<>();
        edge.add(dest);
        int k=dest;
        while(parent[k]!=src && parent[k]!=-1){
            k=parent[k];
            edge.add(k);
        }
        edge.add(src);
        for(int i=1;i<edge.size();i++){

            int a=edge.get(i-1);
            int b=edge.get(i);
            list[a].add(b);
        }


    }

    long mod = 1000000007;

    int x = 500031;
    int[] a = new int[x];
    void solve() {
        //This is the main logic code
       int t = in.nextInt();
       while(t-->0){
           int n = in.nextInt();
           int []a = new int[n];
           for(int i=0;i<n;i++){
               a[i]=in.nextInt();
           }
           int num = a[0];
           int m=0;
           for(int i=1;i<n;i++){
               if(num-a[i]<0){
                   num=a[i];
                   continue;
               }
               else{
                   if(num-a[i]>m){
                       m=num-a[i];
                   }
               }
           }
           if(m==0){out.println(0);}
           else{out.println((int)(Math.log(m)/Math.log(2.0))+1);}

       }
    }

    public static void main(String[] args) {
        new pp1().runIO();
    }

    void run() {
        try {
            in = new FastScanner(new File("A.in"));
            out = new PrintWriter(new File("A.out"));
            solve();
            out.close();
        } catch (FileNotFoundException e) {
            e.printStackTrace();
        }
    }

    void runIO() {
        in = new FastScanner(System.in);
        out = new PrintWriter(System.out);
        solve();
        out.close();
    }

    class FastScanner {
        BufferedReader br;
        StringTokenizer st;

        public FastScanner(File f) {
            try {
                br = new BufferedReader(new FileReader(f));
            } catch (FileNotFoundException e) {
                e.printStackTrace();
            }
        }

        public FastScanner(InputStream f) {
            br = new BufferedReader(new InputStreamReader(f));
        }

        String next() {
            while (st == null || !st.hasMoreTokens()) {
                String s = null;
                try {
                    s = br.readLine();
                } catch (IOException e) {
                    e.printStackTrace();
                }
                if (s == null)
                    return null;
                st = new StringTokenizer(s);
            }
            return st.nextToken();
        }

        String nextLine() {
            try {
                return br.readLine();
            } catch (IOException e) {
                e.printStackTrace();
            }
            return null;
        }

        boolean hasMoreTokens() {
            while (st == null || !st.hasMoreTokens()) {
                String s = null;
                try {
                    s = br.readLine();
                } catch (IOException e) {
                    e.printStackTrace();
                }
                if (s == null)
                    return false;
                st = new StringTokenizer(s);
            }
            return true;
        }

        int nextInt() {
            return Integer.parseInt(next());
        }

        long nextLong() {
            return Long.parseLong(next());
        }

        double nextDouble() {
            return Double.parseDouble(next());
        }
    }
}