Bob really likes playing with arrays of numbers. That's why for his birthday, his friends bought him a really interesting machine – an array beautifier. 

The array beautifier takes an array A consisting of N integers, and it outputs a new array B of length N that it constructed based on the array given to it. The array beautifier constructs the new array in the following way: it takes two numbers at different indices from the original array and writes their sum to the end of the new array. It does this step N times - resulting in an output array of length N. During this process, the machine can take the same index multiple times in different steps. 

Bob was very excited about the gift that his friends gave him, so he put his favorite array in the machine. However, when the machine finished, Bob was not happy with the resulting array. He misses his favorite array very much, and hopes to get it back. 

Given the array that the machine outputted, help Bob find an array that could be the original array that he put in the machine. Sometimes the machine makes mistakes, so it is possible that no appropriate input array exists for the array it has outputted. In such case, let Bob know that his array is forever lost.

Input

The first line contains one positive integer N (2 ≤ N ≤ 10^3) – the length of Bob's array.

The second line contains N integers B_1, B_2, ..., B_N (1 ≤ B_i ≤ 10^6) – the elements of the array the machine outputted.

Output

If an appropriate input array exists, print "YES", followed by the input array A_1, A_2, ..., A_N (-10^9 ≤ A_i ≤ 10^9) in the next line. Otherwise, print "NO".

Examples

Input


2
5 5


Output


YES
2 3


Input


3
1 2 3


Output


YES
0 1 2


Input


3
2 4 5


Output


NO


Input


4
1 3 5 7


Output


YES
6 -3 4 1
10
65 653 741 367 83 123 697 709 75 225
 28
838021 325431 421593 288065 582853 576633 860797 638833 700519 977193 373295 241043 202931 893111 825521 382683 977863 700613 845889 808093 478493 904615 542879 70837 617093 977285 259541 35727
 17
215389 497201 309515 155889 13825 209141 143605 644147 433581 6119 377229 500393 387727 183027 37375 911553 681799
 3
1 2 3
 4
1 3 5 7
 21
1 3 5 9 15 27 49 89 169 323 619 1189 2329 4569 8969 17615 34611 68603 136017 269705 534841
 17
93735 760399 14263 274357 455441 246939 403269 721719 840567 201925 983263 654711 578917 731115 867875 183211 128207
 11
895 65 883 71 73 41 697 957 505 833 521
 14
14133 17793 72643 38055 48689 13209 72227 8395 94373 65841 27691 23519 20649 45113
 18
18757 698263 809583 918785 488029 111625 60375 842523 9189 561421 746763 983163 584071 322501 971457 356953 857001 569403
 45
626953 914809 904465 722525 119559 927109 442661 274413 756639 540533 911895 953255 92227 554759 501873 755671 717375 20675 301847 965695 751539 57157 800935 210091 190657 419977 678497 460321 615673 17165 860271 793783 429477 106631 304299 542627 2167 901487 103669 732797 483611 111411 160243 861585 121493
 7
671981 428609 483433 396855 712413 209125 137319
 2
5 5

YES
0 65 676 -23 106 261 -138 847 -150 225  YES
0 421593 416428 444369 256150 382683 325431 288065 582853 576633 977193 373295 241043 202931 893111 825521 977863 700613 845889 808093 478493 904615 542879 70837 617093 977285 259541 35727  YES
0 155889 59500 -45675 542876 -333735 339854 37375 309515 143605 644147 433581 500393 387727 183027 911553 681799  YES
2 1 0 
 YES
0 3 -2 7
 NO
 YES
0 760399 -666664 941021 -926758 1173697 -333130 736399 246864 474855 256260 -54335 922210 -267499 450710 128207 455441  NO
 YES
