#include <bits/stdc++.h>
template <typename T>
bool chmax(T &a, const T &b) {
  if (a <= b) {
    a = b;
    return (true);
  } else {
    return (false);
  }
}
template <typename T>
bool chmin(T &a, const T &b) {
  if (a >= b) {
    a = b;
    return (true);
  } else {
    return (false);
  }
}
using namespace std;
using ll = long long;
using ull = unsigned long long;
using Pint = pair<int, int>;
using Pll = pair<ll, ll>;
using Pull = pair<ull, ull>;
template <typename T>
T gcd(const T a, const T b) {
  return (b ? gcd(b, a % b) : a);
}
template <typename T>
T lcm(const T a, const T b) {
  return (a / gcd(a, b) * b);
}
constexpr ll MOD = 1000000007LL;
template <typename T = ll>
class UnionFind {
 public:
  UnionFind(T n) {
    par.resize(n);
    siz.resize(n);
    for (int i = 0; i < (int)(n); ++i) {
      par[i] = i;
      siz[i] = 1;
    }
  }
  T find(T x) {
    if (x == par[x])
      return (x);
    else
      return (par[x] = find(par[x]));
  }
  void unite(T x, T y) {
    T xx = find(x);
    T yy = find(y);
    if (xx == yy) return;
    if (siz[xx] <= siz[yy]) swap(xx, yy);
    par[yy] = xx;
    siz[xx] += siz[yy];
  }

 private:
  vector<T> par, siz;
};
template <typename T = ll>
class CompareMax {
 public:
  T operator()(T a, T b) { return (max(a, b)); }
};
template <typename T = ll>
class CompareMin {
 public:
  T operator()(T a, T b) { return (min(a, b)); }
};
template <typename T = ll, typename first = CompareMax<T>, T I = 0>
class SegTree {
 public:
  SegTree(T n) {
    N = n;
    v.resize(4 * n);
    for (int i = 0; i < (int)(4 * n); ++i) v[i] = I;
  }
  void update(T i, T x) {
    i += N - 1;
    v[i] = x;
    while (i > 0) {
      i = (i - 1) / 2;
      v[i] = func(v[i * 2 + 1], v[i * 2 + 2]);
    }
  }
  T query(T a, T b, T k, T l, T r) {
    if (r <= a || b <= l) return (I);
    if (a <= l && r <= b)
      return (v[k]);
    else {
      T vl = query(a, b, k * 2 + 1, l, (l + r) / 2);
      T vr = query(a, b, k * 2 + 2, (l + r) / 2, r);
      return (func(vl, vr));
    }
  }

 private:
  T N;
  first func;
  vector<T> v;
};
template <typename T = ll>
T solveLIS(const vector<T> &v) {
  vector<T> dp(v.size(), numeric_limits<T>::max());
  for (int i = 0; i < (int)(v.size()); ++i) {
    *lower_bound((dp).begin(), (dp).end(), v[i]) = v[i];
  }
  return (distance(dp.begin(), lower_bound((dp).begin(), (dp).end(),
                                           numeric_limits<T>::max())));
}
template <typename T = ll>
T power(T a, T b, T m = MOD) {
  T res = 1;
  while (b > 0) {
    if (b & 1) res = res * a % m;
    a = a * a % m;
    b >>= 1;
  }
  return (res);
}
void replace(string &s, string t, string r) {
  string::size_type p = 0;
  while ((p = s.find(t, p)) != string::npos) {
    s.replace(p, t.length(), r);
    p += r.length();
  }
}
int main() {
  int N;
  cin >> N;
  ll cnt1 = 0, cnt2 = 0;
  vector<ll> v(N);
  for (int i = 0; i < (int)(N); ++i) {
    cin >> v[i];
    if (v[i] % 2)
      ++cnt1;
    else if ((v[i] % 4) == 0)
      ++cnt2;
  }
  if ((cnt1 - 1) > cnt2)
    cout << "No" << endl;
  else {
    if (cnt1 == 0)
      cout << "Yes" << endl;
    else {
      if (N / 2 <= cnt2) {
        cout << "Yes" << endl;
      } else {
        if ((cnt2 - (cnt1 - 1)) >= (N - cnt1 - cnt2) - 1) {
          cout << "Yes" << endl;
        } else {
          cout << "No" << endl;
        }
      }
    }
  }
  return (0);
}
