CodeEff/ECCO huggingface dataset:
# Original solution
n = int(eval(input()))
a = [int(c) for c in input().split()]

count = 0
for n in a:
    x = n
    while x % 2 == 0:
        x /= 2
        count += 1

print(count)

# Optimized solution
def main():
    N = int(eval(input()))

    ans = 0
    for a in [x for x in map(int, input().split()) if x % 2 == 0]:
        i = a
        while i % 2 == 0:
            i //= 2
            ans += 1

    print(ans)
main()
# Original solution
N = int(eval(input()))
a = tuple(map(int, input().split()))

ans = 0
for aa in a:
    while aa % 2 == 0:
        aa //= 2
        ans += 1
print(ans)


# Optimized solution
def main():
    def count(x):
        ret = 0
        while x % 2 == 0:
            x //= 2
            ret += 1
        return ret

    N = int(eval(input()))
    a = list(map(int, input().split()))
    ans = sum(map(count, a))
    print(ans)


if __name__ == '__main__':
    main()

# import sys
# input = sys.stdin.readline
# 
# sys.setrecursionlimit(10 ** 7)
# 
# (int(x)-1 for x in input().split())
# rstrip()
# Original solution
# -*- coding: utf-8 -*-

n = int(eval(input()))
a = list(map(int,input().split()))
af = [[]]

def factorize(n):
    b = 2
    fct = []
    while b * b <= n:
        while n % b == 0:
            n //= b
            fct.append(b)
        b = b + 1
    if n > 1:
        fct.append(n)
    return fct

for i in range(n):
    af.append(factorize(a[i]))
del af[0]

cnt = 0

for i in range(len(af)):
    for j in range(len(af[i])):
        if af[i][j] == 2:
            cnt += 1

print(cnt)

# Optimized solution
n = int(eval(input()))
a = list(map(int,input().split()))

cnt = 0

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

print(cnt)
# Original solution
n=int(eval(input()))
a=list(map(int,input().split()))

even=[x for x in a if x%2==0]
ans=0
while even!=[]:
    delval=0
    even[0]//=2
    len_even=len(even)
    for i in range(len_even):
        if i==0:
            if even[i]%2!=0:
                del even[i]
                delval+=1
        else:
            if (even[i-delval]*3)%2!=0:
                del even[i-delval]
                delval+=1
            else:
                even[i-delval]*=3
    ans+=1
print(ans)

# Optimized solution
n=int(eval(input()))
a=list(map(int,input().split()))
ans=0
for i in a:
    buf=i
    ans+=format(buf,'b')[::-1].find('1')
print(ans)
# Original solution
n = int(eval(input()))
a = list(map(int, input().split()))

cnt = 0
flg = True
while flg:
  flg = False
  for i in range(0, n):
    if not a[i]%2:
      a[i] = a[i] / 2
      flg = True
      cnt += 1
      break

print(cnt)

# Optimized solution
n = int(eval(input()))
a = list(map(int, input().split()))

cnt = 0
flg = True
while flg:
  flg = False
  minus = 0
  for i in range(0, len(a)):
    if not a[i+minus]%2:
      a[i+minus] = a[i+minus] / 2
      flg = True
      cnt += 1
      break
    else:
      a.pop(i+minus)
      minus -= 1

print(cnt)
# Original solution
n=int(eval(input()))
a=list(map(int,input().split()))
ans=0
for i in a:
    while i%2==0:
        i/=2
        ans+=1
print(ans)

# Optimized solution
n=int(eval(input()))
a=list(map(int,input().split()))
ans=0
for i in a:
    cnt=0
    while i%2==0:
        i//=2
        cnt+=1
    ans+=cnt
print(ans)
# Original solution
def I(): return int(eval(input()))
def LI(): return list(map(int,input().split()))
##################################################
N = I()
a = [x for x in LI() if x%2==0]
ans = 0
while 1:
    if len(a)==0:
        print(ans)
        break
    ans += len(a)
    for i,x in enumerate(a):
        a[i] /= 2
    a = [x for x in a if x%2==0]

# Optimized solution
def I(): return int(eval(input()))
def LI(): return list(map(int,input().split()))
##################################################
N = I()
a = [x for x in LI() if x%2==0]
ans = 0
while 1:
    if len(a)==0:
        print(ans)
        break
    ans += len(a)
    a = [x/2 for x in a if x/2%2==0]
