#include<iostream>
#include<vector>
#include<cstring>
#include<algorithm>
#include<queue>
using namespace std;
#define MAX_V 100000
#define INF (1<<24)
#define M 10000000
typedef pair<int,int> P;

struct edge { int to,cap,cost,rev; };

int V,edgecnt;
vector<edge> G[MAX_V];
int h[MAX_V];
int dist[MAX_V];
int prevv[MAX_V],preve[MAX_V];

void init_edge(){
  for(int i=0;i<V;i++)G[i].clear();
}

void add_edge(int from,int to,int cap,int cost){
  G[from].push_back((edge){to,cap,cost,G[to].size()});
  G[to].push_back((edge){from,0,-cost,G[from].size()-1});
}


void pop_edge(int from,int to){
  G[from].pop_back();
  G[to].pop_back();
}

int min_cost_flow(int s,int t,int f){
  int res = 0;
  fill(h,h+V,0);
  while(f>0){

    priority_queue< P, vector<P>, greater<P> >  que;
    fill( dist, dist+V , INF );
    dist[s]=0;
    que.push(P(0,s));
    while(!que.empty()){
      P p = que.top(); que.pop();
      int v = p.second;
      if(dist[v]<p.first)continue;
      for(int i=0;i<(int)G[v].size();i++){
	edge &e = G[v][i];
	if(e.cap>0&&dist[e.to] > dist[v]+e.cost+h[v]-h[e.to]){
	  dist[e.to]=dist[v]+e.cost+h[v]-h[e.to];
	  prevv[e.to]=v;
	  preve[e.to]=i;
	  que.push(P(dist[e.to],e.to));
	}
      }
    }

    if(dist[t]==INF){
      return -INF;
    }
    for(int v=0;v<V;v++)h[v]+=dist[v];

    int d=f;
    for(int v=t;v!=s;v=prevv[v]){
      d=min(d,G[prevv[v]][preve[v]].cap);
    }
    f-=d;
    res+=d*h[t];
    for(int v=t;v!=s;v=prevv[v]){
      edge &e = G[prevv[v]][preve[v]];
      e.cap -= d;
      G[v][e.rev].cap += d;
    }
  }
  return res;
}

int n,sum;
int t[100];
vector < vector<int> > u;



void solve(){

  for(int i=0;i<(int)u.size();i++){
    
    for(int j=0;j<(int)u[i].size();j++){
      add_edge(n+u[i][j],n+n,INF,0);
    }
 
    int z=min_cost_flow(0,n+n,t[0]);

    if(z==-INF||z!=sum){
    }else{
      cout<<"YES"<<endl;
      return;
    }

    for(int j=0;j<(int)u[i].size();j++){
      pop_edge(n+u[i][j],n+n);
    }

  }
  cout<<"NO"<<endl;
}

vector<int> tmp;
void make_table(int n,int sum){
  //cout<<n<<' '<<sum<<endl;
  
  if(sum==t[0]){
    u.push_back(tmp);return;
  }
  if(sum>t[0]||n<0)return;

  tmp.push_back(n);
  make_table(n-1,sum+t[n]);
  tmp.pop_back();
  make_table(n-1,sum);

}

int main(){
  
  while(cin>>n&&n){

    init_edge();
    sum=0;
    for(int i=0;i<n;i++){cin>>t[i];sum-=t[i];}
    u.clear();

    sort(t,t+n);
    reverse(t,t+n);


    tmp.clear();
    make_table(n-1,0);

    for(int i=0;i<n;i++){
      add_edge(i,n+i,t[i],-1);
    }

    for(int i=0;i<n-1;i++){
      for(int j=i+1;j<n;j++){
	add_edge(n+i,j,t[j],0);
      }
    }

    V=n+n+1;
    solve();
  }

  return 0;
}