using System;
using System.Collections.Generic;
using System.Globalization;
using System.IO;
using System.Runtime.CompilerServices;

internal class Solver
{
    const int BUFFER_SIZE = 1 << 10;
    static void Main(string[] args) {
        Console.SetOut(new StreamWriter(Console.OpenStandardOutput()) { AutoFlush = false });
        Span<byte> span = stackalloc byte[BUFFER_SIZE];
        Solve(new Scanner(Console.OpenStandardInput(), ref span));
        Console.Out.Flush();
    }

    static void Solve(in Scanner sc) {
        int N = sc.Read<int>(), other = 0, two = 0, four = 1;
        for (int i = 0; i < N; i++) {
            var a = sc.Read<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");
    }
}

readonly ref struct Scanner
{
    const char SPACE = ' ', BEGIN = '!', END = '~', ZERO = '0', NINE = '9';
    readonly Stream stdin;
    readonly Span<byte> buffer;
    static int p;

    [MethodImpl(256)]
    public Scanner(Stream stream, ref Span<byte> buffer) { stdin = stream; this.buffer = buffer; }
    [MethodImpl(256)]
    void Move() { if (++p < buffer.Length) return; stdin.Read(buffer); p = 0; }
    [MethodImpl(256)]
    char Next() { while (buffer[p] < BEGIN || END < buffer[p]) Move(); return (char) buffer[p]; }
    [MethodImpl(256)]
    byte NextNum() { while (buffer[p] < ZERO || NINE < buffer[p]) Move(); return buffer[p]; }
    [MethodImpl(256)]
    byte ReadByte() { Move(); return buffer[p]; }
    [MethodImpl(256)]
    public ReadOnlySpan<char> StrSpan() {
        var list = new List<char> {Next()};
        for (byte b = ReadByte(); BEGIN <= b && b <= END; b = ReadByte()) list.Add((char) b);
        return list.AsSpan();
    }
    [MethodImpl(256)]
    public ReadOnlySpan<char> StrSpan(int N) {
        var span = new char[N];
        span[0] = Next();
        for (int i = 1; i < span.Length; i++) span[i] = (char) ReadByte();
        return span;
    }
    [MethodImpl(256)]
    int Int() {
        int tmp = NextNum() ^ ZERO;
        for (byte b = ReadByte(); ZERO <= b && b <= NINE; b = ReadByte()) tmp = tmp * 10 + (b ^ ZERO);
        return tmp;
    }
    [MethodImpl(256)]
    long Long() {
        long tmp = NextNum() ^ ZERO;
        for (byte b = ReadByte(); ZERO <= b && b <= NINE; b = ReadByte()) tmp = tmp * 10 + (b ^ ZERO);
        return tmp;
    }
    [MethodImpl(256)]
    double Double() => double.Parse(StrSpan(), NumberStyles.Float | NumberStyles.AllowThousands, CultureInfo.InvariantCulture);
    [MethodImpl(256)]
    public ReadOnlySpan<char> ScanLine() {
        var list = new List<char> {Next()};
        for (byte b = ReadByte(); SPACE <= b && b <= END; b = ReadByte()) list.Add((char) b);
        return list.AsSpan();
    }
    [MethodImpl(256)]
    public T Read<T>() => default(T) switch 
        { int _ => (T)(object)Int(), long _ => (T)(object)Long(), double _ => (T)(object)Double(), _ => (T)(object)StrSpan().ToString() };
    [MethodImpl(256)]
    public T[] Array<T>(int N) {
        var array = new T[N];
        for (int i = 0; i < N; i++) array[i] = Read<T>();
        return array;
    }
    [MethodImpl(256)]
    public T[,] Array2D<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] = Read<T>();
        return array;
    }
    [MethodImpl(256)] public (T, T) Dual<T>() => (Read<T>(), Read<T>());
    [MethodImpl(256)] public (T, T, T) Tri<T>() => (Read<T>(), Read<T>(), Read<T>());
    [MethodImpl(256)] public (T, T, T, T) Quad<T>() => (Read<T>(), Read<T>(), Read<T>(), Read<T>());
    [MethodImpl(256)] public (T, T, T, T, T) Quint<T>() => (Read<T>(), Read<T>(), Read<T>(), Read<T>(), Read<T>());
    [MethodImpl(256)] public (T1, T2) Read<T1, T2>() => (Read<T1>(), Read<T2>());
    [MethodImpl(256)] public (T1, T2, T3) Read<T1, T2, T3>() => (Read<T1>(), Read<T2>(), Read<T3>());
    [MethodImpl(256)] public (T1, T2, T3, T4) Read<T1, T2, T3, T4>() => (Read<T1>(), Read<T2>(), Read<T3>(), Read<T4>());
    [MethodImpl(256)] public (T1, T2, T3, T4, T5) Read<T1, T2, T3, T4, T5>() => (Read<T1>(), Read<T2>(), Read<T3>(), Read<T4>(), Read<T5>());
    [MethodImpl(256)] public (T1, T2, T3, T4, T5, T6) Read<T1, T2, T3, T4, T5, T6>() => (Read<T1>(), Read<T2>(), Read<T3>(), Read<T4>(), Read<T5>(), Read<T6>());
}

static class Extensions
{
    // List
    abstract class Wrapper<T> { public readonly T[] Items; protected Wrapper(T[] items) { Items = 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: 23960