#include <bits/stdc++.h>
using namespace std;
template <typename T>
inline bool isOn(T mask, T pos) {
  return mask & (1 << pos);
}
template <typename T>
inline int Off(T mask, T pos) {
  return mask ^ (1 << pos);
}
template <typename T>
inline int On(T mask, T pos) {
  return mask | (1 << pos);
}
template <class T>
inline int countbit(T n) {
  return (n == 0) ? 0 : (1 + countbit(n & (n - 1)));
}
template <class T>
string toBinary(T n) {
  string ret = "";
  while (n) {
    if (n % 2 == 1)
      ret += '1';
    else
      ret += '0';
    n >>= 1;
  }
  reverse(ret.begin(), ret.end());
  return ret;
}
template <class T>
string toString(T n) {
  ostringstream ost;
  ost << n;
  ost.flush();
  return ost.str();
}
int toInt(string s) {
  int r = 0;
  istringstream sin(s);
  sin >> r;
  return r;
}
long long int toLInt(string s) {
  long long int r = 0;
  istringstream sin(s);
  sin >> r;
  return r;
}
double toDouble(string s) {
  double r = 0;
  istringstream sin(s);
  sin >> r;
  return r;
}
vector<string> token(string str, string deli) {
  char *cstr, *p, *deli_c;
  deli_c = new char[deli.size() + 1];
  cstr = new char[str.size() + 1];
  strcpy(deli_c, deli.c_str());
  strcpy(cstr, str.c_str());
  vector<string> vec;
  p = strtok(cstr, deli_c);
  while (p != NULL) {
    vec.push_back(string(p));
    p = strtok(NULL, deli_c);
  }
  delete[] cstr;
  return vec;
}
template <class T>
inline T GCD(T a, T b) {
  if (a < 0) return GCD(-a, b);
  if (b < 0) return GCD(a, -b);
  return (b == 0) ? a : GCD(b, a % b);
}
template <class T>
inline T LCM(T a, T b) {
  if (a < 0) return LCM(-a, b);
  if (b < 0) return LCM(a, -b);
  return a * (b / GCD(a, b));
}
template <class T>
inline T BIGMOD(T n, T m, T mod) {
  long long int ans = 1;
  long long int k = n;
  while (m) {
    if (m & 1) {
      ans *= k;
      if (ans > mod) ans %= mod;
    }
    k *= k;
    if (k > mod) k %= mod;
    m >>= 1;
  }
  return ans;
}
template <class T>
T modInverse(T b, T m) {
  return BIGMOD(b, m - 2, m);
}
long long int fastExpo(long long int b, long long int p) {
  long long int res = 1, x = b;
  while (p) {
    if (p & 1) res *= x;
    x *= x;
    p = p >> 1;
  }
  return res;
}
long long int hash_table(char c[]) {
  long long int len = strlen(c);
  long long int hash_value = 0, base = 26, mod = 10000007;
  for (long long int i = 0; i < len; i++) {
    long long int n = c[i] - 64;
    long long int power = BIGMOD(base, i, mod);
    n = ((n % mod) * (power % mod)) % mod;
    hash_value = ((hash_value % mod) + (n % mod)) % mod;
  }
  return hash_value;
}
double dist(int x, int y, int x1, int y1) {
  return sqrt(((x1 - x) * (x1 - x)) + ((y1 - y) * (y1 - y)));
}
struct st {
  int one;
  int zero;
};
map<int, int> mp;
int a[5], n;
int v[1000066];
int vs[1000066];
void reset() {
  for (int j = 0; j < n; j++) v[a[j]] = vs[a[j]];
}
int fun(int x1) {
  int cnt = 0;
  if (v[x1]) {
    v[x1]--;
    cnt++;
  }
  int x4, x3, x2;
  x4 = 3 * x1;
  if (v[x4]) {
    v[x4]--;
    cnt++;
  }
  if (cnt == n) {
    return 1;
  }
  for (int i = x1; i < 4 * x1; i++) {
    if (i >= x4 || (4 * x1 - i) > x4) continue;
    int ff = 0;
    if (v[i]) {
      ff += 1;
      v[i]--;
      cnt++;
    }
    if (cnt == n) {
      return 1;
    }
    if (v[4 * x1 - i]) {
      if (ff)
        ff = 3;
      else
        ff = 2;
      v[4 * x1 - i]--;
      cnt++;
    }
    if (cnt + 2 < n) return 0;
    if (cnt == n) {
      return 1;
    }
    if (ff == 1) {
      cnt--;
      v[i]++;
    } else if (ff == 2) {
      cnt--;
      v[4 * x1 - i]++;
    } else if (cnt == 3) {
      cnt--;
      v[i]++;
      cnt--;
      v[4 * x1 - i]++;
    }
  }
  return 0;
}
vector<int> vvv;
int path(int x1) {
  int cnt = 0;
  if (v[x1]) {
    v[x1]--;
    cnt++;
  } else
    vvv.push_back(x1);
  int x4, x3, x2;
  x4 = 3 * x1;
  int f = 0;
  if (v[x4]) {
    v[x4]--;
    cnt++;
  } else
    vvv.push_back(x4);
  if (cnt == n) {
    vvv.push_back(x1);
    vvv.push_back(3 * x1);
    return 1;
  }
  for (int i = x1; i < 4 * x1; i++) {
    if (i >= x4 || (4 * x1 - i) > x4) continue;
    int fff = 0;
    int ff = 0;
    if (v[i]) {
      fff = 1;
      ff = 1;
      v[i]--;
      cnt++;
    }
    if (cnt == n) {
      if (ff == 1) vvv.push_back(4 * x1 - i);
      return 1;
    }
    if (v[4 * x1 - i]) {
      if (fff)
        fff = 3;
      else
        fff = 2;
      ff++;
      v[4 * x1 - i]--;
      cnt++;
    }
    if (cnt == n) {
      if (ff == 1) vvv.push_back(i);
      return 1;
    }
    if (fff == 1) {
      cnt--;
      v[i]++;
    } else if (fff == 2) {
      cnt--;
      v[4 * x1 - i]--;
    } else if (fff == 3) {
      cnt--;
      v[i]++;
      cnt--;
      v[4 * x1 - i]--;
    }
  }
  return 0;
}
int main() {
  int x;
  cin >> n;
  int mn = 99999999;
  for (int i = 0; i < n; i++) {
    cin >> a[i];
    mn = min(mn, a[i]);
    vs[a[i]]++;
  }
  if (mn == 99999999) mn = 1;
  int cnt = 0;
  sort(a, a + n);
  int ans = 0;
  for (int i = 1; i <= mn; i++) {
    reset();
    if (fun(i)) {
      ans = i;
      break;
    }
  }
  if (ans) {
    cout << "YES" << endl;
    reset();
    path(ans);
    sort(vvv.begin(), vvv.end());
    for (int i = 0; i < vvv.size(); i++) cout << vvv[i] << endl;
  } else {
    cout << "NO" << endl;
  }
}
