Iahub and Iahubina went to a picnic in a forest full of trees. Less than 5 minutes passed before Iahub remembered of trees from programming. Moreover, he invented a new problem and Iahubina has to solve it, otherwise Iahub won't give her the food. 

Iahub asks Iahubina: can you build a rooted tree, such that
 -  each internal node (a node with at least one son) has at least two sons; -  node *i* has *c*<sub class="lower-index">*i*</sub> nodes in its subtree? 
Iahubina has to guess the tree. Being a smart girl, she realized that it's possible no tree can follow Iahub's restrictions. In this way, Iahub will eat all the food. You need to help Iahubina: determine if there's at least one tree following Iahub's restrictions. The required tree must contain *n* nodes.
The first line of the input contains integer *n* (1 ≤ *n* ≤ 24). Next line contains *n* positive integers: the *i*-th number represents *c*<sub class="lower-index">*i*</sub> (1 ≤ *c*<sub class="lower-index">*i*</sub> ≤ *n*).
from bitarray import bitarray
from sys import stdin, stdout

def read():
    return stdin.readline().rstrip()

def Ni():
    return [int(x) for x in read().split()]

n = Ni()[0]
size = Ni()
size = sorted(size, reverse=True)

cache = []
for _ in range(n + 1):
    cache.append( [None] * 2**(n + 1))

def solve(at, bitset):

    #print("Solve: ", at, bitset)
    if cache[at][bitset] is not None:
        return cache[at][bitset]

    if at == n:
        cache[at][bitset] = True
        return cache[at][bitset]

    if size[at] == 1:
        cache[at][bitset] = solve(at + 1, bitset)
        return cache[at][bitset]

    if (1 << at) & bitset == 0:
        cache[at][bitset] = False
        return cache[at][bitset]

    ret = False
    for subset, bits in partitions[size[at] - 1]:
        if bits > 1:
            ret = ret | solve(at + 1, subset | bitset)
    cache[at][bitset] = ret
    return cache[at][bitset]

if __name__ == '__main__':


    import collections
    partitions = collections.defaultdict(list)
    # pre-compute subset
    for subset in range(2**n):

        summand = 0
        for k in range(n):
            if (1 << k) & subset:
                summand += size[k]

        bits = bin(subset).count('1')
        partitions[summand].append( (subset, bits) )

    bitset = 1

    solution = solve(0, 1)
    print(["NO", "YES"][solution])

# solution = size[0] == n and solve(0, n, size, used)
# print(["NO", "YES"][solution])