# Original solution
n = int(eval(input()))
a = list(map(int, input().split()))

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

# Optimized solution
n=int(eval(input()))
a=list(map(int,input().split()))
ans=0
for i in a:
  while i%2==0:
    i=i//2
    ans+=1
  
print(ans)
# Original solution
n = int(eval(input()))
a = list(map(int,input().split()))
g = 0
for i in a:
    while i%2==0:
        g+=1
        i/=2
print(g)

# Optimized solution
n = int(eval(input()))
a = list(map(int,input().split()))
ans = 0
for i in range(n):
    while a[i]%2==0:
        a[i] = a[i]//2
        ans+=1
print(ans)
# Original solution
import sys

stdin = sys.stdin

ni = lambda: int(ns())
na = lambda: list(map(int, stdin.readline().split()))
ns = lambda: stdin.readline()

n = ni()
a = na()
ans = 0
while True:
    dtwo = 0
    for i in range(n):
        if a[i] % 2 == 0 and dtwo == 0:
            a[i]//=2
            dtwo = 1
        else:
            a[i]*=3
    if dtwo == 0:
        break
    ans += 1
print(ans)


# Optimized solution
import sys

stdin = sys.stdin

ni = lambda: int(ns())
na = lambda: list(map(int, stdin.readline().split()))
ns = lambda: stdin.readline()

n = ni()
a = na()
# ans = 0
# while True:
#     dtwo = 0
#     for i in range(n):
#         if a[i] % 2 == 0 and dtwo == 0:
#             a[i]//=2
#             dtwo = 1
#         else:
#             a[i]*=3
#     if dtwo == 0:
#         break
#     ans += 1
# print(ans)
ans = 0
for i in range(n):
    tmp = a[i]
    while True:
        if tmp%2 == 0:
            ans += 1
        else:
            break
        tmp = tmp / 2
print(ans)
# Original solution
from functools import reduce

def count_two(n):
	two_count = 0
	while n != 0 and n % 2 == 0:
		two_count += 1
		n //= 2
	return two_count

n = int(eval(input()))
a = list(map(int, input().split()))
a_product = reduce(lambda x, y: x*y, a)
print((count_two(a_product)))

# Optimized solution
from functools import reduce

def count_two(n):
	two_count = 0
	while n != 0 and n % 2 == 0:
		two_count += 1
		n //= 2
	return two_count

n = int(eval(input()))
a = list(map(int, input().split()))
a_two_count_sum = sum([count_two(ai) for ai in a])
print(a_two_count_sum)
# Original solution
from functools import reduce

def count_two(n):
	two_count = 0
	while n != 0 and n % 2 == 0:
		two_count += 1
		n //= 2
	return two_count

n = int(eval(input()))
a = list(map(int, input().split()))
a_two_count_sum = sum([count_two(ai) for ai in a])
print(a_two_count_sum)

# Optimized solution
def count_two(n):
	two = 0
	while n%2 == 0:
		n //= 2
		two += 1
	return two

n = int(eval(input()))
a = [int(m) for m in input().split(" ")]

print((sum([count_two(a_n) for a_n in a])))
# Original solution
import sys

def solve():
    input = sys.stdin.readline
    N = int(eval(input()))
    A = [int(a) for a in input().split()]
    count = 0
    for i in range(N):
        while A[i] % 2 == 0:
            count += 1
            A[i] //= 2
    print(count)

    return 0

if __name__ == "__main__":
    solve()

# Optimized solution
import sys

def solve():
    input = sys.stdin.readline
    N = int(eval(input()))
    A = [int(a) for a in input().split()]
    count = 0
    for i in range(N):
        while A[i] % 2 == 0:
            A[i] //= 2
            count += 1
    print(count)

    return 0

if __name__ == "__main__":
    solve()
# Original solution
N = int(eval(input()))
A = list(map(int, input().split()))

