using System;
using System.Collections.Generic;
using System.Globalization;
using System.IO;
using System.Runtime.CompilerServices;
using static Scanner;
using static Util;
using static System.Math;

class Solver
{
    static void Main(string[] args) {
        Console.SetOut(new StreamWriter(Console.OpenStandardOutput()) { AutoFlush = false });
        Solve();
        Console.Out.Flush();
    }

    static void Solve() {
        int N = Sc<int>(), other = 0, two = 0, four = 1;
        for (int i = 0; i < N; i++) {
            var a = Sc<int>();
            var count = 0;
            while ((a & 1) == 0) {
                a >>= 1;
                count++;
            }
            _ = count >= 2 ? four++ : count == 1 ? two++ : other++;
        }
        if (two > 0) four--;
        Console.WriteLine(other <= four ? "Yes" : "No");
    }
}

class Scanner
{
    const int BUFFER_SIZE = 1024;
    const char SPACE = ' ', BEGIN = '!', END = '~', ZERO = '0', NINE = '9'; 
    static readonly Stream stdin = Console.OpenStandardInput();
    static readonly byte[] buffer = new byte[BUFFER_SIZE];
    static int size, p;
    static bool isEof;

    [MethodImpl(256)]
    private static byte Read() {
        if (isEof) return default;
        if (p < size) return buffer[p++];
        p = 0;
        if ((size = stdin.Read(buffer, 0, BUFFER_SIZE)) > 0) return buffer[p++];
        isEof = true;
        return 0;
    }
    [MethodImpl(256)]
    private static char Next() {
        byte b;
        do b = Read();
        while (b < BEGIN || END < b);
        return (char) b;
    }
    [MethodImpl(256)]
    public static ReadOnlySpan<char> StrSpan() {
        var list = new List<char> { Next() };
        for (var c = (char) Read(); BEGIN <= c && c <= END; c = (char) Read()) list.Add(c);
        return list.AsSpan();
    }
    [MethodImpl(256)]
    private static int Int() {
        int tmp = Next() - ZERO;
        for (var c = (char) Read(); ZERO <= c && c <= NINE; c = (char) Read()) tmp = tmp * 10 + c - ZERO;
        return tmp;
    }
    [MethodImpl(256)]
    private static long Long() {
        long tmp = Next() - ZERO;
        for (var c = (char) Read(); ZERO <= c && c <= NINE; c = (char) Read()) tmp = tmp * 10 + c - ZERO;
        return tmp;
    }
    [MethodImpl(256)]
    private static double Double() => double.Parse(StrSpan(), NumberStyles.Float | NumberStyles.AllowThousands, CultureInfo.InvariantCulture);
    [MethodImpl(256)]
    public static ReadOnlySpan<char> ScanLine() {
        var list = new List<char> { Next() };
        for (var c = Next(); SPACE <= c && c <= END; c = (char) Read()) list.Add(c);
        return list.AsSpan();
    }
    [MethodImpl(256)]
    public static T Sc<T>()
        => default(T) switch
            {int _ => (T) (object) Int(), long _ => (T) (object) Long(), double _ => (T) (object) Double(), _ => (T) (object) StrSpan().ToString()};
    [MethodImpl(256)]
    public static T[] ScArray<T>(int N) {
        var array = new T[N];
        for (int i = 0; i < N; i++) array[i] = Sc<T>();
        return array;
    }
    [MethodImpl(256)]
    public static T[,] ScArray2D<T>(int N, int M) {
        var array = new T[N, M];
        for (int i = 0; i < N; i++)
            for (int j = 0; j < M; j++)
                array[i, j] = Sc<T>();
        return array;
    }
    [MethodImpl(256)] public static (T, T) Dual<T>() => (Sc<T>(), Sc<T>());
    [MethodImpl(256)] public static (T, T, T) Tri<T>() => (Sc<T>(), Sc<T>(), Sc<T>());
    [MethodImpl(256)] public static (T, T, T, T) Quad<T>() => (Sc<T>(), Sc<T>(), Sc<T>(), Sc<T>());
    [MethodImpl(256)] public static (T, T, T, T, T) Quint<T>() => (Sc<T>(), Sc<T>(), Sc<T>(), Sc<T>(), Sc<T>());
    [MethodImpl(256)] public static (T1, T2) Sc<T1, T2>() => (Sc<T1>(), Sc<T2>());
    [MethodImpl(256)] public static (T1, T2, T3) Sc<T1, T2, T3>() => (Sc<T1>(), Sc<T2>(), Sc<T3>());
    [MethodImpl(256)] public static (T1, T2, T3, T4) Sc<T1, T2, T3, T4>() => (Sc<T1>(), Sc<T2>(), Sc<T3>(), Sc<T4>());
    [MethodImpl(256)] public static (T1, T2, T3, T4, T5) Sc<T1, T2, T3, T4, T5>() => (Sc<T1>(), Sc<T2>(), Sc<T3>(), Sc<T4>(), Sc<T5>());
    [MethodImpl(256)] public static (T1, T2, T3, T4, T5, T6) Sc<T1, T2, T3, T4, T5, T6>() => (Sc<T1>(), Sc<T2>(), Sc<T3>(), Sc<T4>(), Sc<T5>(), Sc<T6>());
}

static class Util
{
    [MethodImpl(256)] public static bool AsBit(int bit, int i) => (bit >> i & 1) == 1;
    [MethodImpl(256)] public static bool ChMax<T>(ref this T a, T b) where T : struct, IComparable<T> { if (a.CompareTo(b) >= 0) return false; a = b; return true; }
    [MethodImpl(256)] public static bool ChMin<T>(ref this T a, T b) where T : struct, IComparable<T> { if (a.CompareTo(b) <= 0) return false; a = b; return true; }
}
static class Extensions
{
    // List
    private abstract class Wrapper<T> { public readonly T[] Items; }
    [MethodImpl(256)]
    public static Span<T> AsSpan<T>(this List<T> list) => Unsafe.As<Wrapper<T>>(list).Items.AsSpan(0, list.Count);

    // Array
    [MethodImpl(256)]
    public static void Sort<T>(this T[] arr, IComparer<T> comparer = null) => Array.Sort(arr, 0, arr.Length, comparer);
    [MethodImpl(256)]
    public static void Reverse<T>(this T[] arr) => Array.Reverse(arr, 0, arr.Length);
}

Measured memory_bytes: 23704