There are N positive integers written on a blackboard: A_1, ..., A_N.
Snuke can perform the following operation when all integers on the blackboard are even:
 - Replace each integer X on the blackboard by X divided by 2.
Find the maximum possible number of operations that Snuke can perform.

-----Constraints-----
 - 1 \leq N \leq 200
 - 1 \leq A_i \leq 10^9

-----Input-----
Input is given from Standard Input in the following format:
N
A_1 A_2 ... A_N

-----Output-----
Print the maximum possible number of operations that Snuke can perform.

-----Sample Input-----
3
8 12 40

-----Sample Output-----
2

Initially, [8, 12, 40] are written on the blackboard.
Since all those integers are even, Snuke can perform the operation.
After the operation is performed once, [4, 6, 20] are written on the blackboard.
Since all those integers are again even, he can perform the operation.
After the operation is performed twice, [2, 3, 10] are written on the blackboard.
Now, there is an odd number 3 on the blackboard, so he cannot perform the operation any more.
Thus, Snuke can perform the operation at most twice.

Difficulty: introductory

Starter code:

Solutions:
n = int(input())
a = list(map(int, input().split()))

cnt = 0
for i in range(n):
    cnt = cnt | a[i]

j = 0
ans = 0
while 1:
    if (cnt >> j & 1 == 0):
        ans += 1
        j += 1
    else:
        break
print(ans)

n = int(input())
a = list(map(int, input().split()))
l = []
for i in a:
    cnt = 0
    while i%2 == 0:
        cnt +=1
        i //=2
    l.append(cnt)
print(min(l))

n = int(input())
a = list(map(int, input().split()))

ans = 1000
for i in range(n):
    x = a[i]
    shift = 0
    while(x%2==0):
        x = int(x/2)
        shift+=1
    ans = min(ans, shift)
    if ans == 0:
        break
print(ans)

#81B
N=int(input())
data=map(int,input().split())
def wareru(n):
    p=0
    while n%2==0:
        n=n//2
        p=p+1
    return p
print(min(map(wareru,data)))

n = int(input())
a = list(map(int, input().split()))
count = 0

while True:
	odd = False
	for x in range(n):
		if a[x] % 2 != 0:
			odd = True
			break
		else:
			a[x] //= 2
	if odd: break
	count += 1

print(count)

num = int(input())
nu_list = [int(v) for v in input().split()]
count = 0
#print(nu_list)
bool = True
while bool == True:
  for i in range(len(nu_list)):
    if nu_list[i] % 2 != 0:
      bool = False
      break
    else:
      nu_list[i] = nu_list[i] // 2
  if bool == True:
    count += 1 
print(count)

N=input()
a=list(map(int,input().split()))
res=10**9

for i in a:
    count=0
    while i%2==0:
        count+=1
        i=i/2
    if count<res:
        res=count
print(res)

N = int(input())
A = [int(i) for i in input().split()]
B = A.copy()
OK = True
count = 0
while OK:
    for c in range(N):
        if A[c] % 2 == 0:
            A[c] = A[c] // 2
            if A[-1] == (B[-1] / (2 ** (count+1))):
                count += 1
        else:
            OK = False
            break
print(count)

n = int(input())
A = list(map(int, input().split()))

K = 0
while all(a%2 == 0 for a in A):
  A = [a/2 for a in A]
  K += 1
  
print(K)


n=int(input())
a=list(map(int,input().split()))
count=-1
for j in range(10**5):
  count+=1
  for i in range(n):
    if a[i]%2!=0:
      print(count)
      return
    a[i]//=2
  
print(count)

n = int(input())
a = list(map(int, input().split()))

cnt = 0

while True:
  exist_odd = False
  for index in range(len(a)):
    if a[index] % 2 != 0:
      exist_odd = True
    a[index] /= 2
    
  if exist_odd: break
    
  cnt = cnt + 1

print(cnt)

import re
input()
An=input().split()
print(min(len((re.findall("0+$",bin(int(a)))+[""])[0]) for a in An))

N = int(input())

l = list(map(int, input().split()))

counter = 0
flag = 1

