output_description: Print the maximum number of operations that Snuke can perform.
  
  * * *
input_description: Input is given from Standard Input in the following format:
  
      
      
      N
      a_1 a_2 a_3 ... a_N
attempt: # coding: utf-8
  import re
  import math
  from collections import defaultdict
  from collections import deque
  import itertools
  from copy import deepcopy
  import random
  import time
  import os
  import queue
  import sys
  import datetime
  from functools import lru_cache
  
  # @lru_cache(maxsize=None)
  readline = sys.stdin.readline
  sys.setrecursionlimit(2000000)
  # import numpy as np
  alphabet = "abcdefghijklmnopqrstuvwxyz"
  mod = int(10**9 + 7)
  inf = int(10**20)
  
  
  def yn(b):
      if b:
          print("yes")
      else:
          print("no")
  
  
  def Yn(b):
      if b:
          print("Yes")
      else:
          print("No")
  
  
  def YN(b):
      if b:
          print("YES")
      else:
          print("NO")
  
  
  class union_find:
      def __init__(self, n):
          self.n = n
          self.P = [a for a in range(N)]
          self.rank = [0] * n
  
      def find(self, x):
          if x != self.P[x]:
              self.P[x] = self.find(self.P[x])
          return self.P[x]
  
      def same(self, x, y):
          return self.find(x) == self.find(y)
  
      def link(self, x, y):
          if self.rank[x] < self.rank[y]:
              self.P[x] = y
          elif self.rank[y] < self.rank[x]:
              self.P[y] = x
          else:
              self.P[x] = y
              self.rank[y] += 1
  
      def unite(self, x, y):
          self.link(self.find(x), self.find(y))
  
      def size(self):
          S = set()
          for a in range(self.n):
              S.add(self.find(a))
          return len(S)
  
  
  def is_pow(a, b):  # aはbの累乗数か
      now = b
      while now < a:
          now *= b
      if now == a:
          return True
      else:
          return False
  
  
  def bin_(num, size):
      A = [0] * size
      for a in range(size):
          if (num >> (size - a - 1)) & 1 == 1:
              A[a] = 1
          else:
              A[a] = 0
      return A
  
  
  def get_facs(n, mod_=0):
      A = [1] * (n + 1)
      for a in range(2, len(A)):
          A[a] = A[a - 1] * a
          if mod > 0:
              A[a] %= mod_
      return A
  
  
  def comb(n, r, mod, fac):
      if n - r < 0:
          return 0
      return (fac[n] * pow(fac[n - r], mod - 2, mod) * pow(fac[r], mod - 2, mod)) % mod
  
  
  def next_comb(num, size):
      x = num & (-num)
      y = num + x
      z = num & (~y)
      z //= x
      z = z >> 1
      num = y | z
      if num >= (1 << size):
          return False
      else:
          return num
  
  
  def get_primes(n, type="int"):
      if n == 0:
          if type == "int":
              return []
          else:
              return [False]
      A = [True] * (n + 1)
      A[0] = False
      A[1] = False
      for a in range(2, n + 1):
          if A[a]:
              for b in range(a * 2, n + 1, a):
                  A[b] = False
      if type == "bool":
          return A
      B = []
      for a in range(n + 1):
          if A[a]:
              B.append(a)
      return B
  
  
  def is_prime(num):
      if num <= 1:
          return False
      i = 2
      while i * i <= num:
          if num % i == 0:
              return False
          i += 1
      return True
  
  
  def ifelse(a, b, c):
      if a:
          return b
      else:
          return c
  
  
  def join(A, c=""):
      n = len(A)
      A = list(map(str, A))
      s = ""
      for a in range(n):
          s += A[a]
          if a < n - 1:
              s += c
      return s
  
  
  def factorize(n, type_="dict"):
      b = 2
      list_ = []
      while b * b <= n:
          while n % b == 0:
              n //= b
              list_.append(b)
          b += 1
      if n > 1:
          list_.append(n)
      if type_ == "dict":
          dic = {}
          for a in list_:
              if a in dic:
                  dic[a] += 1
              else:
                  dic[a] = 1
          return dic
      elif type_ == "list":
          return list_
      else:
          return None
  
  
  def floor_(n, x=1):
      return x * (n // x)
  
  
  def ceil_(n, x=1):
      return x * ((n + x - 1) // x)
      return ret
  
  
  def seifu(x):
      return x // abs(x)
  
  
  ###################################################
  def main():
      N = int(input())
      A = list(map(int, input().split()))
      ni = [0] * N
      for a in range(N):
          now = A[a]
          cnt = 0
          while now % 2 == 0:
              now //= 2
              cnt += 1
          ni[a] = cnt
      print(sum(ni))
  
  
  main()
  
problem_description: Statement
  
  As AtCoder Beginner Contest 100 is taking place, the office of AtCoder, Inc.
  is decorated with a sequence of length N, a = {a_1, a_2, a_3, ..., a_N}.  
  Snuke, an employee, would like to play with this sequence.
  
  Specifically, he would like to repeat the following operation as many times as
  possible:
  
      
      
      For every i satisfying 1 \leq i \leq N, perform one of the following: "divide a_i by 2" and "multiply a_i by 3".  
      Here, choosing "multiply a_i by 3" for every i is not allowed, and the value of a_i after the operation must be an integer.
      
  
  At most how many operations can be performed?
samples: [{"input": "3\n    5 2 4", "output": "3\n    \n\nThe sequence is initially {5, 2, 4}. Three operations can be performed as\nfollows:\n\n  * First, multiply a_1 by 3, multiply a_2 by 3 and divide a_3 by 2. The sequence is now {15, 6, 2}.\n  * Next, multiply a_1 by 3, divide a_2 by 2 and multiply a_3 by 3. The sequence is now {45, 3, 6}.\n  * Finally, multiply a_1 by 3, multiply a_2 by 3 and divide a_3 by 2. The sequence is now {135, 9, 3}.\n\n* * *"}, {"input": "4\n    631 577 243 199", "output": "0\n    \n\nNo operation can be performed since all the elements are odd. Thus, the answer\nis 0.\n\n* * *"}, {"input": "10\n    2184 2126 1721 1800 1024 2528 3360 1945 1280 1776", "output": "39"}]