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 sys import stdin, stdout
import collections

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

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

def solve(at, bitset, leaves):

    # print("At: ", at, '{0:b}'.format(bitset).zfill(n)[::-1], 'leaves=', leaves)

    hit = cache.get((at, bitset, leaves))

    if hit is not None:
        return hit

    if at == k:
        if leaves == 0:
            return True
        else:
            return False

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

    ret = False
    for subset in range(1 << k):

        if subset & bitset != 0:
            continue

        summand = 0
        bits = 0
        for b in range(k):
            if (1 << b) & subset:
                summand += sizes[b]
                bits += 1

        if summand + leaves >= sizes[at] - 1:
            used = sizes[at] - 1 - summand
            if used + bits > 1:
                ret = ret | solve(at + 1, subset | bitset, leaves - used)

    cache[(at, bitset, leaves)] = ret
    return ret

# for index in range(18):
sizes = []
leaves = 0
n = Ni()[0]

for k in Ni():
    if k == 1:
        leaves += 1
    else:
        sizes.append(k)

k = len(sizes)
# truth = read()
sizes = sorted(sizes, reverse=True)
cache = {}

if (k == 0):
    print(["NO", "YES"][leaves == 1])
else:
    solution = solve(0, 1, leaves) and sizes[0] == n
    # print(index, ["NO", "YES"][solution] == truth)
    print(["NO", "YES"][solution])