while flag == 1:
	for i in range(len(l)):
		if l[i] % 2 != 0:
			flag = 0
			break
		else:
			l[i] = int(l[i] / 2)
	if flag == 1:
		counter += 1

print(counter)

n = int(input())
a = list(map(int, input().split()))
# count = 0
# list a[i]が偶数かどうかをチェック。ループはとりあえず省略する

exist_odd = False
# in_if = 0
in_for = 0
# in_while = 0
while exist_odd == False:
    for i in range(n):
        if a[i] % 2 != 0:
            exist_odd = True
            if n != i:
                in_for -= 1
            break
        else:
            a[i] = a[i] / 2
        # in_if += 1
        # print(in_if)
    in_for += 1
print(in_for)

N = int(input())
A = list(map(int, input().split()))
cnt = 0

flag = True
while flag:
    for i in range(N):
        if A[i]%2 == 0:
            A[i]//=2
        else:
            flag = False
            break
    else:
        cnt += 1
        continue
print(cnt)


n = int(input())
a_list = list(map(int, input().split()))
new_list = []
ans = 0
while True:
    for i in a_list:
        if i % 2 == 1:
            break
        else:
            a = i // 2
            new_list.append(a)
    if len(new_list) < n:
        break
    ans += 1
    a_list = new_list
    new_list = []

print(ans)

import numpy as np

N = int(input())
A = list(map(int,input().split()))

ans = 0

def func1(n):
  return n/2

def func2(n):
  return n%2

i = 0
while i == 0:
  
  x = list(map(func2,A))
  
  if sum(x) == 0:
    ans += 1
    A = list(map(func1,A))
  else:
    break

print(ans)




n = int(input())
a = list(map(int,input().split()))

def devide(a,c,n):
    even = True
    for i in range(n):
        if a[i] % 2 != 0:
           even = False
        else:
            a[i] = int(a[i] / 2)
    return devide(a,c+1,n) if even else c
print(devide(a,0,n))

def main():
    n = int(input())
    a = list(map(int, input().split(" ")))
    ans = 0
    while True:
        for i in range(n):
            if a[i] % 2 != 0:
                return ans
            a[i] = a[i] // 2
        ans += 1


print(main())

num = int(input())
 
vals = list(map(int,input().split()))
 
cnt = 0
flag = True
while(flag):
	for i in range(num):
		if vals[i] % 2 == 1:
			print(cnt)
			flag = False
			break
		else:
			vals[i] = vals[i] / 2
	cnt += 1

n = int(input())
a = list(map(int,input().split()))

count = 0
while True:
    flg = False
    for i in range(n):
        if a[i] % 2 != 0:
            flg = True
    if flg:
        break
    
    for j in range(n):
        a[j] /= 2
    count += 1
print(count)

N = int(input())
A = list(map(int,input().split()))
ans = 0
while 1:
    flg = 0
    for i in range(N):
        if A[i] % 2 == 0:
            A[i] /= 2
        else:
            flg = 1
            break
    if flg == 1:
        break
    ans += 1
print(ans)

n = input()
a = list(map(int,input().split()))
ans = float("inf")
for i in a:
    ans = min(ans, len(bin(i)) - bin(i).rfind("1") - 1)
print(ans)

import numpy as np

N = int(input())
arr = np.array(list(map(int, input().split())))
cnt = 0
while True:
  if np.sum(arr%2) > 0:
    break
  else:
    arr = arr/2
    cnt += 1
print(cnt)
  


N = int(input())
A = list(map(int, input().split()))

ans = 0

while True:
  exist_odd = False
  for n in range(N):
    if A[n] % 2 == 1:
      exist_odd = True
      break
    else:
      A[n] //= 2
  if exist_odd: break
  ans += 1

print(ans)


n = int(input())
a = list(map(int, input().split()))
ans = 0
while True:
    for i in range(n):
        if a[i] % 2 == 1:
            print(ans)
            return
        else:
            a[i] /= 2
    ans += 1
print(ans)


N=int(input())
A=list(map(int,input().split()))
def rec(A):
    B=[0]*N
    for i in range(N):
        if A[i] % 2 != 0: return 0
        B[i] = A[i] / 2
    return rec(B)+1
print(rec(A))