0 14133 34556 -16763 29972 42671 29556 8499 -104 94477 -28636 52155 -24464 45113  YES
0 698263 220522 589061 -477436 965465 -122942 183317 378104 368659 614504 356953 18757 9189 584071 322501 857001 569403  YES
0 927109 -807550 1564189 -652294 1207053 -253798 755671 626953 914809 904465 722525 442661 274413 540533 92227 717375 20675 301847 965695 751539 57157 800935 210091 190657 419977 678497 460321 615673 17165 860271 793783 429477 106631 304299 542627 2167 901487 103669 732797 483611 111411 160243 861585 121493  NO
 YES
0 5 
/*学习古代文章，诗词
出师表 三国·诸葛亮

先帝创业未半而中道崩殂，今天下三分，益州疲弊，此诚危急存亡之秋也。然侍卫之臣不懈于内，忠志之士忘身于外者，盖追先帝之殊遇，欲报之于陛下也。诚宜开张圣听，以光先帝遗德，恢弘志士之气，不宜妄自菲薄，引喻失义，以塞忠谏之路也。

宫中府中，俱为一体；陟罚臧否，不宜异同：若有作奸犯科及为忠善者，宜付有司论其刑赏，以昭陛下平明之理；不宜偏私，使内外异法也。

侍中、侍郎郭攸之、费祎、董允等，此皆良实，志虑忠纯，是以先帝简拔以遗陛下：愚以为宫中之事，事无大小，悉以咨之，然后施行，必能裨补阙漏，有所广益。

将军向宠，性行淑均，晓畅军事，试用于昔日，先帝称之曰“能”，是以众议举宠为督：愚以为营中之事，悉以咨之，必能使行阵和睦，优劣得所。

亲贤臣，远小人，此先汉所以兴隆也；亲小人，远贤臣，此后汉所以倾颓也。先帝在时，每与臣论此事，未尝不叹息痛恨于桓、灵也。侍中、尚书、长史、参军，此悉贞良死节之臣，愿陛下亲之信之，则汉室之隆，可计日而待也。

臣本布衣，躬耕于南阳，苟全性命于乱世，不求闻达于诸侯。先帝不以臣卑鄙，猥自枉屈，三顾臣于草庐之中，咨臣以当世之事，由是感激，遂许先帝以驱驰。后值倾覆，受任于败军之际，奉命于危难之间：尔来二十有一年矣。

先帝知臣谨慎，故临崩寄臣以大事也。受命以来，夙夜忧叹，恐托付不效，以伤先帝之明；故五月渡泸，深入不毛。今南方已定，兵甲已足，当奖率三军，北定中原，庶竭驽钝，攘除奸凶，兴复汉室，还于旧都。此臣所以报先帝而忠陛下之职分也。至于斟酌损益，进尽忠言，则攸之、祎、允之任也。

愿陛下托臣以讨贼兴复之效，不效，则治臣之罪，以告先帝之灵。若无兴德之言，则责攸之、祎、允等之慢，以彰其咎；陛下亦宜自谋，以咨诹善道，察纳雅言，深追先帝遗诏。臣不胜受恩感激。

今当远离，临表涕零，不知所言。
*/
//Generated at 2021-10-12 15:26:19 UTC+8
//Created by Alphagocc
#ifndef TYPE_HPP
#define TYPE_HPP
#include <type_traits>
#ifndef __cpp_lib_void_t
namespace std
{
template <typename...> using void_t = void;
}
#endif
template <typename T, typename _ = void> struct is_container : std::false_type
{};
template <typename... Ts> struct is_container_helper
{};
template <typename T>
struct is_container<T,
    typename std::conditional<false,
        is_container_helper<decltype(std::declval<T>().size()),
            decltype(std::declval<T>().begin()),
            decltype(std::declval<T>().end()),
            decltype(std::declval<T>().cbegin()),
            decltype(std::declval<T>().cend())>,
        void>::type> : public std::true_type
{};
#endif
#include <bits/stdc++.h>
#define FORCE_INLINE __inline__ __attribute__((always_inline))
class IO
{
    static const int bufSize = 1 << 20;