def factorization(n):
    arr = {}
    temp = n
    for i in range(2, int(-(-n ** 0.5 // 1)) + 1):
        if temp % i == 0:
            cnt = 0
            while temp % i == 0:
                cnt += 1
                temp //= i
            arr[i] = cnt

    if temp != 1:
        arr[temp] = 1

    if arr == []:
        arr[n] = 1

    return arr

ans = 0
for a in A:
    arr = factorization(a)
    if 2 in arr:
        ans += arr[2]
print(ans)


# Optimized solution
N = int(eval(input()))
A = list(map(int, input().split()))

def factorization(n):
    arr = {}
    temp = n
    i = 2
    if temp % i == 0:
        cnt = 0
        while temp % i == 0:
            cnt += 1
            temp //= i
        arr[i] = cnt

    return arr

ans = 0
for a in A:
    arr = factorization(a)
    if 2 in arr:
        ans += arr[2]
print(ans)
# Original solution
n=int(eval(input()))
a=sorted([int(i) for i in input().split()])
cnt=0
while True:
    odd=[i for i in a if i%2==1]
    even=[i for i in a if i%2==0]
    if len(even)==0:
        break
    maxi=even[-1]
    even=[i*3 for i in even[0:-1]]
    even.append(maxi//2)
    a=odd+even
    cnt+=1
print(cnt)

# Optimized solution
n=int(eval(input()))
a=[int(i) for i in input().split()]
cnt=0
for i in range(n):
    while a[i]%2==0:
        a[i]=a[i]//2
        cnt+=1
print(cnt)
# Original solution
N = int(eval(input()))
A = list(map(int,input().split()))
ans = 0
for a in A:
    while a > 0 and a%2 == 0:
        a //= 2
        ans += 1
print(ans)


# Optimized solution
N = int(eval(input()))
a = list(map(int,input().split()))
ans = 0

for e in a:
    while e%2 == 0:
        ans += 1
        e //= 2
print(ans)
# Original solution
N=int(eval(input()))
A=list(map(int,input().split()))


ans=0
for i in range(N):
    while A[i]%2==0:
        ans+=1
        A[i]//=2
print(ans)

# Optimized solution
N=int(eval(input()))
A=list(map(int,input().split()))
ans=0
for i in range(N):
    while A[i]%2==0:
        A[i]//=2
        ans+=1
print(ans)
# Original solution
import sys
input = sys.stdin.readline

def factorization(n):
    arr = []
    temp = n
    for i in range(2, int(-(-n**0.5//1))+1):
        if temp%i==0:
            cnt=0
            while temp%i==0:
                cnt+=1
                temp //= i
            arr.append([i, cnt])

    if temp!=1:
        arr.append([temp, 1])

    if arr==[]:
        arr.append([n, 1])

    return arr

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

for i in a:
    li = factorization(i)
    for j in li:
        if j[0] == 2:
            ans += j[1]

print(ans)


# Optimized solution
import sys
input = sys.stdin.readline

def main():
    n = int(eval(input()))
    a = list(map(int,input().split()))
    ans = 0

    for i in a:
        count = 0
        while i // 2 * 2 == i:
            i = i // 2
            count += 1
        ans += count

    print(ans)

if __name__ == '__main__':
    main()
# Original solution
def num_divisions(num):
    for i in range(1+num):
        if num % 2**i == 0:
            pass
        else:
            return i - 1
        
        
N = int(eval(input()))
A = list(map(int, input().split()))

cnt = 0
for a in A:
    cnt += num_divisions(a)
print(cnt)

# Optimized solution
def decompose_by_2(n):
    cnt = 0
    while True:
        if n % 2 == 1:
            return cnt
        n = n / 2
        cnt += 1
        
_ = eval(input())
A = list(map(int, input().split()))
cnt = 0
for a in A:
    cnt += decompose_by_2(a)
    
print(cnt)
# Original solution
n=int(eval(input()))
a=list(map(int,input().split()))

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

# Optimized solution
n=int(eval(input()))
a=list(map(int,input().split()))

def cnt_div2(n):
    cnt=0
    while n%2==0:
        n//=2
        cnt+=1
    return cnt

#各要素に対して，2で割ることのできる回数をカウント
lis = [cnt_div2(i) for i in a]
print((sum(lis)))
# Original solution
N = int(eval(input()))
A = list(map(int, input().split()))
import math
ans = 0
for i in range(N):
  a = A[i]
  b = int(math.log2(a))+1
  for j in range(b):
    if a % 2 == 0:
      ans += 1
      a = a/2
    else:
      break
      
print(ans)
    
    

# Optimized solution
N = int(eval(input()))
ans = 0
A = list(map(int, input().split()))
for i in range(N):
  a = A[i]
  while a%2 == 0:
    ans += 1
    a = a//2
print(ans)
# Original solution
def main():
    
    N = int(eval(input()))
    A = list(map(int, input().split()))
    ans = 0
    
    for a in A:
        while a%2 == 0:
            ans += 1
            a /= 2
            
    print(ans)
    
if __name__ == "__main__":
    main()

# Optimized solution
N = int(eval(input()))
A = list(map(int, input().split()))

ans = 0
for a in A:
    tmp = a
    while tmp%2==0:
        ans += 1
        tmp //=2
        
print(ans)
# Original solution
N = int(eval(input()))
A = list(map(int, input().split()))

ans = 0
for a in A:
    tmp = a
    while tmp%2==0:
        ans += 1
        tmp //=2
        
print(ans)

# Optimized solution
N = int(eval(input()))
A = list(map(int, input().split()))

ans = 0
for a in A:
    ans += bin(a)[::-1].index("1")
        
print(ans)
# Original solution
N = int(eval(input()))
a = list(map(int,input().split()))

cnt = 0
while True:
    flg = False
    for i in range(N):
        if a[i] % 2 == 0:
            a[i] /= 2
            break
        elif i == N - 1:
            print(cnt)
            flg = True
    if flg == True:
        break

    cnt += 1


# Optimized solution
N = int(eval(input()))
a = list(map(int,input().split()))

cnt = 0
for i in range(N):
    while True:
        if a[i] % 2 != 0:
            break
        else:
            cnt+=1
            a[i] = a[i] / 2
print(cnt)
# Original solution
# AtCoder Beginner Contest 100
# C - *3 or /2

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

count=0

A=[ a for a in A if a%2==0 ]

while len(A)>0:
    _A=[]
    for a in A:
        if a==max(A):
            _a=a//2
            if _a%2==0:
                _A.append(_a)
            else:
                pass
        else:
            if a%2==0:
                _a=a*3
                _A.append(_a)
            else :
                pass
    count+=1
    A=_A
    # print(A)
    # print(_A)

print(count)


# Optimized solution
# AtCoder Beginner Contest 100
# C - *3 or /2
def f(N,c):
    if N%2==0:
        n=N//2
        c+=1
        return f(n,c)
    else:
        return c



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

count=0

for a in A:
    count+= f(a,0)

print(count)
# Original solution
n = int(eval(input()))
a = list(map(int, input().split()))
count = 0
for i in a:
    while i % 2 == 0:
        i /= 2
        count += 1
print(count)

# Optimized solution
n = int(eval(input()))
a = [int(i) for i in input().split()]

a = sorted(list([x for x in a if (x % 2) == 0]), reverse=True)
ans = 0
for i in a:
    while i % 2 == 0:
        i //= 2
        ans += 1
print((int(ans)))
# Original solution
# For taking integer inputs.
import math


def inp():
    return(int(eval(input())))


# For taking List inputs.
def inlist():
    return(list(map(int, input().split())))


# For taking string inputs. Actually it returns a List of Characters, instead of a string, which is easier to use in Python, because in Python, Strings are Immutable.
def instr():
    s = eval(input())
    return(list(s[:len(s)]))


# For taking space seperated integer variable inputs.
def invr():
    return(list(map(int, input().split())))


N = inp()
a = inlist()
c = 0
while True:
    done1 = 0
    for i in range(N):
        if a[i] % 2 == 0 and done1 == 0:
            a[i] = a[i] // 2
            done1 = 1
            c += 1
        else:
            a[i] *= 3
    if done1 == 0:
        break

print(c)


# Optimized solution
# For taking integer inputs.
import math


def inp():
    return(int(eval(input())))


# For taking List inputs.
def inlist():
    return(list(map(int, input().split())))


# For taking string inputs. Actually it returns a List of Characters, instead of a string, which is easier to use in Python, because in Python, Strings are Immutable.
def instr():
    s = eval(input())
    return(list(s[:len(s)]))


# For taking space seperated integer variable inputs.
def invr():
    return(list(map(int, input().split())))


def getn(n):
    c = 0
    while n % 2 == 0:
        n = n // 2
        c += 1
    return c


N = inp()
a = inlist()
c = 0
for i in a:
    c += getn(i)

print(c)
# Original solution
n=int(eval(input()))
l=list(map(int, input().split()))

z=[]
for i in range(n):
    x,y=0,l[i]
    for j in range(10**9):
        if y%2==0:
            x+=1
            y=y//2
        else:
            z.append(x)
            break

print((sum(z)))

# Optimized solution
n=int(eval(input()))
l=list(map(int, input().split()))

z=[]
for i in range(n):
    x,y=0,l[i]
    while y%2==0:
        x+=1
        y=y//2
    else:
        z.append(x)

print((sum(z)))
# Original solution
# -*- coding:utf-8 -*-

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

    ans = 0
    # 2**x の xの総和が答え
    for a in A:
        while a%2 == 0:
            a = a / 2
            ans += 1
    
    print(ans)

if __name__ == "__main__":
    solve()

# Optimized solution
# -*- coding:utf-8 -*-

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

    ans = 0
    #  素因数分解したときの2**x の xの総和が答え
    for a in A:
        while a%2 == 0:
            a = a / 2
            ans += 1
    
    print(ans)

if __name__ == "__main__":
    solve()
# Original solution
#coding: utf-8
N = int(eval(input()))
L = list(map(int, input().split()))

cnt = 0
tri_cnt = 0
mem = 0

#全てが奇数になるまで実行し続ける
while(tri_cnt != len(L)):
    if(L[mem]%2 != 0):
        mem += 1
    else:
        L[mem] //= 2
        # for i in range(len(L)):
        #     if(i != mem):
        #         #L[i] = L[i] * 3
        #         print('',end='')
        cnt += 1

    tri_cnt = 0
    for i in range(len(L)):
        if (L[i] % 2 != 0):
            tri_cnt += 1
    # print(L)
    # print(tri_cnt)
else:
    print(cnt)

# Optimized solution
#coding: utf-8
N = int(eval(input()))
L = list(map(int, input().split()))

cnt = 0
tri_cnt = 0
mem = 0

#全てが奇数になるまで実行し続ける
while(mem != len(L)):
    if(L[mem]%2 != 0):
        mem += 1
    else:
        L[mem] //= 2
        # for i in range(len(L)):
        #     if(i != mem):
        #         L[i] = L[i] * 3
        #         print('',end='')
        cnt += 1

    # tri_cnt = 0
    # for i in range(len(L)):
    #     if (L[i] % 2 != 0):
    #         tri_cnt += 1
else:
    print(cnt)
# Original solution
n = int(eval(input()))
a = list(map(int,input().split()))
Sum = 0
for i in range(n):
    while a[i] % 2 == 0:
        a[i] /= 2
        Sum += 1
print(Sum)


# Optimized solution
n = int(eval(input()))
a = list(map(int,input().split()))
cnt = 0
for i in range(n):
    if a[i] % 2 == 0:
        while a[i] % 2 == 0:
            a[i] = a[i] // 2
            cnt += 1
print(cnt)
# Original solution
def prime_decomposition(n):
  i = 2
  table = []
  counter = 0
  while i * i <= n:
    while n % i == 0:
      n /= i
      if i == 2:
          counter += 1
      table.append(i)
    i += 1
  if n > 1:
    if n == 2:
        counter += 1
    table.append(n)
  return counter


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

ans = 0
for i in range(N):
    if A[i] % 2 == 0:
        ans += prime_decomposition(A[i])

print(ans)

# Optimized solution
def gu(x):
    counter = 0
    while x % 2 == 0 and x != 0:
        x /= 2
        counter += 1
    return counter


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

ans = 0
for i in range(N):
    if A[i] % 2 == 0:
        ans += gu(A[i])

print(ans)
# Original solution
import math
#試し割法
def trial_division(n):
    #素因数を格納するリスト
    factor = []
    #2から√n以下の数字で割っていく
    # c = 0
    tmp = math.sqrt(n) + 1
    tmp = int(tmp)
    for num in range(2,tmp):
        while n % num == 0:
            n //= num
            factor.append(num)
    #リストが空ならそれは素数
    if not factor:
        return 'prime number'
    else:
        factor.append(n)
        return factor


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

ans = 0
for i in range(N):
    if A[i] == 2:
        ans += 1
    buff = trial_division(A[i])
    for el in buff:
        if el == 2:
            ans += 1

print(ans)



# Optimized solution
import math

def wareru(s):

    buff = s
    c = 0
    while True:
        if buff % 2 == 0:
            c+=1
            buff = buff / 2
        else:
            return c

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

ans = 0
for i in range(N):
    ans += wareru(A[i])
    # if A[i] == 2:
    #     ans += 1

    # for el in buff:
    #     if el == 2:
    #         ans += 1

print(ans)
# Original solution
# 素因数分解
def prime_decomposition(n):
    i = 2
    table = []
    while i * i <= n:
        while n % i == 0:
            n //= i
            table.append(i)
        i += 1
    if n > 1:
        table.append(n)
    return table
  
N = int(eval(input()))
a = list(map(int,input().split()))

ans = 0

for i in range(N):
    ans += prime_decomposition(a[i]).count(2)
    
print(ans)

# Optimized solution
N = int(eval(input()))
a = list(map(int,input().split()))

ans = 0

for i in range(N):
    num = a[i]
    while num % 2 == 0:
        num = num // 2
        ans += 1
    
print(ans)
# Original solution
import math
n = int(eval(input()))
a = list(map(int, input().split()))


def trial_division(n):
    factor = []
    tmp = int(math.sqrt(n)) + 1
    for num in range(2,tmp):
        while n % num == 0:
            n //= num
            factor.append(num)
    if not factor:
        return [n]
    else:
        factor.append(n)
        return factor


count = 0
for i in a:
    temp = trial_division(i)
    count += temp.count(2)

print(count)

# Optimized solution
import math
n = int(eval(input()))
a = list(map(int, input().split()))


def trial_division(n):
    factor = []
    tmp = int(math.sqrt(n)) + 1
    for _ in range(2,tmp):
        while n % 2 == 0:
            n //= 2
            factor.append(2)
    if not factor:
        return [n]
    else:
        factor.append(n)
        return factor


count = 0
for i in a:
    temp = trial_division(i)
    count += temp.count(2)

print(count)
# Original solution
n = int(eval(input()))
a = list(map(int, input().split()))


def trial_division(n):
    #２で割った因数を格納するリスト
    factor = []
    #2で割れなくなった時点でストップ
    while n % 2 == 0:
        n //= 2    # ２で割った商を切り捨てて代入
        factor.append(2)
    #nが一度も２で割れなかったらそのまま返す
    if not factor:
        return [n]
    else:
        factor.append(n)
        return factor


count = 0
for i in a:
    temp = trial_division(i)
    count += temp.count(2)

print(count)

# Optimized solution
n = int(eval(input()))
a = list(map(int, input().split()))

cnt = 0
for i in a:
    while i % 2 == 0:
        i = i // 2
        cnt += 1

print(cnt)
# Original solution
n = int(eval(input()))
a = list(map(int, input().split()))
ans = 0
for i in range(n):
    for j in range(29, 0, -1):
        if a[i] % (2 ** j) == 0:
            ans += j
            break
print(ans)


# Optimized solution
n = int(eval(input()))
a = list(map(int, input().split()))


def count_2(x):
    if x % 2 != 0:
        return 0
    else:
        return count_2(x // 2) + 1


ans = 0
for i in range(n):
    ans += count_2(a[i])

print(ans)
# Original solution
import sys
sys.setrecursionlimit(10**9)
from functools import reduce
from operator import mul

def two(a,ans):
    if a%2==0:
        return two(a//2,ans+1)
    else:
        return ans

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

ans1=0
#ans2=0
p=reduce(mul,A)
ans1=two(p,ans1)
#for i in range(N):
#    ans2=two(A[i],ans2)
print(ans1)

# Optimized solution
#import sys
#sys.setrecursionlimit(10**9)
#from functools import reduce
#from operator import mul

#def two(a,ans):
#    if a%2==0:
#        return two(a//2,ans+1)
#    else:
#        return ans

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

#ans1=0
#ans2=0
#p=reduce(mul,A)
p2=1
for a in A:
    p2*=a
#ans1=two(p,ans1)
ans3=0
while p2%2==0:
    p2//=2
    ans3+=1
#for i in range(N):
#    ans2=two(A[i],ans2)
print(ans3)
# Original solution
def counter(value):
    count = 0
    while value % 2 == 0:
        count += 1
        value /= 2

    return count

n = int(eval(input()))

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

count = 0

for i in range(n):
    if a[i] % 2 == 0:
        count += counter(a[i])
        
print(count)


# Optimized solution
ans = 0
N = int(eval(input()))
a = list(map(int, input().split()))
for n in a:
    while not n % 2:
        ans += 1
        n //= 2
print(ans)