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].
//   package com.company;
  import java.util.*;
  import java.io.*;
  import java.lang.*;
  /*
  ** @author jigar_nainuji
   */
  public class Main{

      public static void main(String args[]){
          PrintWriter out=new PrintWriter(System.out);
          InputReader in=new InputReader(System.in);
          TASK solver = new TASK();
//          int t = in.nextInt();
          int t=1;
            for(int i=0;i<t;i++)
            {
                solver.solve(in,out,i);
            }
            out.close();
      }
      static class TASK{
          static int dp[] = new int[63];
          static{
              dp[0]=1;
              for(int i=1;i<63;i++)
              {
                  dp[i]=dp[i-1]*2;
              }
          }
          static boolean CheckForSequence(int dp[], int n, int k)
          {
              for (int i = n - 1; i >= 0; i--)
              {
                  if (k >= dp[i])
                      k -= dp[i];

              }
              if (k != 0)
                  return false;
              else
                  return true;
          }
          void solve(InputReader in,PrintWriter out,int testNumber) {
              int t = in.nextInt();
              while(t-->0)
              {
                  int n = in.nextInt();
                  int a[] = new int[n];
                  int c=0;
                  for(int i=0;i<n;i++)
                      a[i]=in.nextInt();
                  int i=1;
                  while(i<n)
                  {
                      if(a[i]<a[i-1])
                      {
                          int sum=a[i-1]-a[i];
                          if(CheckForSequence(dp,c,sum))
                          {
                              a[i]=a[i-1];
                              i++;
                          }
                          else
                              c++;
                      }
                      else
                          i++;
                  }
                  System.out.println(c);

              }
          }
      }
      static class pair{
          int l;
          int r;
          int idx;
          pair(int l,int r,int idx)
          {
              this.l=l;
              this.r=r;
              this.idx=idx;
          }
      }
      static class InputReader {
          private InputStream stream;
          private byte[] buf = new byte[1024];
          private int curChar;
          private int numChars;
          private SpaceCharFilter filter;

          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() {
              BufferedReader br = new BufferedReader(new InputStreamReader(System.in));
              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);
          }
      }
  }