    char inBuf[bufSize], outBuf[bufSize];
    char *ip1 = inBuf, *ip2 = inBuf;
    int goodReadBit = 1, op1 = -1, op2 = bufSize - 1;
    FORCE_INLINE int gc()
    {
        return ip1 == ip2
                && (ip2 = (ip1 = inBuf) + fread(inBuf, 1, bufSize, stdin),
                    ip1 == ip2)
            ? (goodReadBit = 0, EOF)
            : *ip1++;
    }
    template <typename T> FORCE_INLINE void __RI(T &x)
    {
        int ch = gc(), neg = 1;
        x = 0;
        for (; !(isdigit(ch) || ch == '-' || ch == EOF); ch = gc()) {}
        if (ch == EOF) return;
        if (ch == '-') neg = -1, ch = gc();
        for (; isdigit(ch); ch = gc()) x = x * 10 + (ch - 48) * neg;
    }
    template <typename T> FORCE_INLINE void __RC(T &x)
    {
        int ch;
        while (isspace(ch = gc())) {}
        if (ch == EOF) return;
        x = ch;
    }
    FORCE_INLINE void __RS(std::string &x)
    {
        char ch;
        x.clear();
        for (ch = gc(); isspace(ch); ch = gc()) {}
        if (ch == EOF) return;
        for (; !isspace(ch) && ch != EOF; ch = gc()) x.push_back(ch);
    }

public:
    FORCE_INLINE IO &R(char &x) { return __RC(x), (*this); }
    FORCE_INLINE IO &R(unsigned char &x) { return __RC(x), (*this); }
    FORCE_INLINE IO &R(std::string &x) { return __RS(x), (*this); }
    template <typename T1, typename T2> FORCE_INLINE IO &R(std::pair<T1, T2> &x)
    {
        return R(x.first), R(x.second), (*this);
    }
    template <typename T, typename... Args> FORCE_INLINE IO &RA(T *a, int n)
    {
        for (int i = 0; i < n; ++i) R(a[i]);
        return (*this);
    }
    template <typename T, typename... Args>
    FORCE_INLINE IO &R(T &x, Args &...args)
    {
        return R(x), R(args...), (*this);
    }
    template <typename T, typename... Args>
    FORCE_INLINE IO &RA(T *a, int n, Args... args)
    {
        for (int i = 0; i < n; ++i) RA(a[i], args...);
        return (*this);
    }
    template <typename T>
    FORCE_INLINE typename std::enable_if<std::is_integral<T>::value, IO>::type &
        R(T &x)
    {
        return __RI(x), (*this);
    }
    template <typename T>
    FORCE_INLINE typename std::enable_if<is_container<T>::value, IO>::type &R(
        T &x)
    {
        for (auto &i : x) R(i);
        return (*this);
    }
    template <typename T>
    FORCE_INLINE typename std::enable_if<
        std::is_void<std::void_t<decltype(std::declval<T>().read())>>::value,
        IO>::type &
        R(T &x)
    {
        return x.read(), (*this);
    }

private:
    char space = ' ';
    FORCE_INLINE void pc(const char &x)
    {
        if (op1 == op2) flush();
        outBuf[++op1] = x;
    }
    template <typename T> FORCE_INLINE void __WI(T x)
    {
        static char buf[sizeof(T) * 16 / 5];
        static int len = -1;
        if (x >= 0) {
            do {
                buf[++len] = x % 10 + 48, x /= 10;
            } while (x);
        } else {
            pc('-');
            do {
                buf[++len] = -(x % 10) + 48, x /= 10;
            } while (x);
        }
        while (len >= 0) { pc(buf[len]), --len; }
    }

public:
    FORCE_INLINE void flush() { fwrite(outBuf, 1, op1 + 1, stdout), op1 = -1; }
    FORCE_INLINE IO &W(const char &x) { return pc(x), (*this); }
    FORCE_INLINE IO &W(const char *x)
    {
        while (*x != '\0') pc(*(x++));
        return (*this);
    }
    FORCE_INLINE IO &W(const std::string &x) { return W(x.c_str()), (*this); }
    template <typename T1, typename T2>
    FORCE_INLINE IO &W(const std::pair<T1, T2> &x)
    {
        WS(x.first);
        W(x.second);
        return (*this);
    }
    FORCE_INLINE IO &WL() { return W('\n'), (*this); }
    template <typename T> FORCE_INLINE IO &WL(const T &x)
    {
        return W(x), W('\n'), (*this);
    }
    FORCE_INLINE IO &WS() { return W(space), (*this); }
    template <typename T> FORCE_INLINE IO &WS(const T &x)
    {
        return W(x), W(space), (*this);
    }
    template <typename T> FORCE_INLINE IO &WA(T *a, int n)
    {
        for (int i = 0; i < n; i++) WS(a[i]);
        WL();
        return (*this);
    }
    template <typename T, typename... Args>
    FORCE_INLINE IO &W(const T &x, const Args &...args)
    {
        W(x), W(space), W(args...);
        return (*this);
    }
    template <typename T, typename... Args>
    FORCE_INLINE IO &WS(const T &x, const Args &...args)
    {
        return W(x), W(space), W(args...), W(space), (*this);
    }
    template <typename... Args> FORCE_INLINE IO &WL(const Args &...args)
    {
        return W(args...), W('\n'), (*this);
    }
    template <typename T, typename... Args>
    FORCE_INLINE IO &WA(T *a, int n, Args... args)
    {
        for (int i = 0; i < n; i++) WA(a[i], args...);
        return (*this);
    }
    template <typename T>
    FORCE_INLINE typename std::enable_if<std::is_integral<T>::value, IO>::type &
        W(const T &x)
    {
        return __WI(x), (*this);
    }
    template <typename T>
    FORCE_INLINE typename std::enable_if<is_container<T>::value, IO>::type &W(
        const T &x)
    {

        for (auto &i : x) WS(i);
        WL();
        return (*this);
    }
    template <typename T>
    FORCE_INLINE typename std::enable_if<
        std::is_void<std::void_t<decltype(std::declval<T>().write())>>::value,
        IO>::type &
        W(const T &x)
    {
        return x.write(), (*this);
    }
    template <typename T> FORCE_INLINE IO &operator>>(T &x)
    {
        R(x);
        return (*this);
    }
    template <typename T> FORCE_INLINE IO &operator<<(const T &x)
    {
        W(x);
        return (*this);
    }
    int good() { return goodReadBit; }
    IO() {}
    ~IO() { flush(); }
} io;
#undef FORCE_INLINE