n = int(input())
a = list(map(int, input().split()))
cnt = 0

while all(i%2==0 for i in a):
  a = [i//2 for i in a]
  cnt+=1

print(cnt)


n = int(input())
a = list(map(int, input().split()))
res = 0
while all(i % 2 == 0 for i in a):
    a = [i/2 for i in a]
    res += 1
print(res)

n = int(input())
a = list(map(int,input().split()))
x = 0
t = True
while t:
    for i in range(n):
        if a[i] % 2 == 1:
            t = False
        a[i] /= 2
    x += 1
print(x-1)

N = int(input())
A = list([0]*N)
A = list(map(int, input().split()))

cnt = 0
flag = False
while 1:
    for i in range(N):
        if A[i] % 2 != 0:
            flag = True
            break
        A[i] = A[i] /2
    if flag:
        break
    cnt += 1
print(cnt)

N = int(input())
A = list(map(int, input().split()))

i = 1
escape = False
while 1:
  for j in range(N):
    if A[j] % (2 ** i) == 0:
      pass
    else:
      escape = True
      break
  else:
    i += 1
  
  if escape:
    break
    
print((i - 1))


N = int(input())
A = list(map(int, input().split()))
count = 0
roop = True

while roop == True:
    for i in range(N):
        if A[i] % 2 == 0:
            A[i] /= 2
        else:
            roop = False
            break
            
    if roop == True:
        count += 1
print(count)





N=int(input())
A=list(map(int,input().split()))
ans_list = []

for n in A:
    temp = n
    count = 0
    while temp % 2 == 0:
        temp /= 2
        count = count + 1
    ans_list.append(count)
    
print(min(ans_list))

n = int(input())
a = list(map(int, input().split()))
count = 0
# list a[i]が偶数かどうかをチェック。ループはとりあえず省略する

exist_odd = False
while exist_odd == False:
    for i in range(n):
        if a[i] % 2 != 0:
            exist_odd = True
            if n != i:
                count -= 1
            break
        else:
            a[i] = a[i] / 2
    count += 1
    # print(count)
print(count)

N=int(input())
A=list(map(int,input().split()))
count=0
 
while all(a%2==0 for a in A):
  A=[a//2 for a in A]
  count+=1
 
print(count)

def f(n, a):
    count = 0
    while True:
        for i in range(n):
            if a[i] % 2 == 0:
                a[i] = a[i] / 2
            else :
                return count
        count += 1

n = int(input())
a = [int(s) for s in input().split()]
print(f(n,a))

import numpy as np
n = int(input())
A = np.array(input().split(), np.int64)

cnt = 0
while np.all(A % 2 == 0):
    A = A // 2
    cnt += 1
print(cnt)


N = int(input())
a = list(int(x) for x in input().split())

ans = 0
flag = True
while flag:
  for i in range(N):
    if a[i]%2 == 0:
      a[i]/=2
    else:
      flag = False
      break
  if flag:
    ans+=1

print(ans)

N = int(input())
nums = [int(s) for s in input().split()]
i = 0
cnt = 0
while True:
    if i == N:
        i = 0
        cnt += 1
    if nums[i % N] % 2 == 1:
        break
    nums[i % N] //= 2
    i += 1
print(cnt)

import numpy as np
N=int(input())
A=list(map(int,input().split()))
A=np.array(A)

count=0
flag=True
while flag:
  for i in range(N):
    if A[i]%2==1:
      flag=False
  A=A/2
  if flag:
    count+=1
print(count)

N=int(input())
A=list(map(int,input().split()))

cnt=0
flag=True
while flag:
    for i in range(N):
        if A[i]%2==0:
            A[i]//=2
        else:
            flag=False
            break
    else:
        cnt+=1
        continue
    break
print(cnt)


def resolve():
    _ = int(input())
    a = list(map(int, input().split()))
    res = 0
    while all(i % 2 == 0 for i in a):
        res += 1
        a = list(map(lambda x: x / 2, a))
    print(res)

resolve()

n = int(input())
a = list(map(int, input().split()))
t = True
ans = 0
while t:
    for i in range(n):
        if a[i] % 2 == 1:
            t = False
            break
        else:
            a[i] /= 2
    if t:
        ans += 1
print(ans)



#!/usr/bin/env python3
import math
import sys
sys.setrecursionlimit(10**6)


n = int(input())
a = list(map(int, input().split()))

ans = 10**10

for i in a:
    tmp = 0
    while(i % 2 != 1):
        tmp += 1
        i = i//2
    # print(tmp)
    ans = min(ans, tmp)

print(ans)


n = int(input())
list_a = [int(i) for i in input().split()]
ans = 0
flag = True
while flag:
    for i in range(0, len(list_a)):
        if list_a[i] % 2 == 0:
            list_a[i] = list_a[i] // 2
        else:
            flag = False
            break

        if i == len(list_a) - 1:
            ans += 1

print(ans)

n = int(input())
ls = list(map(int,input().split()))
ans = float("inf")
for i in range(n):
    p = 1
    while True:
        if ls[i] / (2 ** p) % 1 == 0:
            p += 1
        else:
            p -= 1
            break
    if p < ans:
        ans = p
print(ans)

N = int(input())
A = list(map(int,input().split()))
ans = 10**9
for x in A:
    if x % 2 == 1:
        print(0)
        return
    c = 0
    while x % 2 == 0:
        x //= 2
        c += 1
    ans = min(ans, c)
print(ans)

def main():

    n = int(input())
    nums = list(map(int, input().split()))
    ans = 0
    flg = True
    while flg:
        for i in range(len(nums)):
            if nums[i] % 2 == 0:
                num = nums[i] / 2
                nums[i] = num
            else:
                flg = False
                break
        if flg:
            ans += 1

    print(ans)

def __starting_point():
    main()
__starting_point()

N = int(input())
A_lst = list(map(int, input().split()))
cnt = 0
A_lst_c = []
for i in range(N):
    while A_lst[i] % 2 == 0:
        A_lst[i] //= 2
        cnt += 1
    if i == 0:
        pass
    else:
        cnt = cnt - A_lst_c[i-1]
    A_lst_c.append(cnt)
A_lst_c_min = min(A_lst_c)
print(A_lst_c_min)

N = int(input())
A = list(map(int, input().split()))

def cnt(x):
  ret = 0
  while x%2 == 0:
    ret += 1
    x //= 2
  return ret

ans = 30
for a in A:
  ans = min(ans, cnt(a))

print(ans)

n = int(input())
A = [0]*n
L = list(map(int,input().split()))
for i in range(n):
  cnt = 0
  while L[i] % 2 == 0:
    L[i] = L[i]/2
    cnt += 1
  A[i] = cnt
print(min(A))

n = int(input())
a = list(map(int, input().split()))
ans = 0
for ans in range(31):
    for i,A in enumerate(a):
        if A%2:
            print(ans)
            return
        a[i] //= 2


import sys
n = input()
li = list(map(int,input().split()))

# 黒板にかかれている文字は全部偶数か？
for i in li:
  if i % 2 != 0:
    print("0")
    return

# 黒板にかかれている文字を全部2で割っていく
count = 0

while(True):
  for index, item in enumerate(li):
    if item % 2 == 0:
      li[index] = item / 2
    else:
      print(count)
      return
  count += 1

hoge = input()
int_line = [int(i) for i in input().split()]

cnt = 0
flag = False

while True:
    for m, i in enumerate(int_line):
        if i % 2 == 0:
            int_line[m] = i/2
        else:
            flag = True
    if flag == True:
        print(cnt)
        break
    else:
        cnt += 1

N = int(input())
A = list(map(int, input().split()))

count = 0
exist_odd = False

while True:
  for i in range(N):
    if A[i] % 2 != 0:
      exist_odd = True

  if exist_odd:
    break

  for i in range(N):
    A[i] /=2

  count +=1

print(count)

n = int(input())
a = list(map(int,input().split()))
ans = 0
flag = False

while flag == False:
    for i in range(n):
        if a[i]%2 == 0:
            a[i] /= 2
        else:
            flag = True
            break
    else:
        ans += 1

print(ans)

n = int(input())
data = list(map(int,input().split()))
bool = True
count = 0
while bool:
    for i in range (n):
        if data[i] % 2 != 0:
            bool = False
        data[i] = data[i] // 2
    if bool == False:
        print(count)
    count += 1


N = int(input())
A = list(map(int,input().split()))
count = 0
roop = True

while roop == True:
    for i in range(N):
        if A[i] % 2 == 0:
            A[i] /= 2
        else:
            roop = False
            break
    if roop == True:
        count += 1
print(count)

n = int(input())
aa = list(map(int, input().split()))
ans = 100
for i in range(n):
    x = 0
    while aa[i] > 0:
        if aa[i] % 2 != 0:
            break
        aa[i] //= 2
        x += 1
    ans = min(ans, x)
print(ans)


n = int(input())
li = list(map(int, input().split()))
b = float('inf')
for a in li:
    c = 0
    while a%2 == 0:
      a = a/2
      c += 1
    b = min(b,c)
print(b)
          


#-*-coding:utf-8-*-
import sys
input=sys.stdin.readline
import numpy as np

def main():
    n = input()
    A = np.array(input().split(),dtype=np.int32)
    answer=0

    while np.all(A%2==0):
        A//=2
        answer+=1
    print(answer)

def __starting_point():
    main()
__starting_point()

getints = lambda: map(int, input().split())
n = int(input())
a = list(getints())
ans = 10 ** 9
for x in a:
    cnt = 0
    while x % 2 == 0:
        x /= 2
        cnt += 1
    ans = min(ans, cnt)
print(ans)

n = int(input())
ary = list(map(int, input().split()))

def count_ops(ary):
    count = 0

    while 1:
        for i, v in enumerate(ary):
            if v % 2 == 1:
                return count
            else:
                ary[i] = v/2

        count += 1
    
    return count
 
print((count_ops(ary)))


from typing import List


def answer(n: int, a: List[int]) -> int:
    count = 1
    while all(i % 2 ** count == 0 for i in a):
        count += 1
    return count - 1


def main():
    n = int(input())
    a = list(map(int, input().split()))
    print((answer(n, a)))


def __starting_point():
    main()

__starting_point()

n = int(input())
a = list(map(int,input().split()))
x = 0
t = True
while t:
    for i in range(n):
        if a[i] % 2 == 1:
            t = False
        else:
            a[i] /= 2
    x += 1
print(x-1)

N = int(input())
A = list(map(int, input().split()))

count = 0
while True:
    for i in range(N):
        if A[i] % 2 != 0:
            break
        A[i] = A[i] / 2
    else:
        count+=1
        continue
    break
print(count)

import sys


def solve(N, A):
    count = 0
    while True:
        for i in range(N):
            if A[i] % 2 > 0:
                print(count)
                return
            A[i] = A[i] / 2
        count += 1
    

def __starting_point():
    N = int(input())
    A = list(map(int, input().split()))
    solve(N, A)

__starting_point()

n = int(input())
a = [int(x.strip()) for x in input().split()]
ch,ans = 0,0
flg = 'OK'
while flg == 'OK':
  for x in a:
    if x % 2 == 0:
      ch += 1
    else:
      break
  if ch == n:
    flg = 'OK'
    ch = 0
    ans += 1
    a = list(map(lambda x:int(x/2),a)) # list関数にネストしないとmapオブジェクトでNGになる
  else:
    flg = 'NG'
print(ans)

# coding: utf-8
# Your code here!

divided_2 = lambda x : int(x / 2)
enable_divided_2 = lambda x : True if int(x % 2) == 0 else False

n = int(input())
A = list(map(int, input().split()))
cnt = 0

while(1) : 
    if False in list(map(enable_divided_2, A)) : 
        break
    A = list(map(divided_2, A))
    cnt += 1
    
print(cnt)

n = int(input())
a = list(map(int,input().split()))
x = 0
t = True
while t:
    for i in range(n):
        if a[i] % 2 == 1:
            t = False
        else:
            a[i] /= 2
    if t == True:
        x += 1
print(x)

n = int(input())
a = list(map(int,input().split()))
cnt = 0
while all([i%2==0 for i in a]):
    a = [i/2 for i in a]
    cnt += 1
print(cnt)

N = int(input())
A = list(map(int, input().split()))
count = 0
while all(a % 2 == 0 for a in A):
  A = [a /2 for a in A]
  count += 1
print(count)
  


N = int(input())
A = list(map(int, input().split()))
ans = 0
is_end = False
while True:
    for a in A:
        if a%2 != 0:
            is_end = True
            break
    if is_end:
        break
    ans += 1
    A = [a/2 for a in A]

print(ans)

n = int(input())
arr = list(map(int, input().split()))

cnt_arr = []

for ele in arr:
    cnt = 0
    while ele % 2 == 0:
        ele /= 2
        cnt += 1
    cnt_arr.append(cnt)
print((min(cnt_arr)))


import numpy as np
n = int(input())
p = list(map(int, input().split()))
p = np.array(p)
cnt = 0
while cnt < 10000000:
    for i in p:
        if i % 2 != 0:
            print(cnt)
            return
    cnt += 1
    p = p // 2

N = int(input())
a = list(map(int,input().split()))
dev = lambda x : x/2
amari = lambda x : x % 2
for i in range(1000):
    amari_a = list(map(amari, a))
    if amari_a.count(1) > 0: break
    a = list(map(dev,a))
print(i)

n = int(input())
a = list(map(int,input().split()))
y = list()
for i in range(n):
    x = 0
    while a[i] % 2 == 0:
        a[i] /= 2
        x += 1
    y.append(x)
print(min(y))

import sys

n = int(input())
a = list(map(int, input().split()))

cnt = [0] * n

while 1:
    for i in range(n):
        if a[i] % 2 == 0:
            a[i] /= 2
            cnt[i] += 1
        else:
            print(min(cnt))
            return

n = int(input())
l = list(input().split(' '))

flag = True
t = 0
while True:
    for i, x in enumerate(l):
        if int(x) % 2 == 0:
            l[i] = int(x) / 2
        else:
            flag = False
            break
    if flag:
        t += 1
    else:
        break

print(t)



n=int(input())
a=list(map(int,input().split()))
b=[]
cnt=0
for i in range(n):
    if a[i]%2==1:
        print('0')
        return
    else:
        while a[i]%2==0:
            cnt += 1
            a[i] /=  2
        b.append(cnt)
        cnt = 0
print(min(b))

# -*- coding:utf-8 -*-
N = int(input())
A_list = list(map(int,input().split()))

ans_list = []
temp_ans = 0

for value in A_list:
    temp_value = value
    temp_ans = 0
    while temp_value%2 == 0:
        temp_value /= 2
        temp_ans += 1

    ans_list.append(temp_ans)

print(min(ans_list))


def div_by_2(n):
    res = 0
    while n % 2 == 0:
        n //= 2
        res += 1
    return res

N = int(input())
A = list(map(int, input().split()))
print(min(map(div_by_2, A)))

#!/usr/bin/env python3
# atcoder 
# Türkler var mı?
# Herkese memnün oldum
import sys
#from heapq import heapify, heappush, heappop
#from heapq import nlargest, nsmallest

iimr = lambda: map(int, sys.stdin.readline().rstrip().split())
readline = sys.stdin.readline
# puorquoi le sys.stdin.buffer.readline() ne fonctionne plus sur atcoder?
#sys.setrecursionlimit(10 ** 7)
#INF = 1 << 30 # 大体 1e9


def debug(*x):
    print(*x, file=sys.stderr)


# s == self
class atcoder():
    def __init__(s):
        f = open(0)
        s.N = int(f.readline())
        s.A = list(map(int, f.readline().split()))

    def çözmek(s):
        res = []
        res.append(s.関数(s.N, s.A))
        print(*res)	
    
    def 関数(self, n, a):
        guusuu = True
        cnt = 0
        while(guusuu):
            for i in range(n):
                if(a[i] % 2 != 0):
                    guusuu = False
                    break;
                else:
                    a[i] /= 2
            if(guusuu): cnt += 1
        return cnt 

def __starting_point():
    ima = atcoder()
    ima.çözmek()

__starting_point()

n = int(input())
line = list(map(int, input().split()))
ans = 30
for i in range(n):
  count = 0
  x = line[i]
  while True:
    if x % 2 == 0:
      x = x//2
      count += 1
    else:
      break
  if count < ans:
    ans = count
print(ans)
      


n = int(input())
li = list(map(int,input().split()))
li.sort()
cnt = 0
guu = 0
for j in range(100000):
    guu = 0
    for i in range(len(li)):
        if li[i] % 2 == 0:
            guu += 1
    if guu == n:
        for i in range(len(li)):
            li[i] = li[i]//2
        cnt += 1
    else:
        print(cnt)
        return


n = int(input())
l = list(map(int, input().split()))
result = 0
loop = 0
while True:
    if all(x % 2 == 0 for x in l):
        result += 1
        for data in range(len(l)):
            l[data] = l[data]//2
    else:
        print(result)
        return


n=int(input())
a=list(map(int, input().split()))
ma=len(bin(10**9))
for i in range(n):
    cnt=0
    while a[i]%2==0:
        a[i]/=2
        cnt+=1
    ma=min(ma,cnt)
print(ma)


n = int(input())
a = list(map(int, input().split()))

for i in range(100):
    for j in range(len(a)):
        if a[j]%2 == 0:
            a[j] //= 2
        else:
            print(i)
            return


n = int(input())
a_lst = list(map(int, input().split()))

res = []
for a in a_lst:
  tmp = a
  cnt = 0
  while tmp % 2 == 0:
    tmp = tmp // 2
    cnt += 1
  res.append(cnt)
print(min(res))

N=int(input())
li = list(map(int,input().split()))

flag=True
ans=-1

while(flag):
    ans+=1
    newlist=[]
    for i in li:
        newlist.append(i//2)
        if i%2!=0:
            flag=False
    li=newlist
print(ans)


N = int(input())
A = list(map(int, input().split()))

ans = float('inf')
for i in range(N):
    temp = 0
    while A[i] % 2 == 0:
        A[i] /= 2
        temp += 1
    ans = min(ans, temp)

print(ans)


N = int(input())
A = list(map(int,input().split()))

count=0
for _ in range(30):
    for i in range(N):
        B=A[i]%2
        if B==1:
            break
        A[i]=A[i]//2
    else:
        count+=1
        continue
    break
print(count)

def is_divide(an):
  for i, a in enumerate(an):
    if a % 2 == 0:
      an[i] = a / 2
    else:
      return False
  
  return True

n = int(input())
an = list(map(int, input().split()))

count = 0
while True:
  if not is_divide(an):
    break
  count += 1

print(count)


n = int(input())
a = list(map(int, input().split()))
INF = 10 ** 9

def how_many_times_divisible(x):
    ans = 0
    while x % 2 == 0:
        x /= 2
        ans += 1
    return ans

ans = INF
for i in range(n):
    if how_many_times_divisible(a[i]) < ans:
        ans = how_many_times_divisible(a[i])
print(ans)


def divide(l):
	for i in range(len(l)):
		if l[i] % 2 == 0:
			l[i] = int(l[i] / 2)
		else:
			return False
			
	return True


n = int(input())
l = list(map(int, input().split()))

count = 0
while divide(l):
	count += 1
		
print(count)

n = int(input())
a = [int(i) for i in input().split()]
ans = -1
true = 1

while true == 1:
    for i in range(n):
        if a[i]%2 != 0:
            true = 0
            break
        else:
            a[i] /= 2
    ans += 1

print(ans)

n=int(input())
n_list=list(map(int,input().split()))
count=0

def check(list):
    for i in range(n):
        if(n_list[i]%2!=0):
            return False
    return True

    

while(check(n_list)):
    n_list=[k/2 for k in n_list]
    count+=1
print(count)  

N = int(input())
a = list(map(int, input().split()))
ans = 0
exist = True

while exist:
  for i in range(N):
    if (a[i]%2 != 0):
      exist = False
    else:
      a[i] = a[i]//2
  if exist:
    ans += 1

print(ans)

n = int(input())
a = [int(s) for s in input().split()]

ans = 0
parity = True
while parity:
    for i in range(n):
        if a[i] % 2 == 0:
            a[i] = a[i] / 2
        else:
            parity = False
    if parity:
        ans += 1 
print(ans)