#include<bits/stdc++.h>

using namespace std;

class Fraction
{
private:
  // Calculates the greates common divisor with
  // Euclid's algorithm
  // both arguments have to be positive
  long long gcd(long long a, long long b)
  {
    while(a != b) {
      if(a > b) {
        a -= b;
      } else {
        b -= a;
      }
    }
    return a;
  }

public:
  long long numerator, denominator;

  Fraction()
  {
    numerator = 0;
    denominator = 1;
  }

  Fraction(long long n, long long d)
  {
    if(d == 0) {
      cerr << "Denominator may not be 0." << endl;
      exit(0);
    } else if(n == 0) {
      numerator = 0;
      denominator = 1;
    } else {
      int sign = 1;
      if(n < 0) {
        sign *= -1;
        n *= -1;
      }
      if(d < 0) {
        sign *= -1;
        d *= -1;
      }

      long long tmp = gcd(n, d);
      numerator = n / tmp * sign;
      denominator = d / tmp;
    }
  }

  operator int() { return (numerator) / denominator; }

  operator float() { return ((float) numerator) / denominator; }

  operator double() { return ((double) numerator) / denominator; }


};


Fraction operator+(const Fraction &lhs, const Fraction &rhs)
{
  Fraction tmp(lhs.numerator * rhs.denominator
               + rhs.numerator * lhs.denominator,
               lhs.denominator * rhs.denominator);
  return tmp;
}

Fraction operator-(const Fraction &lhs, const Fraction &rhs)
{
  Fraction tmp(lhs.numerator * rhs.denominator
               - rhs.numerator * lhs.denominator,
               lhs.denominator * rhs.denominator);
  return tmp;
}

Fraction operator*(const Fraction &lhs, const Fraction &rhs)
{
  Fraction tmp(lhs.numerator * rhs.numerator,
               lhs.denominator * rhs.denominator);
  return tmp;
}

Fraction operator/(const Fraction &lhs, const Fraction &rhs)
{
  Fraction tmp(lhs.numerator * rhs.denominator,
               lhs.denominator * rhs.numerator);
  return tmp;
}


bool operator<(const Fraction &a, const Fraction &b)
{
  Fraction c = a - b;
  return ((double) c < 0);
}

int main()
{
  set< Fraction > dp[1 << 7];
  int N, A[7];

  cin >> N;
  for(int i = 0; i < N; i++) cin >> A[i];

  for(int i = 0; i < N; i++) {
    dp[1 << i].emplace(Fraction(A[i], 1));
  }
  for(int i = 0; i < (1 << N); i++) {
    for(int j = 0; j < (1 << N); j++) {
      if(i & j) continue;
      for(auto &k : dp[i]) {
        for(auto l : dp[j]) {
          dp[i | j].emplace(k + l);
          dp[i | j].emplace(k - l);
          dp[i | j].emplace(k * l);
          if((double) l != 0) dp[i | j].emplace(k / l);
          if(dp[i | j].count(Fraction(0, 1))) {
            cout << "YES" << endl;
            return (0);
          }
        }
      }
    }
  }
  cout << "NO" << endl;
}