#ifndef UTIL_HPP
#define UTIL_HPP
#include <bits/stdc++.h>
#define var auto
#define ALL(x) x.begin(), x.end()
const std::int32_t INF = 0x3f3f3f3f;
const std::int64_t INFL = 0x3f3f3f3f3f3f3f3f;
#define If(x, y, z) ((x) ? (y) : (z))
#endif
#include "windows.h"
// https://www.zhihu.com/question/378525362/answer/1078276038;

constexpr unsigned int CreateSeed(
    const char *str, const unsigned int initial_result = 0)
{
    return *str == 0
        ? initial_result
        : CreateSeed(str + 1, ((initial_result << 8ULL) + *str) & UINT_MAX);
}

template <typename... RemainingStrings>
constexpr unsigned int CreateSeed(
    const char *first_str, const RemainingStrings &...remaining_strs)
{
    return CreateSeed(first_str, CreateSeed(remaining_strs...));
}

template <unsigned int Seed> struct Random
{
    static constexpr unsigned int value
        = (134775813ULL * Seed + 1ULL) & UINT_MAX;
    using next = Random<value>;
};
constexpr bool isPrime(int x)
{
    for (int i = 2; i * i <= x; i++)
        if (x % i == 0) return 0;
    return 1;
}
using namespace std;
constexpr unsigned int kSeed = CreateSeed(__TIME__, __DATE__);
constexpr int randomPrimeInCompileTime()
{
    int x = Random<kSeed>::value;
    x &= 0x3fffffff;
    if (x < int(1e8)) x += 1e8;
    while (!isPrime(x)) x++;
    return x;
}
int CodeforcesRandSeed()
{
    int x = GetCurrentProcessId();
    x ^= (int64_t)GetProcessHeap();
    x ^= (int64_t)HeapAlloc(GetProcessHeap(), 0, 1);
    auto dummy = new char;
    x ^= (int64_t)dummy;
    x ^= random_device{}();
    x ^= chrono::high_resolution_clock().now().time_since_epoch().count();
    return x;
}
mt19937_64 rng(CodeforcesRandSeed());
int randomPrime()
{
    int x = Random<kSeed>::value;
    x &= 0x3fffffff;
    if (x < int(1e8)) x += 1e8;
    while (!isPrime(x)) x++;
    return x;
}
vector<int> zAlgo(string s)
{
    int n = s.length();
    vector<int> z(n + 1);
    z[0] = n;
    int j = 0;
    for (int i = 1; i <= n;) {
        for (; i + j < n && s[i + j] == s[j]; j++)
            ;
        if (z[i] = j) {
            int k;
            for (k = 1; k + z[k] < z[i]; k++) z[i + k] = z[k];
            i += k;
            j -= k;
        } else
            i++;
    }
    return z;
}
const int Ps[] = { 257, 65537, 17 };
uniform_int_distribution<int> dis(0, sizeof(Ps) / sizeof(Ps[0]) - 1);
namespace Math
{
template <typename T, typename T2> T qpow(T a, T2 b, const int &MOD)
{
    T ans = 1;
    for (; b; b >>= 1) {
        if (b & 1) ans = (a * ans) % MOD;
        a = (a * a) % MOD;
    }
    return ans;
}
template <typename T> T exgcd(T l, T r, T &x, T &y)
{
    if (!r) {
        x = 1, y = 0;
        return l;
    } else {
        int d = exgcd(r, l % r, y, x);
        y -= l / r * x;
        return d;
    }
}
template <typename T> T inv(T a, const int &MOD)
{
    return qpow(a, MOD - 2, MOD);
}
template <typename T> T exinv(T a, const int &MOD)
{
    T x, y;
    exgcd(a, MOD, x, y);
    x %= MOD;
    return x + ((x >> (sizeof(T) * 8 - 1)) & MOD);
}
// Only Use Signed Integer
template <typename T, T MOD> struct ModInt
{
    T x;
    ModInt(T x = 0)
        : x(x)
    {
        while (x < 0) x += MOD;
    }
    ModInt<T, MOD> operator+=(const ModInt<T, MOD> &y)
    {
        x += y.x - MOD;
        x += (x >> (sizeof(T) * 8 - 1)) & MOD;
        return (*this);
    }
    ModInt<T, MOD> operator-=(const ModInt<T, MOD> &y)
    {
        x = x - y.x;
        x += (x >> (sizeof(T) * 8 - 1)) & MOD;
        return (*this);
    }
    ModInt<T, MOD> operator*=(const ModInt<T, MOD> &y)
    {
        x = x * y.x % MOD;
        return (*this);
    }
    ModInt<T, MOD> operator/=(const ModInt<T, MOD> &y)
    {
        x = x * inv(y.x, MOD) % MOD;
        return (*this);
    }
    ModInt<T, MOD> pow(int64_t p) { return x = qpow(x, p, MOD), *this; }
    void write() const { io.W(x); }
};
template <typename T, T MOD>
ModInt<T, MOD> operator+(ModInt<T, MOD> a, const ModInt<T, MOD> &b)
{
    a += b;
    return a;
}
template <typename T, T MOD>
ModInt<T, MOD> operator-(ModInt<T, MOD> a, const ModInt<T, MOD> &b)
{
    a -= b;
    return a;
}
template <typename T, T MOD>
ModInt<T, MOD> operator*(ModInt<T, MOD> a, const ModInt<T, MOD> &b)
{
    a *= b;
    return a;
}
template <typename T, T MOD>
ModInt<T, MOD> operator/(ModInt<T, MOD> a, const ModInt<T, MOD> &b)
{
    a /= b;
    return a;
}
template <typename T, T MOD>
bool operator==(const ModInt<T, MOD> &a, const ModInt<T, MOD> &b)
{
    return a.x == b.x;
}
}
const int MOD1 = randomPrimeInCompileTime(), MOD2 = randomPrime();
struct Hash2
{
    using mint = Math::ModInt<int64_t, MOD1>;
    using H = Hash2;
    mint h1;
    int64_t h2;
    Hash2(mint h1 = 0, int64_t h2 = 0)
        : h1(h1)
        , h2(h2)
    {}
    H &operator+=(const H &y)
    {
        h2 += y.h2 - MOD2;
        h2 += (h2 >> (sizeof(int64_t) * 8 - 1)) & MOD2;
        h1 += y.h1;
        return *this;
    }
    H &operator-=(const H &y)
    {
        h2 -= y.h2;
        h2 += (h2 >> (sizeof(int64_t) * 8 - 1)) & MOD2;
        h1 -= y.h1;
        return *this;
    }
    H &operator*=(const H &y)
    {
        h1 = h1 * y.h1;
        h2 = h2 * y.h2 % MOD2;
        return *this;
    }
};
Hash2 operator+(Hash2 a, const Hash2 &b)
{
    a += b;
    return a;
}
Hash2 operator-(Hash2 a, const Hash2 &b)
{
    a -= b;
    return a;
}
Hash2 operator*(Hash2 a, const Hash2 &b)
{
    a *= b;
    return a;
}
bool operator==(const Hash2 &a, const Hash2 &b)
{
    return a.h1 == b.h1 && a.h2 == b.h2;
}
struct RollingHash
{
    using H = Hash2;
    int n;
    vector<H> pw, hs;
    RollingHash(string s, int P1, int P2)
    {
        n = s.size();
        auto P = H(P1, P2);
        pw.resize(n + 1, H(0, 0));
        hs = pw;
        pw[0] = H(1, 1);
        for (int i = 1; i <= n; i++) pw[i] = pw[i - 1] * P;
        for (int i = 0; i < n; i++)
            hs[i + 1] = hs[i] * P + H(s[i] - '0', s[i] - '0');
    }
    H getHash(int l, int r) { return hs[r] - hs[l] * pw[r - l]; }
};

