description: You are given an integer n. In 1 move, you can do one of the following actions:
  
    * erase any digit of the number (it's acceptable that the number before the operation has exactly one digit and after the operation, it is "empty"); 
    * add one digit to the right. 
  
  
  
  The actions may be performed in any order any number of times.
  
  Note that if, after deleting some digit from a number, it will contain leading zeroes, they will not be deleted. E.g. if you delete from the number 301 the digit 3, the result is the number 01 (not 1).
  
  You need to perform the minimum number of actions to make the number any power of 2 (i.e. there's an integer k (k ≥ 0) such that the resulting number is equal to 2^k). The resulting number must not have leading zeroes.
  
  E.g. consider n=1052. The answer is equal to 2. First, let's add to the right one digit 4 (the result will be 10524). Then let's erase the digit 5, so the result will be 1024 which is a power of 2.
  
  E.g. consider n=8888. The answer is equal to 3. Let's erase any of the digits 8 three times. The result will be 8 which is a power of 2.
  
  Input
  
  The first line contains one integer t (1 ≤ t ≤ 10^4) — the number of test cases. Then t test cases follow.
  
  Each test case consists of one line containing one integer n (1 ≤ n ≤ 10^9).
  
  Output
  
  For each test case, output in a separate line one integer m — the minimum number of moves to transform the number into any power of 2.
  
  Example
  
  Input
  
  
  12
  1052
  8888
  6
  75
  128
  1
  301
  12048
  1504
  6656
  1000000000
  687194767
  
  
  Output
  
  
  2
  3
  1
  3
  0
  0
  2
  1
  3
  4
  9
  2
  
  Note
  
  The answer for the first test case was considered above.
  
  The answer for the second test case was considered above.
  
  In the third test case, it's enough to add to the right the digit 4 — the number 6 will turn into 64.
  
  In the fourth test case, let's add to the right the digit 8 and then erase 7 and 5 — the taken number will turn into 8.
  
  The numbers of the fifth and the sixth test cases are already powers of two so there's no need to make any move.
  
  In the seventh test case, you can delete first of all the digit 3 (the result is 01) and then the digit 0 (the result is 1).
solution: import java.io.BufferedReader;
  import java.io.IOException;
  import java.io.InputStreamReader;
  import java.util.ArrayList;
  import java.util.List;
  import java.util.StringTokenizer;
  
  import static java.lang.Math.*;
  
  public class Round739 {
  
      //------------------------------------------CONSTANTS---------------------------------------------------------------
      public static final int MOD = (int) (1e9 + 7);
  
      //---------------------------------------------I/0------------------------------------------------------------------
  
      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;
          }
      }
  
      public static void print(String s) {
          System.out.println(s);
      }
  
      public static void main(String[] args) {
          FastReader sc = new FastReader();
  
          int t = 1;
          t = sc.nextInt();
  
          for(int i = 0; i<t; i++) {
              System.out.println(solve(sc));
          }
      }
  
      //------------------------------------------------SOLVE-------------------------------------------------------------
  
      public static int solve(FastReader sc) {
          int n = sc.nextInt();
  
          String s = Integer.valueOf(n).toString();
          int min = s.length() + 1;
  
          for (int i = 0; i<64; i++) {
              StringBuilder x = new StringBuilder("");
              long pp = (long)Math.pow(2, i);
              String p = Long.valueOf(pp).toString();
              StringBuilder ss = new StringBuilder(s);
              int cnt = 0;
              for (int j = 0; j<p.length(); j++) {
                  int idx = ss.substring(x.length(), ss.length()).indexOf(Character.valueOf(p.charAt(j)).toString());
                  if (idx != -1) {
                      idx += x.length();
                  }
                  if (idx == -1) {
                      cnt += (ss.length() - x.length()) + (p.length() - j);
                      break;
                  } else {
                      if (idx!=x.length()) {
                          ss.delete(0, idx);
                          cnt += idx - x.length();
                          ss.insert(0, x);
                          x.append(p.charAt(j));
                      } else {
                          x.append(p.charAt(j));
                      }
                      if (j==p.length()-1) {
                          if (ss.length() > p.length()) {
                              cnt += ss.length() - p.length();
                          }
                      }
                  }
              }
              min = min(min, cnt);
          }
  
          return min;
      }
  
      //-----------------------------------------------FUNCTIONS----------------------------------------------------------
  
      public static String printArray(int[] a) {
          StringBuilder s = new StringBuilder("");
          for(int i = 0; i<a.length; i++) {
              s.append(a[i] + " ");
          }
          return s.toString();
      }
  
      // first element that is not less than target
      public static int lowerBound(int[] arr, int begin, int end, int target) {
          while(begin < end) {
              int mid = begin + (end - begin) / 2;
              // When the element is less than the mid target
              if(arr[mid] < target)
                  // begin to mid + 1, arr [begin] value is less than or equal target
                  begin = mid + 1;
                  // When the mid target element when greater than or equal
              else if(arr[mid] >= target)
                  end = mid;
          }
          return begin;
      }
  
      // first element that is greater than target
      public static int upperBound(int[] arr, int begin, int end, int target) {
          while(begin < end) {
              int mid = begin + (end - begin) / 2;
              if(arr[mid] <= target)
                  begin = mid + 1;
              else if(arr[mid] < target)
                  end = mid;
          }
          return begin;
      }
  
      // generate permutations (call search and access through permutations)
      public static class Permutations {
          List<List<Integer>> permutations = new ArrayList<>();
          List<Integer> permutation = new ArrayList<>();
          boolean[] taken;
          int[] a;
  
          public Permutations(int[] a) {
              this.a = a;
              taken = new boolean[a.length];
          }
  
          void search() {
              if (permutation.size()==a.length) {
                  permutations.add(new ArrayList<>(permutation));
              } else {
                  for (int i = 0; i<a.length; i++) {
                      if (taken[i]) {
                          continue;
                      }
                      taken[i] = true;
                      permutation.add(a[i]);
                      search();
                      taken[i] = false;
                      permutation.remove(permutation.size()-1);
                  }
              }
          }
      }
  
      // generate subsets (call search and access subsets)
      public static class Subsets {
          List<List<Integer>> subsets = new ArrayList<>();
          List<Integer> subset = new ArrayList<>();
  
          void search(int[] a, int x) {
              if (x == a.length) {
                  subsets.add(new ArrayList<>(subset));
              } else {
                  subset.add(a[x]);
                  search(a, x+1);
                  subset.remove(subset.size() - 1);
                  search(a, x+1);
              }
          }
      }
  
      public static int gcd(int a, int b) {
          while (b != 0) {
              int t = b;
              b = a % b;
              a = t;
          }
          return a;
      }
  
      public static int lcm(int a, int b) {
          return (a*b)/gcd(a, b);
      }
  
      public static int[] prefixSum(int[] a) {
          int n = a.length;
          int[] ps = new int[n];
          ps[0] = a[0];
  
          for (int i = 1; i<n; i++) {
              ps[i] = ps[i-1] + a[i];
          }
  
          return ps;
      }
  
      public static int[][] prefixSum2D(int[][] a) {
          int n = a.length;
          int m = a[0].length;
          int[][] ps = new int[n][m];
          ps[0][0] = a[0][0];
  
          for (int j = 1; j<m; j++) {
              ps[0][j] = ps[0][j-1] + a[0][j];
          }
          for (int i = 1; i<n; i++) {
              ps[i][0] = ps[i-1][0] + a[i][0];
          }
  
          for (int i = 1; i<n; i++) {
              for (int j = 1; j<m; j++) {
                  ps[i][j] = ps[i-1][j] + ps[i][j-1] - ps[i-1][j-1] + a[i][j];
              }
          }
  
          return ps;
      }
  
      public static double log2(double a) {
          return log(a)/log(2);
      }
  
      //----------------------------------------DATA-STRUCTURES-----------------------------------------------------------
  
      // Range STATIC queries (i.e. RMQ) in O(1), others with functions in O(log n)
      public static class SparseTable {
          int[][] st;
          int n;
          int k;
  
          public SparseTable(int[] a) {
              n = a.length;
              k = (int) log2(n);
              st = new int[n][k+1];
  
              for (int i = 0; i<n; i++) {
                  st[i][0] = a[i];
              }
  
              // 1<<j == 2^j
              for (int j = 1; j<=k; j++) {
                  for (int i = 0; i + (1 << j) <= n; i++) {
                      st[i][j] = min(st[i][j-1], st[i + (1 << (j - 1))][j - 1]);
                  }
              }
          }
  
          //not always available O(log n) -- change the constructor to use it
          public long sumQuery(int l, int r) {
              long sum = 0;
              for (int j = k; j>=0; j--) {
                  if ((1 << j) <= r - l + 1) {
                      sum += st[l][j];
                      l += 1 << j;
                  }
              }
  
              return sum;
          }
  
          //always available O(1) -- change this and the constructor for rangeMaxQuery
          public int rangeMinQuery(int l, int r) {
              int j = (int) log2(r - l + 1);
              int min = min(st[l][j], st[r - (1 << j) + 1][j]);
              return min;
          }
  
      }
  
      //Range Sum Dynamic Queries O(log n)
      public static class BinaryIndexedTree {
  
          int[] bit;
  
          public BinaryIndexedTree(int[] a) {
              int n = a.length;
              bit = new int[n+1];
              // Store the actual values in BITree[]
              // using update()
              for(int i = 0; i < n; i++)
                  updateBit(i, a[i]);
          }
  
          // O(log n) update delta at index in the array (do it on the array and then call this function)
          public void updateBit(int index, int delta) {
              index += 1;
  
              while (index <= bit.length) {
                  bit[index] += delta;
  
                  index += index & (-index);
              }
          }
  
          // Computes sum a[0...index] in O(log n)
          public int getSum(int index) {
              int sum = 0;
  
              index += 1;
  
              while (index > 0) {
                  sum += bit[index];
  
                  index -= index & (-index);
              }
  
              return sum;
          }
      }
  
      public static class UnionFind {
  
          int[] link;
          int[] size;
  
          UnionFind(int n) {
              link = new int[n];
              size = new int[n];
              for (int i = 0; i<n; i++) {
                  link[i] = i;
                  size[i] = 1;
              }
          }
  
          int find(int x) {
              while (x != link[x]) x = link[x];
              return x;
          }
  
          boolean same(int a, int b) {
              return find(a) == find(b);
          }
  
          void unite(int a, int b) {
              a = find(a);
              b = find(b);
  
              if (size[a] < size[b]) {
                  int temp = a;
                  a = b;
                  b = temp;
              }
  
              size[a] += size[b];
              link[b] = a;
          }
      }
  
      public static class SegmentTree {
  
          int st[];
  
          public SegmentTree(int arr[]) {
              int n = arr.length;
  
              int x = (int) (Math.ceil(log2(n)));
  
              int maxSize = 2 * (int) Math.pow(2, x) - 1;
  
              st = new int[maxSize];
  
              build(arr, 0, n-1, 0);
          }
  
          int build(int arr[], int ss, int se, int si) {
              if (ss == se) {
                  st[si] = arr[ss];
                  return arr[ss];
              }
  
              int mid = ss + (se - ss) / 2; //ss+se/2
  
              st[si] = build(arr, ss, mid, si * 2 + 1) +
                      build(arr, mid + 1, se, si * 2 + 2);
              return st[si];
          }
  
          private int getSumUtil(int ss, int se, int l, int r, int si) {
              if (l <= ss && r >= se) {
                  return st[si];
              }
  
              if (se < l || ss > r) {
                  return 0;
              }
  
              int mid = ss + (se - ss) / 2;
              return getSumUtil(ss, mid, l, r, 2 * si + 1) +
                      getSumUtil(mid + 1, se, l, r, 2 * si + 2);
          }
  
          void updateValueUtil(int ss, int se, int i, int diff, int si) {
              if (i < ss || i > se) {
                  return;
              }
  
              st[si] = st[si] + diff;
              if (se != ss) {
                  int mid = ss + (se - ss) / 2;
                  updateValueUtil(ss, mid, i, diff, 2 * si + 1);
                  updateValueUtil(mid + 1, se, i, diff, 2 * si + 2);
              }
          }
  
          int getSum(int n, int l, int r) {
              if (l < 0 || r > n - 1 || l > r) {
                  return -1;
              }
  
              return getSumUtil(0, n-1, l, r, 0);
          }
  
          // don't do it directly on the array but use this function that will
          // do everything for you
          void updateValue(int arr[], int n, int i, int newValue) {
              if (i < 0 || i > n - 1) {
                  return;
              }
  
              int diff = newValue - arr[i];
  
              arr[i] = newValue;
  
              updateValueUtil(0, n - 1, i, diff, 0);
          }
      }
  }