#include <bits/stdc++.h>
int IntMaxVal = (int)1e20;
int IntMinVal = (int)-1e20;
long long LongMaxVal = (long long)1e20;
long long LongMinVal = (long long)-1e20;
template <typename T>
inline void minimize(T& a, T b) {
  a = std::min(a, b);
}
template <typename T>
inline void maximize(T& a, T b) {
  a = std::max(a, b);
}
using namespace std;
template <typename T>
struct argument_type;
template <typename T, typename U>
struct argument_type<T(U)> {};
template <typename T1, typename T2>
istream& operator>>(istream& is, pair<T1, T2>& s) {
  is >> s.first >> s.second;
  return is;
}
template <typename T>
ostream& operator<<(ostream& os, const vector<T>& v) {
  for (int i = 0; i < v.size(); i++) os << v[i] << ' ';
  os << '\n';
  return os;
}
template <typename T1, typename T2>
ostream& operator<<(ostream& s, pair<T1, T2>& t) {
  s << t.first << ' ' << t.second;
  return s;
}
template <typename T>
vector<T> readVector(int n) {
  vector<T> res(n);
  for (int i = 0; i < n; i++) cin >> res[i];
  return res;
}
vector<int> bigNodes;
vector<int> bigNodesSizeByMask;
vector<int> bigNodesCountByMask;
bool dp[2000][20][30];
bool calced[2000][20][30];
bool canBuild(int curLeafsMask, int assigningTo, int leavesCount) {
  if (curLeafsMask & (1 << assigningTo)) return false;
  if (!calced[curLeafsMask][assigningTo][leavesCount]) {
    calced[curLeafsMask][assigningTo][leavesCount] = true;
    int bigNodeSize = bigNodes[assigningTo] - 1;
    for (int subMask = 0; subMask < curLeafsMask + 1; ++subMask) {
      if ((subMask & curLeafsMask) != subMask) continue;
      if (bigNodesSizeByMask[subMask] > bigNodeSize)
        continue;
      else {
        int needLeaves = bigNodeSize - bigNodesSizeByMask[subMask];
        if (needLeaves + bigNodesCountByMask[subMask] < 2) continue;
        if (needLeaves > leavesCount) continue;
        int remLeaves = leavesCount - needLeaves;
        if (assigningTo == 0) {
          if (remLeaves == 0) dp[curLeafsMask][assigningTo][leavesCount] = true;
        } else if (canBuild(curLeafsMask ^ subMask, assigningTo - 1,
                            remLeaves)) {
          dp[curLeafsMask][assigningTo][leavesCount] = true;
        }
      }
    }
  }
  return dp[curLeafsMask][assigningTo][leavesCount];
}
int main() {
  srand(time(NULL));
  ios_base::sync_with_stdio(false);
  cin.tie(NULL);
  int n;
  cin >> n;
  ;
  int leaves = 0;
  for (int i = 0; i < n; ++i) {
    int x;
    cin >> x;
    ;
    if (x == 1)
      leaves++;
    else if (x == 2) {
      cout << "NO" << '\n';
      return 0;
    } else {
      bigNodes.push_back(x);
    }
  }
  if (bigNodes.size() > 14) {
    cout << "NO";
    return 0;
  }
  sort(bigNodes.begin(), bigNodes.end());
  if (bigNodes.size() == 0) {
    if (n == 1) {
      cout << "YES";
    } else
      cout << "NO";
    return 0;
  }
  int maxMask = 1 << bigNodes.size();
  bigNodesSizeByMask.resize(maxMask);
  bigNodesCountByMask.resize(maxMask);
  int b = 0;
  for (int mask = 1; mask < maxMask; ++mask) {
    if (mask & (2 << b)) b++;
    bigNodesSizeByMask[mask] =
        bigNodes[b] + bigNodesSizeByMask[mask ^ (1 << b)];
    bigNodesCountByMask[mask] = 1 + bigNodesCountByMask[mask ^ (1 << b)];
  }
  int allBigNodesMask;
  if (bigNodes.size() == 1)
    allBigNodesMask = 0;
  else
    allBigNodesMask = (1 << (bigNodes.size() - 1)) - 1;
  if (canBuild(allBigNodesMask, bigNodes.size() - 1, leaves))
    cout << "YES";
  else
    cout << "NO";
}