int main()
{
    string s, t;
    io >> s >> t;
    auto z = zAlgo(t + "$" + s);
    int P1 = 10, P2 = 10;
    auto hs = RollingHash(s, P1, P2);
    auto ht = RollingHash(t, P1, P2);
    int n = s.size(), m = t.size();
    auto want = ht.getHash(0, m);
    vector<int> lcp(n);
    for (int i = 0; i < n; i++) { lcp[i] = min(z[i + m + 1], m); }
    auto test = [&](int l1, int r1, int l2, int r2) {
        /* io.WL(l1 + 1, r1, l2 + 1, r2);
        io.WL(hs.getHash(l1, r1).h1, hs.getHash(l1, r1).h2);
        io.WL(hs.getHash(l2, r2).h1, hs.getHash(l2, r2).h2);
        io.WL(want.h1, want.h2); */
        if (hs.getHash(l1, r1) + hs.getHash(l2, r2) == want) {
            io.WL(l1 + 1, r1).WL(l2 + 1, r2);
            exit(0);
        }
    };
    auto check = [&](int l, int r, int k) {
        if (r > n) return;
        // io.WL(l, r, k);
        if (k > 0) {
            if (r + k <= n) test(l, r, r, r + k);
            if (l - k >= 0) test(l - k, l, l, r);
        }
    };
    for (int i = 0; i < n; i++) {
        {
            check(i, i + m, m - lcp[i]);
            check(i, i + m, m - lcp[i] - 1);
        }
        if (m > 1) {
            check(i, i + m - 1, m);
            check(i, i + m - 1, m - 1);
        }
    }
    return 0;
}