#include<iostream>
#include<iomanip>
#include<vector>
#include<algorithm>
#include<string>
#include<cmath>
#include<queue>
#include<map>
#include<set>
#include<climits>

#define pb push_back
#define rep(i, a, n) for(int (i)=a; (i)<(n); (i)++)
#define FOR(i, n) rep(i, 0, n)
#define F(n) FOR(i, n)
#define FF(n) FOR(j, n)
#define repi(i, a, n) for(int (i)=a; (i)<=(n); (i)++)
#define FORI(i, n) repi(i, 1, n)
#define FI(n) FORI(i, n)
#define FFI(n) FORI(j, n)
#define IN(x) int x; cin>>(x);
#define SIN(x) string x; cin>>(x);
#define INN(x, y) int x, y; cin>>(x)>>(y);
#define vi vector<int>
#define vll vector<ll>
#define pii pair<int, int>
#define vpii vector<pair<int, int> >
#define sortv(x) sort((x).begin(), (x).end())
#define sortvd(x) sort((x).begin(), (x).end(), greater<int>())
#define lboundv(x,v) lower_bound((x).begin(),(x).end(),(v))-(x).begin();
#define uboundv(x,v) upper_bound((x).begin(),(x).end(),(v))-(x).begin();
#define fi first
#define se second
#define mems(a, v) memset((a), (v), sizeof((a)))
#define mp make_pair
#define log(x) cout<<#x<<" : "<<x<<endl;
#define logp(x) cout<<#x<<" : ("<<x.fi<<", "<<x.se<<")"<<endl;
#define logai(a, i) cout<<#a<<'['<<i<<']'<<" : "<<a[i]<<endl;
#define loga(a, n) cout<<#a<<" -> "; F(n) cout<<i<<": "<<a[i]<<", "; cout<<endl;
#define logv(a) loga(a, a.size())
#define out(x) cout<<x<<endl
#define outp(x) cout<<x.fi<<' '<<x.se<<endl
#define outa(a, n) F(n) cout<<a[i]<<' '; cout<<endl;
#define outv(a) outa(a, a.size())
#define sim template<class t
typedef long long ll;
typedef long double LD;
sim> void maxi(t &x, t y) {if(x<y) x=y;}
sim> void mini(t &x, t y) {if(x>y) x=y;}
using namespace std;

#define N 300005

int n;
ll x[N], a[N], ps[N];

bool my_sq(ll x) {
    ll v = sqrt(x);
    return v*v==x;
}

bool solve(int i) {
    if(i>=n) return true;
    /* log(i); */
    ll v = ps[i-1];
    for(ll j=a[i-1]+1; j<=x[i+1]/2; j++) {
        /* log(j); */
        a[i] = j;
        ps[i] = j*j;
        ps[i+1] = ps[i]+x[i+1];
        /* log(ps[i]); */
        /* log(ps[i+1]); */
        if(!my_sq(ps[i+1])) continue;
        a[i+1] = sqrt(ps[i+1]);
        x[i] = ps[i]-ps[i-1];
        if(solve(i+2)) return true;
    }
    return false;
}

int main() {
	ios::sync_with_stdio(0);
    cin>>n;
    FI(n/2) cin>>x[2*i];
    if(solve(1)) {
        out("Yes");
        FI(n) cout<<x[i]<<' ';
    }
    else out("No");
	return 0;
}


#include<iostream>
#include<iomanip>
#include<vector>
#include<algorithm>
#include<string>
#include<cmath>
#include<queue>
#include<map>
#include<set>
#include<climits>

#define pb push_back
#define rep(i, a, n) for(int (i)=a; (i)<(n); (i)++)
#define FOR(i, n) rep(i, 0, n)
#define F(n) FOR(i, n)
#define FF(n) FOR(j, n)
#define repi(i, a, n) for(int (i)=a; (i)<=(n); (i)++)
#define FORI(i, n) repi(i, 1, n)
#define FI(n) FORI(i, n)
#define FFI(n) FORI(j, n)
#define IN(x) int x; cin>>(x);
#define SIN(x) string x; cin>>(x);
#define INN(x, y) int x, y; cin>>(x)>>(y);
#define vi vector<int>
#define vll vector<ll>
#define pii pair<int, int>
#define vpii vector<pair<int, int> >
#define sortv(x) sort((x).begin(), (x).end())
#define sortvd(x) sort((x).begin(), (x).end(), greater<int>())
#define lboundv(x,v) lower_bound((x).begin(),(x).end(),(v))-(x).begin();
#define uboundv(x,v) upper_bound((x).begin(),(x).end(),(v))-(x).begin();
#define fi first
#define se second
#define mems(a, v) memset((a), (v), sizeof((a)))
#define mp make_pair
#define log(x) cout<<#x<<" : "<<x<<endl;
#define logp(x) cout<<#x<<" : ("<<x.fi<<", "<<x.se<<")"<<endl;
#define logai(a, i) cout<<#a<<'['<<i<<']'<<" : "<<a[i]<<endl;
#define loga(a, n) cout<<#a<<" -> "; F(n) cout<<i<<": "<<a[i]<<", "; cout<<endl;
#define logv(a) loga(a, a.size())
#define out(x) cout<<x<<endl
#define outp(x) cout<<x.fi<<' '<<x.se<<endl
#define outa(a, n) F(n) cout<<a[i]<<' '; cout<<endl;
#define outv(a) outa(a, a.size())
#define sim template<class t
typedef long long ll;
typedef long double LD;
sim> void maxi(t &x, t y) {if(x<y) x=y;}
sim> void mini(t &x, t y) {if(x>y) x=y;}
using namespace std;

#define N 1000005

int n;
ll s[N];
ll dif[N], x[N], ps[N], mv[N];

bool sq(ll x) {
    ll v = sqrt(x);
    return v*v==x;
}

bool solve(int i) {
    /* cout<<"solve "<<i<<endl; */
    /* FFI(i) cout<<x[j]<<' '; cout<<endl; */
    if(i>n) return true;
    ll v = ps[i-1];
    /* log(v); */
    int in = lower_bound(s, s+N, v+1)-s;
    /* log(in); */
    /* log(s[in]); */
    while(in < N-1) {
        if(s[in+1]-s[in] > x[i+1]) return false;
        x[i] = s[in]-v;
        ps[i+1] = s[in]+x[i+1];
        if(sq(ps[i+1]))
        if(sq(ps[i+1]) && solve(i+2)) return true;
        in++;
    }
    return false;
}

int main() {
	ios::sync_with_stdio(0);
    FI(N-1) {
        dif[i] = 2*i-1;
        s[i] = (ll)i*i;
    }
    /* loga(s, 10); */
    /* log(lower_bound(s, s+N, 1ll)-s); */
    cin>>n;
    FI(n/2) {
        cin>>x[2*i];
    }
    FI(n/2) {
        int in = lower_bound(dif, dif+N, x[2*i])-dif;
        mv[2*i-1] = s[in+2];
    }
    if(solve(1)) {
        out("Yes");
        FI(n) cout<<x[i]<<' '; cout<<endl;
    }
    else out("No");
	return 0;
}


#include<iostream>
#include<iomanip>
#include<vector>
#include<algorithm>
#include<string>
#include<cmath>
#include<queue>
#include<map>
#include<set>
#include<climits>

#define pb push_back
#define rep(i, a, n) for(int (i)=a; (i)<(n); (i)++)
#define FOR(i, n) rep(i, 0, n)
#define F(n) FOR(i, n)
#define FF(n) FOR(j, n)
#define repi(i, a, n) for(int (i)=a; (i)<=(n); (i)++)
#define FORI(i, n) repi(i, 1, n)
#define FI(n) FORI(i, n)
#define FFI(n) FORI(j, n)
#define IN(x) int x; cin>>(x);
#define SIN(x) string x; cin>>(x);
#define INN(x, y) int x, y; cin>>(x)>>(y);
#define vi vector<int>
#define vll vector<ll>
#define pii pair<int, int>
#define vpii vector<pair<int, int> >
#define sortv(x) sort((x).begin(), (x).end())
#define sortvd(x) sort((x).begin(), (x).end(), greater<int>())
#define lboundv(x,v) lower_bound((x).begin(),(x).end(),(v))-(x).begin();
#define uboundv(x,v) upper_bound((x).begin(),(x).end(),(v))-(x).begin();
#define fi first
#define se second
#define mems(a, v) memset((a), (v), sizeof((a)))
#define mp make_pair
#define log(x) cout<<#x<<" : "<<x<<endl;
#define logp(x) cout<<#x<<" : ("<<x.fi<<", "<<x.se<<")"<<endl;
#define logai(a, i) cout<<#a<<'['<<i<<']'<<" : "<<a[i]<<endl;
#define loga(a, n) cout<<#a<<" -> "; F(n) cout<<i<<": "<<a[i]<<", "; cout<<endl;
#define logv(a) loga(a, a.size())
#define out(x) cout<<x<<endl
#define outp(x) cout<<x.fi<<' '<<x.se<<endl
#define outa(a, n) F(n) cout<<a[i]<<' '; cout<<endl;
#define outv(a) outa(a, a.size())
#define sim template<class t
typedef long long ll;
typedef long double LD;
sim> void maxi(t &x, t y) {if(x<y) x=y;}
sim> void mini(t &x, t y) {if(x>y) x=y;}
using namespace std;

#define N 300005

int n;
ll x[N], a[N], ps[N], mv[N];

bool my_sq(ll x) {
    ll v = sqrt(x);
    return v*v==x;
}

bool solve(int i) {
    if(i>=n) return true;
    /* log(i); */
    ll v = ps[i-1];
    for(ll j=a[i-1]+1; j<=x[i+1]/2; j++) {
        /* log(j); */
        a[i] = j;
        ps[i] = j*j;
        ps[i+1] = ps[i]+x[i+1];
        /* log(ps[i]); */
        /* log(ps[i+1]); */
        if(!my_sq(ps[i+1])) continue;
        a[i+1] = sqrt(ps[i+1]);
        x[i] = ps[i]-ps[i-1];
        if(solve(i+2)) return true;
    }
    return false;
}

int main() {
	ios::sync_with_stdio(0);
    cin>>n;
    FI(n/2) cin>>x[2*i];
    mv[n] = INT_MAX;
    for(int i=n-1; i; i--) {
        mv[i] = mv[i+1]-1;
        if(i&1) mini(mv[i], x[i+1]/2);
        if(mv[i] <= 0) {out("No"); return 0;}
        /* log(i); log(mv[i]); */
    }
    if(solve(1)) {
        out("Yes");
        FI(n) cout<<x[i]<<' ';
    }
    else out("No");
	return 0;
}


/******************************************************/
/******************************************************/
/**            BISMILLAHIR RAHMANIR RAHIM            **/
/**         Al-Shahriar Tonmoy - Red_Sparkle         **/
/**  Department of Computer Science and Engineering  **/
/**               Barisal University                 **/
/**               It's time to bloom.                **/
/******************************************************/
/******************************************************/

#include<bits/stdc++.h>
using namespace std;
#define     fRead           freopen("input.txt","r",stdin)
#define     fWrite          freopen("output.txt","w",stdout)
#define     fast            ios_base::sync_with_stdio(false);cin.tie(NULL)
#define     in1(X)          scanf("%lli",&(X))
#define     in2(X,Y)        scanf("%lli%lli",&(X),&(Y))
#define     in3(X,Y,Z)      scanf("%lli%lli%lli",&(X),&(Y),&(Z))
#define     ins(S)          scanf("%s",(S))
#define     out(X)          printf("%lli",(X))
#define     outs(S)         printf("%s",(S))
#define     printnl         printf("\n");
#define     End             return 0
#define     ll              long long int
#define     ul              unsigned long long int
#define     dob             double
#define     st              string
#define     pairl           pair<ll,ll>
#define     max3(a,b,c)     max(a,max(b,c))
#define     min3(a,b,c)     min(a,min(b,c))
#define     fr              first
#define     se              second
#define     T               true
#define     F               false
#define     nl              "\n"
#define     all(v)          v.begin(),v.end()
#define     mem(a,v)        memset(a,v,sizeof(a))
#define     maxi            1000000000000014
#define     mini            -100000000000014
#define     mod             998244353
#define     an              1000007
#define     mapi            map<ll,ll>
#define     pi              push_back
#define     po              pop_back
#define     ve              vector<ll>
#define     mp              make_pair

/*************** #Template FUNCTIONS# **************/

/// ll pc;void PrintCase(){printf("Case #%lli: ",++pc);}
/// ll GCD(ll a,ll b){if(a<b)swap(a,b);if(b==1) return 1;if(!b) return a;if(!(a%b)) return b;else return GCD(b,a%b);}
/// ll LCM(ll a,ll b){return (a*b)/GCD(a,b);}
/// ll bigmod(ll n,ll p){if(p==0) return 1;if(p==1)return (n+mod)%mod;if(p%2)return (bigmod(n,p-1)*n+mod)%mod;else{ll x=bigmod(n,p/2);return (x*x+mod)%mod;}}
/// ll modinverse(ll n){return bigmod(n,mod-2)%mod;}
/// bool sc[an];ve pr;void sieve(){for(ll i=2;i*i<an;i++){if(!sc[i]){for(ll j=i*i;j<an;j+=i) sc[j]=1;}}pr.pi(2);for(ll i=3;i<an;i+=2) if(!sc[i]) pr.pi(i);}
/// pairl pf[an];void pri_fact(ll n){ll i,u=0;for(i=0;i<pr.size() && n!=1;i++){ll c=0;while(!(n%pr[i])){n/=pr[i];c++;} if(c){pf[u].fr=pr[i];pf[u].se=c;u++;}}if(n>1){pf[u].fr=n;pf[u].se=1;}}
/// ve de;void devisors(ll n){ll i;for(i=1;i<=sqrt(n);i++){if(!(n%i) && i!=sqrt(n)){de.pi(i);de.pi(n%i);}}if((i-1)*(i-1)==n) de.pi(i-1);sort(all(de));}

/********************** START **********************/

int main()
{

    ll n,i,k=0,x,y,s=0;
    cin>>n;

    ll a[n+1];
    for(i=1;i<=n/2;i++){
        cin>>a[i];
    }

    ve ans;
    for(i=1;i<=n/2;i++){
        while(1){
            x=(k*k)+a[i]+s;
            y=sqrt(x);
            if(y*y==x) break;
            k++;
            if(k>1000){
                cout<<"No"<<endl;
                End;
            }
        }
        ll p=k*k;
        k=y;
        s+=(p+a[i]);
        ans.pi(p);
        ans.pi(a[i]);
    }
    cout<<"Yes"<<endl;
    for(i=0;i<n;i++) cout<<ans[i]<<" ";

    End;
}
/*****************  ALHAMDULILLAH  *****************/


/******************************************************/
/******************************************************/
/**            BISMILLAHIR RAHMANIR RAHIM            **/
/**         Al-Shahriar Tonmoy - Red_Sparkle         **/
/**  Department of Computer Science and Engineering  **/
/**               Barisal University                 **/
/**               It's time to bloom.                **/
/******************************************************/
/******************************************************/

#include<bits/stdc++.h>
using namespace std;
#define     fRead           freopen("input.txt","r",stdin)
#define     fWrite          freopen("output.txt","w",stdout)
#define     fast            ios_base::sync_with_stdio(false);cin.tie(NULL)
#define     in1(X)          scanf("%lli",&(X))
#define     in2(X,Y)        scanf("%lli%lli",&(X),&(Y))
#define     in3(X,Y,Z)      scanf("%lli%lli%lli",&(X),&(Y),&(Z))
#define     ins(S)          scanf("%s",(S))
#define     out(X)          printf("%lli",(X))
#define     outs(S)         printf("%s",(S))
#define     printnl         printf("\n");
#define     End             return 0
#define     ll              long long int
#define     ul              unsigned long long int
#define     dob             double
#define     st              string
#define     pairl           pair<ll,ll>
#define     max3(a,b,c)     max(a,max(b,c))
#define     min3(a,b,c)     min(a,min(b,c))
#define     fr              first
#define     se              second
#define     T               true
#define     F               false
#define     nl              "\n"
#define     all(v)          v.begin(),v.end()
#define     mem(a,v)        memset(a,v,sizeof(a))
#define     maxi            1000000000000014
#define     mini            -100000000000014
#define     mod             998244353
#define     an              1000007
#define     mapi            map<ll,ll>
#define     pi              push_back
#define     po              pop_back
#define     ve              vector<ll>
#define     mp              make_pair

/*************** #Template FUNCTIONS# **************/

/// ll pc;void PrintCase(){printf("Case #%lli: ",++pc);}
/// ll GCD(ll a,ll b){if(a<b)swap(a,b);if(b==1) return 1;if(!b) return a;if(!(a%b)) return b;else return GCD(b,a%b);}
/// ll LCM(ll a,ll b){return (a*b)/GCD(a,b);}
/// ll bigmod(ll n,ll p){if(p==0) return 1;if(p==1)return (n+mod)%mod;if(p%2)return (bigmod(n,p-1)*n+mod)%mod;else{ll x=bigmod(n,p/2);return (x*x+mod)%mod;}}
/// ll modinverse(ll n){return bigmod(n,mod-2)%mod;}
/// bool sc[an];ve pr;void sieve(){for(ll i=2;i*i<an;i++){if(!sc[i]){for(ll j=i*i;j<an;j+=i) sc[j]=1;}}pr.pi(2);for(ll i=3;i<an;i+=2) if(!sc[i]) pr.pi(i);}
/// pairl pf[an];void pri_fact(ll n){ll i,u=0;for(i=0;i<pr.size() && n!=1;i++){ll c=0;while(!(n%pr[i])){n/=pr[i];c++;} if(c){pf[u].fr=pr[i];pf[u].se=c;u++;}}if(n>1){pf[u].fr=n;pf[u].se=1;}}
/// ve de;void devisors(ll n){ll i;for(i=1;i<=sqrt(n);i++){if(!(n%i) && i!=sqrt(n)){de.pi(i);de.pi(n%i);}}if((i-1)*(i-1)==n) de.pi(i-1);sort(all(de));}

/********************** START **********************/

int main()
{

    ll n,i,k=0,x,y,s=0;
    cin>>n;

    ll a[n+1];
    for(i=1;i<=n/2;i++){
        cin>>a[i];
    }

    ve ans;
    for(i=1;i<=n/2;i++){
        while(1){
            x=(k*k)+a[i]+s;
            y=sqrt(x);
            if(y*y==x) break;
            k++;
            if(k>1000){
                cout<<"No"<<endl;
                End;
            }
        }
        ll p=(k*k)-s;
        k=y;
        s+=(p+a[i]);
        ans.pi(p);
        ans.pi(a[i]);
    }
    cout<<"Yes"<<endl;
    for(i=0;i<n;i++) cout<<ans[i]<<" ";

    End;
}
/*****************  ALHAMDULILLAH  *****************/


/******************************************************/
/******************************************************/
/**            BISMILLAHIR RAHMANIR RAHIM            **/
/**         Al-Shahriar Tonmoy - Red_Sparkle         **/
/**  Department of Computer Science and Engineering  **/
/**               Barisal University                 **/
/**               It's time to bloom.                **/
/******************************************************/
/******************************************************/

#include<bits/stdc++.h>
using namespace std;
#define     fRead           freopen("input.txt","r",stdin)
#define     fWrite          freopen("output.txt","w",stdout)
#define     fast            ios_base::sync_with_stdio(false);cin.tie(NULL)
#define     in1(X)          scanf("%lli",&(X))
#define     in2(X,Y)        scanf("%lli%lli",&(X),&(Y))
#define     in3(X,Y,Z)      scanf("%lli%lli%lli",&(X),&(Y),&(Z))
#define     ins(S)          scanf("%s",(S))
#define     out(X)          printf("%lli",(X))
#define     outs(S)         printf("%s",(S))
#define     printnl         printf("\n");
#define     End             return 0
#define     ll              long long int
#define     ul              unsigned long long int
#define     dob             double
#define     st              string
#define     pairl           pair<ll,ll>
#define     max3(a,b,c)     max(a,max(b,c))
#define     min3(a,b,c)     min(a,min(b,c))
#define     fr              first
#define     se              second
#define     T               true
#define     F               false
#define     nl              "\n"
#define     all(v)          v.begin(),v.end()
#define     mem(a,v)        memset(a,v,sizeof(a))
#define     maxi            1000000000000014
#define     mini            -100000000000014
#define     mod             998244353
#define     an              1000007
#define     mapi            map<ll,ll>
#define     pi              push_back
#define     po              pop_back
#define     ve              vector<ll>
#define     mp              make_pair

/*************** #Template FUNCTIONS# **************/

/// ll pc;void PrintCase(){printf("Case #%lli: ",++pc);}
/// ll GCD(ll a,ll b){if(a<b)swap(a,b);if(b==1) return 1;if(!b) return a;if(!(a%b)) return b;else return GCD(b,a%b);}
/// ll LCM(ll a,ll b){return (a*b)/GCD(a,b);}
/// ll bigmod(ll n,ll p){if(p==0) return 1;if(p==1)return (n+mod)%mod;if(p%2)return (bigmod(n,p-1)*n+mod)%mod;else{ll x=bigmod(n,p/2);return (x*x+mod)%mod;}}
/// ll modinverse(ll n){return bigmod(n,mod-2)%mod;}
/// bool sc[an];ve pr;void sieve(){for(ll i=2;i*i<an;i++){if(!sc[i]){for(ll j=i*i;j<an;j+=i) sc[j]=1;}}pr.pi(2);for(ll i=3;i<an;i+=2) if(!sc[i]) pr.pi(i);}
/// pairl pf[an];void pri_fact(ll n){ll i,u=0;for(i=0;i<pr.size() && n!=1;i++){ll c=0;while(!(n%pr[i])){n/=pr[i];c++;} if(c){pf[u].fr=pr[i];pf[u].se=c;u++;}}if(n>1){pf[u].fr=n;pf[u].se=1;}}
/// ve de;void devisors(ll n){ll i;for(i=1;i<=sqrt(n);i++){if(!(n%i) && i!=sqrt(n)){de.pi(i);de.pi(n%i);}}if((i-1)*(i-1)==n) de.pi(i-1);sort(all(de));}

/********************** START **********************/

int main()
{
    fast;

    ll n,i,k=1,x,y,s=0;
    cin>>n;

    ll a[n+1];
    for(i=1;i<=n/2;i++){
        cin>>a[i];
    }

    ve ans;
    for(i=1;i<=n/2;i++){
        while(1){
            x=(k*k)+a[i];
            y=sqrt(x);
            if(y*y==x) break;
            k++;
            if(k>3162277){
                cout<<"No"<<endl;
                End;
            }
        }
        ll p=(k*k)-s;
        s+=(p+a[i]);
        k=sqrt(s);
        ans.pi(p);
        ans.pi(a[i]);
    }
    cout<<"Yes"<<endl;
    for(i=0;i<n;i++) cout<<ans[i]<<" ";

    End;
}
/*****************  ALHAMDULILLAH  *****************/


/******************************************************/
/******************************************************/
/**            BISMILLAHIR RAHMANIR RAHIM            **/
/**         Al-Shahriar Tonmoy - Red_Sparkle         **/
/**  Department of Computer Science and Engineering  **/
/**               Barisal University                 **/
/**               It's time to bloom.                **/
/******************************************************/
/******************************************************/

#include<bits/stdc++.h>
using namespace std;
#define     fRead           freopen("input.txt","r",stdin)
#define     fWrite          freopen("output.txt","w",stdout)
#define     fast            ios_base::sync_with_stdio(false);cin.tie(NULL)
#define     in1(X)          scanf("%lli",&(X))
#define     in2(X,Y)        scanf("%lli%lli",&(X),&(Y))
#define     in3(X,Y,Z)      scanf("%lli%lli%lli",&(X),&(Y),&(Z))
#define     ins(S)          scanf("%s",(S))
#define     out(X)          printf("%lli",(X))
#define     outs(S)         printf("%s",(S))
#define     printnl         printf("\n");
#define     End             return 0
#define     ll              long long int
#define     ul              unsigned long long int
#define     dob             double
#define     st              string
#define     pairl           pair<ll,ll>
#define     max3(a,b,c)     max(a,max(b,c))
#define     min3(a,b,c)     min(a,min(b,c))
#define     fr              first
#define     se              second
#define     T               true
#define     F               false
#define     nl              "\n"
#define     all(v)          v.begin(),v.end()
#define     mem(a,v)        memset(a,v,sizeof(a))
#define     maxi            1000000000000014
#define     mini            -100000000000014
#define     mod             998244353
#define     an              1000007
#define     mapi            map<ll,ll>
#define     pi              push_back
#define     po              pop_back
#define     ve              vector<ll>
#define     mp              make_pair

/*************** #Template FUNCTIONS# **************/

/// ll pc;void PrintCase(){printf("Case #%lli: ",++pc);}
/// ll GCD(ll a,ll b){if(a<b)swap(a,b);if(b==1) return 1;if(!b) return a;if(!(a%b)) return b;else return GCD(b,a%b);}
/// ll LCM(ll a,ll b){return (a*b)/GCD(a,b);}
/// ll bigmod(ll n,ll p){if(p==0) return 1;if(p==1)return (n+mod)%mod;if(p%2)return (bigmod(n,p-1)*n+mod)%mod;else{ll x=bigmod(n,p/2);return (x*x+mod)%mod;}}
/// ll modinverse(ll n){return bigmod(n,mod-2)%mod;}
/// bool sc[an];ve pr;void sieve(){for(ll i=2;i*i<an;i++){if(!sc[i]){for(ll j=i*i;j<an;j+=i) sc[j]=1;}}pr.pi(2);for(ll i=3;i<an;i+=2) if(!sc[i]) pr.pi(i);}
/// pairl pf[an];void pri_fact(ll n){ll i,u=0;for(i=0;i<pr.size() && n!=1;i++){ll c=0;while(!(n%pr[i])){n/=pr[i];c++;} if(c){pf[u].fr=pr[i];pf[u].se=c;u++;}}if(n>1){pf[u].fr=n;pf[u].se=1;}}
/// ve de;void devisors(ll n){ll i;for(i=1;i<=sqrt(n);i++){if(!(n%i) && i!=sqrt(n)){de.pi(i);de.pi(n%i);}}if((i-1)*(i-1)==n) de.pi(i-1);sort(all(de));}

/********************** START **********************/

int main()
{

    ll n,i,k=1,x,y,s=0;
    cin>>n;

    ll a[n+1];
    for(i=1;i<=n/2;i++){
        cin>>a[i];
    }

    ve ans;
    for(i=1;i<=n/2;i++){
        while(1){
            x=(k*k)+a[i];
            y=sqrt(x);
            if(y*y==x) break;
            k++;
            if(k>1000){
                cout<<"No"<<endl;
                End;
            }
        }
        ll p=(k*k)-s;
        s+=(p+a[i]);
        k=sqrt(s);
        ans.pi(p);
        ans.pi(a[i]);
    }
    cout<<"Yes"<<endl;
    for(i=0;i<n;i++) cout<<ans[i]<<" ";

    End;
}
/*****************  ALHAMDULILLAH  *****************/


/******************************************************/
/******************************************************/
/**            BISMILLAHIR RAHMANIR RAHIM            **/
/**         Al-Shahriar Tonmoy - Red_Sparkle         **/
/**  Department of Computer Science and Engineering  **/
/**               Barisal University                 **/
/**               It's time to bloom.                **/
/******************************************************/
/******************************************************/

#include<bits/stdc++.h>
using namespace std;
#define     fRead           freopen("input.txt","r",stdin)
#define     fWrite          freopen("output.txt","w",stdout)
#define     fast            ios_base::sync_with_stdio(false);cin.tie(NULL)
#define     in1(X)          scanf("%lli",&(X))
#define     in2(X,Y)        scanf("%lli%lli",&(X),&(Y))
#define     in3(X,Y,Z)      scanf("%lli%lli%lli",&(X),&(Y),&(Z))
#define     ins(S)          scanf("%s",(S))
#define     out(X)          printf("%lli",(X))
#define     outs(S)         printf("%s",(S))
#define     printnl         printf("\n");
#define     End             return 0
#define     ll              long long int
#define     ul              unsigned long long int
#define     dob             double
#define     st              string
#define     pairl           pair<ll,ll>
#define     max3(a,b,c)     max(a,max(b,c))
#define     min3(a,b,c)     min(a,min(b,c))
#define     fr              first
#define     se              second
#define     T               true
#define     F               false
#define     nl              "\n"
#define     all(v)          v.begin(),v.end()
#define     mem(a,v)        memset(a,v,sizeof(a))
#define     maxi            1000000000000014
#define     mini            -100000000000014
#define     mod             998244353
#define     an              1000007
#define     mapi            map<ll,ll>
#define     pi              push_back
#define     po              pop_back
#define     ve              vector<ll>
#define     mp              make_pair

/*************** #Template FUNCTIONS# **************/

/// ll pc;void PrintCase(){printf("Case #%lli: ",++pc);}
/// ll GCD(ll a,ll b){if(a<b)swap(a,b);if(b==1) return 1;if(!b) return a;if(!(a%b)) return b;else return GCD(b,a%b);}
/// ll LCM(ll a,ll b){return (a*b)/GCD(a,b);}
/// ll bigmod(ll n,ll p){if(p==0) return 1;if(p==1)return (n+mod)%mod;if(p%2)return (bigmod(n,p-1)*n+mod)%mod;else{ll x=bigmod(n,p/2);return (x*x+mod)%mod;}}
/// ll modinverse(ll n){return bigmod(n,mod-2)%mod;}
/// bool sc[an];ve pr;void sieve(){for(ll i=2;i*i<an;i++){if(!sc[i]){for(ll j=i*i;j<an;j+=i) sc[j]=1;}}pr.pi(2);for(ll i=3;i<an;i+=2) if(!sc[i]) pr.pi(i);}
/// pairl pf[an];void pri_fact(ll n){ll i,u=0;for(i=0;i<pr.size() && n!=1;i++){ll c=0;while(!(n%pr[i])){n/=pr[i];c++;} if(c){pf[u].fr=pr[i];pf[u].se=c;u++;}}if(n>1){pf[u].fr=n;pf[u].se=1;}}
/// ve de;void devisors(ll n){ll i;for(i=1;i<=sqrt(n);i++){if(!(n%i) && i!=sqrt(n)){de.pi(i);de.pi(n%i);}}if((i-1)*(i-1)==n) de.pi(i-1);sort(all(de));}

/********************** START **********************/

int main()
{

    ll n,i,k=0,x,y,s=0;
    cin>>n;

    ll a[n+1];
    for(i=1;i<=n/2;i++){
        cin>>a[i];
    }

    ve ans;
    for(i=1;i<=n/2;i++){
        while(1){
            x=(k*k)+a[i];
            y=sqrt(x);
            if(y*y==x) break;
            k++;
            if(k>1000){
                cout<<"No"<<endl;
                End;
            }
        }
        ll p=(k*k)-s;
        s+=(p+a[i]);
        k=sqrt(s);
        ans.pi(p);
        ans.pi(a[i]);
    }
    cout<<"Yes"<<endl;
    for(i=0;i<n;i++) cout<<ans[i]<<" ";

    End;
}
/*****************  ALHAMDULILLAH  *****************/


// 1
#include <bits/stdc++.h>
using namespace std;
#define int long long int
#define ld long double
#define pb push_back
#define MOD 1000000007
#define mod1 1187278649
#define mod2 1149736019
#define ioi cout<<"\n------------ioi------------\n"
#define all(x) (x).begin(),(x).end()
#define sz(x) (int)(x).size()

const ld PI=3.14159265358979323;
const int linf=1000111000111000111LL;
const int inf=1011111111;
const int N=200005;

// v1[i] -> stores the different pairs of numbers a,b(b>a) such that b*b-a*a = i;
vector < pair <int,int> > v1[N];

int32_t main()
{
    #ifndef ONLINE_JUDGE
        freopen("inputf.txt", "r", stdin);
        freopen("outputf.txt", "w", stdout);
    #endif

    ios::sync_with_stdio(false);
    cin.tie(0);
    cout.tie(0);
    int test=1;
    // cin>>test;
    while(test--){
        int n;
        cin>>n;
        int arr[n/2];
        for(int i=0;i<n/2;i++)
            cin>>arr[i];
        for(int i=1;i<N;i++){
            // condition when difference between squares of two consecutive numbers will exceed N
            if(2*i+1>N)
                break;
            for(int j=i+1;(j*j-i*i)<=N;j++)
                if((j*j-i*i)<N)
                    v1[j*j-i*i].pb({i,j});
        }
        // for(int i=1;i<=100;i++){
        //     for(int j=0;j<sz(v1[i]);j++)
        //         cout<<v1[i][j].first<<" "<<v1[i][j].second<<"       ";
        //     cout<<endl;
        // }
        int prev=0;
        vector <int> ans;
        ans.pb(0);
        bool ok1=true;
        for(int i=0;i<n/2;i++){
            bool ok=false;
            for(int j=0;j<sz(v1[arr[i]]);j++){
                if(v1[arr[i]][j].first>prev){
                    ans.pb(v1[arr[i]][j].first*v1[arr[i]][j].first);
                    ans.pb(v1[arr[i]][j].second*v1[arr[i]][j].second);
                    ok=true;
                    prev=v1[arr[i]][j].second;
                    break;
                }
            }
            if(!ok){
                ok1=false;
                break;
            }
        }
        if(!ok1)
            cout<<"No\n";
        else{
            cout<<"Yes\n";
            for(int i=1;i<sz(ans);i++)
                cout<<ans[i]-ans[i-1]<<" ";
            cout<<"\n";
        }
    }
    cerr<< '\n' << "Time elapsed :" << clock() * 1000.0 / CLOCKS_PER_SEC << " ms\n" ;
}


#include <bits/stdc++.h>
using namespace std;

// #include <ext/pb_ds/assoc_container.hpp>
// #include <ext/pb_ds/tree_policy.hpp>
// using namespace __gnu_pbds;

#define int long long int
#define ld long double
#define pb push_back
#define mp make_pair
#define MOD 1000000007
#define mod1 1187278649
#define mod2 1149736019
#define ioi cout<<"\n------------ioi------------\n"
#define all(x) (x).begin(),(x).end()
#define sz(x) (int)(x).size()
// #define ordered_set tree<int, null_type,less<int>, rb_tree_tag,tree_order_statistics_node_update>

const ld PI=3.14159265358979323;
const int linf=1000111000111000111LL;
const int inf=1011111111;
const int N=1000005;

int32_t main()
{
    ios::sync_with_stdio(false);
    cin.tie(0);
    cout.tie(0);
    int test=1;
    // cin>>test;
    while(test--){
        int n;
        cin>>n;
        int arr[n/2];
        for(int i=0;i<n/2;i++)
            cin>>arr[i];
        vector <int> v1;
        for(int i=1;i<=5000;i++)
            v1.pb(i*i);
        // map to store the occurence of diff values
        // Ex-> diff = 15 occurs between 49 - 64
        // it also occurs between 1 - 16
        map < int , vector <int> > mp1;
        for(int i=0;i<5000;i++){
            for(int j=i;j<5000;j++){
                if((v1[j]-v1[i])>0)
                    mp1[v1[j]-v1[i]].pb(v1[i]);
            }
        }
        vector <int> v2; // It stores the answer.
        v2.pb(0);
        int prev=0; // initializing it to 0 and will be updated at every step.
        bool ok=true; // condition check variable.
        for(int i=0;i<n/2;i++){
            // if the diff is not found then we have no answer.
            if(mp1.find(arr[i])==mp1.end()){
                ok=false;
                break;
            }
            // p1 finds the next possible value for number such that difference matches our requirement.
            int p1=lower_bound(all(mp1[arr[i]]), prev)-mp1[arr[i]].begin();
            // If we do not get the number within the array then again we have no answer.
            if(p1==sz(mp1[arr[i]])){
                ok=false;
                break;
            }
            v2.pb(mp1[arr[i]][p1]);
            v2.pb(mp1[arr[i]][p1]+arr[i]);
            prev=mp1[arr[i]][p1]+arr[i]; // updating prev variable.
        }
        if(!ok)
            cout<<"No\n";
        else{
            cout<<"Yes\n";
            for(int i=1;i<sz(v2);i++)
                cout<<v2[i]-v2[i-1]<<" ";

        }
    }
    cerr<< '\n' << "Time elapsed :" << clock() * 1000.0 / CLOCKS_PER_SEC << " ms\n" ;
}


#include <bits/stdc++.h>
using namespace std;

// #include <ext/pb_ds/assoc_container.hpp>
// #include <ext/pb_ds/tree_policy.hpp>
// using namespace __gnu_pbds;

#define int long long int
#define ld long double
#define pb push_back
#define mp make_pair
#define MOD 1000000007
#define mod1 1187278649
#define mod2 1149736019
#define ioi cout<<"\n------------ioi------------\n"
#define all(x) (x).begin(),(x).end()
#define sz(x) (int)(x).size()
// #define ordered_set tree<int, null_type,less<int>, rb_tree_tag,tree_order_statistics_node_update>

const ld PI=3.14159265358979323;
const int linf=1000111000111000111LL;
const int inf=1011111111;
const int N=1000005;

int32_t main()
{
    ios::sync_with_stdio(false);
    cin.tie(0);
    cout.tie(0);
    int test=1;
    // cin>>test;
    while(test--){
        int n;
        cin>>n;
        int arr[n/2];
        for(int i=0;i<n/2;i++)
            cin>>arr[i];
        vector <int> v1;
        for(int i=1;i<=1000;i++)
            v1.pb(i*i);
        // map to store the occurence of diff values
        // Ex-> diff = 15 occurs between 49 - 64
        // it also occurs between 1 - 16
        map < int , vector <int> > mp1;
        for(int i=0;i<5000;i++){
            for(int j=i;j<5000;j++){
                if((v1[j]-v1[i])>0)
                    mp1[v1[j]-v1[i]].pb(v1[i]);
            }
        }
        vector <int> v2; // It stores the answer.
        v2.pb(0);
        int prev=0; // initializing it to 0 and will be updated at every step.
        bool ok=true; // condition check variable.
        for(int i=0;i<n/2;i++){
            // if the diff is not found then we have no answer.
            if(mp1.find(arr[i])==mp1.end()){
                ok=false;
                break;
            }
            // p1 finds the next possible value for number such that difference matches our requirement.
            int p1=lower_bound(all(mp1[arr[i]]), prev)-mp1[arr[i]].begin();
            // If we do not get the number within the array then again we have no answer.
            if(p1==sz(mp1[arr[i]])){
                ok=false;
                break;
            }
            v2.pb(mp1[arr[i]][p1]);
            v2.pb(mp1[arr[i]][p1]+arr[i]);
            prev=mp1[arr[i]][p1]+arr[i]; // updating prev variable.
        }
        if(!ok)
            cout<<"No\n";
        else{
            cout<<"Yes\n";
            for(int i=1;i<sz(v2);i++)
                cout<<v2[i]-v2[i-1]<<" ";

        }
    }
    cerr<< '\n' << "Time elapsed :" << clock() * 1000.0 / CLOCKS_PER_SEC << " ms\n" ;
}


#include <bits/stdc++.h>
using namespace std;

// #include <ext/pb_ds/assoc_container.hpp>
// #include <ext/pb_ds/tree_policy.hpp>
// using namespace __gnu_pbds;

#define int long long int
#define ld long double
#define pb push_back
#define mp make_pair
#define MOD 1000000007
#define mod1 1187278649
#define mod2 1149736019
#define ioi cout<<"\n------------ioi------------\n"
#define all(x) (x).begin(),(x).end()
#define sz(x) (int)(x).size()
// #define ordered_set tree<int, null_type,less<int>, rb_tree_tag,tree_order_statistics_node_update>

const ld PI=3.14159265358979323;
const int linf=1000111000111000111LL;
const int inf=1011111111;
const int N=1000005;

int32_t main()
{
    ios::sync_with_stdio(false);
    cin.tie(0);
    cout.tie(0);
    int test=1;
    // cin>>test;
    while(test--){
        int n;
        cin>>n;
        int arr[n/2];
        for(int i=0;i<n/2;i++)
            cin>>arr[i];
        vector <int> v1;
        for(int i=1;i<=1000;i++)
            v1.pb(i*i);
        // map to store the occurence of diff values
        // Ex-> diff = 15 occurs between 49 - 64
        // it also occurs between 1 - 16
        map < int , vector <int> > mp1;
        for(int i=0;i<1000;i++){
            for(int j=i;j<1000;j++){
                if((v1[j]-v1[i])>0)
                    mp1[v1[j]-v1[i]].pb(v1[i]);
            }
        }
        vector <int> v2; // It stores the answer.
        v2.pb(0);
        int prev=0; // initializing it to 0 and will be updated at every step.
        bool ok=true; // condition check variable.
        for(int i=0;i<n/2;i++){
            // if the diff is not found then we have no answer.
            if(mp1.find(arr[i])==mp1.end()){
                ok=false;
                break;
            }
            // p1 finds the next possible value for number such that difference matches our requirement.
            int p1=lower_bound(all(mp1[arr[i]]), prev)-mp1[arr[i]].begin();
            // If we do not get the number within the array then again we have no answer.
            if(p1==sz(mp1[arr[i]])){
                ok=false;
                break;
            }
            v2.pb(mp1[arr[i]][p1]);
            v2.pb(mp1[arr[i]][p1]+arr[i]);
            prev=mp1[arr[i]][p1]+arr[i]; // updating prev variable.
        }
        if(!ok)
            cout<<"No\n";
        else{
            cout<<"Yes\n";
            for(int i=1;i<sz(v2);i++)
                cout<<v2[i]-v2[i-1]<<" ";

        }
    }
    cerr<< '\n' << "Time elapsed :" << clock() * 1000.0 / CLOCKS_PER_SEC << " ms\n" ;
}


// 1
#include <bits/stdc++.h>
using namespace std;
#define int long long int
#define ld long double
#define pb push_back
#define MOD 1000000007
#define mod1 1187278649
#define mod2 1149736019
#define ioi cout<<"\n------------ioi------------\n"
#define all(x) (x).begin(),(x).end()
#define sz(x) (int)(x).size()

const ld PI=3.14159265358979323;
const int linf=1000111000111000111LL;
const int inf=1011111111;
const int N=200005;

// v1[i] -> stores the different pairs of numbers a,b(b>a) such that b*b-a*a = i;
vector < pair <int,int> > v1[N];

int32_t main()
{
    #ifndef ONLINE_JUDGE
        freopen("inputf.txt", "r", stdin);
        freopen("outputf.txt", "w", stdout);
    #endif

    ios::sync_with_stdio(false);
    cin.tie(0);
    cout.tie(0);
    int test=1;
    // cin>>test;
    while(test--){
        int n;
        cin>>n;
        int arr[n/2];
        for(int i=0;i<n/2;i++)
            cin>>arr[i];
        for(int i=1;i<N;i++){
            // condition when difference between squares of two consecutive numbers will exceed N
            if(2*i+1>N)
                break;
            for(int j=i+1;(j*j-i*i)<=N;j++)
                v1[j*j-i*i].pb({i,j});
        }
        // for(int i=1;i<=100;i++){
        //     for(int j=0;j<sz(v1[i]);j++)
        //         cout<<v1[i][j].first<<" "<<v1[i][j].second<<"       ";
        //     cout<<endl;
        // }
        int prev=0;
        vector <int> ans;
        ans.pb(0);
        bool ok1=true;
        for(int i=0;i<n/2;i++){
            bool ok=false;
            for(int j=0;j<sz(v1[arr[i]]);j++){
                if(v1[arr[i]][j].first>prev){
                    ans.pb(v1[arr[i]][j].first*v1[arr[i]][j].first);
                    ans.pb(v1[arr[i]][j].second*v1[arr[i]][j].second);
                    ok=true;
                    prev=v1[arr[i]][j].second;
                    break;
                }
            }
            if(!ok){
                ok1=false;
                break;
            }
        }
        if(!ok1)
            cout<<"No\n";
        else{
            cout<<"Yes\n";
            for(int i=1;i<sz(ans);i++)
                cout<<ans[i]-ans[i-1]<<" ";
            cout<<"\n";
        }
    }
    cerr<< '\n' << "Time elapsed :" << clock() * 1000.0 / CLOCKS_PER_SEC << " ms\n" ;
}


#include <bits/stdc++.h>
using namespace std;

// #include <ext/pb_ds/assoc_container.hpp>
// #include <ext/pb_ds/tree_policy.hpp>
// using namespace __gnu_pbds;

#define int long long int
#define ld long double
#define pb push_back
#define mp make_pair
#define MOD 1000000007
#define mod1 1187278649
#define mod2 1149736019
#define ioi cout<<"\n------------ioi------------\n"
#define all(x) (x).begin(),(x).end()
#define sz(x) (int)(x).size()
// #define ordered_set tree<int, null_type,less<int>, rb_tree_tag,tree_order_statistics_node_update>

const ld PI=3.14159265358979323;
const int linf=1000111000111000111LL;
const int inf=1011111111;
const int N=1000005;

int32_t main()
{
    ios::sync_with_stdio(false);
    cin.tie(0);
    cout.tie(0);
    int test=1;
    // cin>>test;
    while(test--){
        int n;
        cin>>n;
        int arr[n/2];
        for(int i=0;i<n/2;i++)
            cin>>arr[i];
        vector <int> v1;
        for(int i=1;i<=3000;i++)
            v1.pb(i*i);
        // map to store the occurence of diff values
        // Ex-> diff = 15 occurs between 49 - 64
        // it also occurs between 1 - 16
        map < int , vector <int> > mp1;
        for(int i=0;i<3000;i++){
            for(int j=i;j<3000;j++){
                if((v1[j]-v1[i])>0)
                    mp1[v1[j]-v1[i]].pb(v1[i]);
            }
        }
        vector <int> v2; // It stores the answer.
        v2.pb(0);
        int prev=0; // initializing it to 0 and will be updated at every step.
        bool ok=true; // condition check variable.
        for(int i=0;i<n/2;i++){
            // if the diff is not found then we have no answer.
            if(mp1.find(arr[i])==mp1.end()){
                ok=false;
                break;
            }
            // p1 finds the next possible value for number such that difference matches our requirement.
            int p1=lower_bound(all(mp1[arr[i]]), prev)-mp1[arr[i]].begin();
            // If we do not get the number within the array then again we have no answer.
            if(p1==sz(mp1[arr[i]])){
                ok=false;
                break;
            }
            v2.pb(mp1[arr[i]][p1]);
            v2.pb(mp1[arr[i]][p1]+arr[i]);
            prev=mp1[arr[i]][p1]+arr[i]; // updating prev variable.
        }
        if(!ok)
            cout<<"No\n";
        else{
            cout<<"Yes\n";
            for(int i=1;i<sz(v2);i++)
                cout<<v2[i]-v2[i-1]<<" ";

        }
    }
    cerr<< '\n' << "Time elapsed :" << clock() * 1000.0 / CLOCKS_PER_SEC << " ms\n" ;
}


#include <cstdio>
#include <cstring>
#include <algorithm>
#include <cmath>
typedef long long ll;

template<typename T>inline void read(T &x) {
	x=0;char c=getchar();
	while(c<'0'||c>'9')c=getchar();
	while(c>='0'&&c<='9')x=(x<<1)+(x<<3)+(c^48), c=getchar();
}

const int N = (int)1e5+5;
const long long max=(ll)1e13;
ll n, a[N], sum;

int main() {
#ifndef ONLINE_JUDGE
	freopen("e.in", "r", stdin);
#endif
	read(n);
	for(int i=1;i<=n>>1;i++) {
		read(a[i<<1]);
		bool flag=false;
		ll x=a[i<<1], s, t;
		ll k=1ll*(int)sqrt(x);
		for(ll j=k;j>=1;--j)
			if(x%j==0) {
				s=j, t=x/j;
				if((s+t)&1) continue;
				flag=true;
				ll a1=1ll*(s+t)/2, a2=1ll*(t-s)/2;
				a1*=a1, a2*=a2;
				if(a2<=sum) continue;
				a[i*2-1]=a2-sum;
				if(a[i*2-1]<=0||a[i*2]||a[i*2]!=a1-a2||a[i*2-1]>max||a[i*2]>max) {
					puts("No");
					return 0;
				}
				sum+=a[i*2-1]+a[i*2];
				break;
			}
		if(!flag) {
			puts("No");
			return 0;
		}
	}
	puts("Yes");
	for(int i=1;i<=n;i++) printf("%lld ", a[i]);
	puts("");
	return 0;
}


#include <cstdio>
#include <cstring>
#include <algorithm>
#include <cmath>
typedef long long ll;

template<typename T>inline void read(T &x) {
	x=0;char c=getchar();
	while(c<'0'||c>'9')c=getchar();
	while(c>='0'&&c<='9')x=(x<<1)+(x<<3)+(c^48), c=getchar();
}

const int N = (int)1e5+5;
ll n, a[N], sum;

int main() {
#ifndef ONLINE_JUDGE
	freopen("e.in", "r", stdin);
#endif
	read(n);
	for(int i=1;i<=n>>1;i++) {
		read(a[i<<1]);
		bool flag=false;
		ll x=a[i<<1], s, t;
		ll k=1ll*(int)sqrt(x);
		for(ll j=k;j>=1;--j)
			if(x%j==0) {
				s=j, t=x/j;
				if((s+t)&1) continue;
				flag=true;
				break;
			}
		ll a1=1ll*(s+t)/2, a2=1ll*(t-s)/2;
		a1*=a1, a2*=a2;
		a[i*2-1]=a2-sum;
		if(a[i*2-1]<=0||a[i*2]!=a1-a2) {
			puts("No");
			return 0;
		}
		sum+=a[i*2-1]+a[i*2];
	}
	puts("Yes");
	for(int i=1;i<=n;i++) printf("%lld ", a[i]);
	puts("");
	return 0;
}


#include <cstdio>
#include <cstring>
#include <algorithm>
#include <cmath>
typedef long long ll;

template<typename T>inline void read(T &x) {
	x=0;char c=getchar();
	while(c<'0'||c>'9')c=getchar();
	while(c>='0'&&c<='9')x=(x<<1)+(x<<3)+(c^48), c=getchar();
}

const int N = (int)1e5+5;
const long long max=(ll)1e13;
ll n, a[N], sum;

int main() {
#ifndef ONLINE_JUDGE
	freopen("e.in", "r", stdin);
#endif
	read(n);
	for(int i=1;i<=n>>1;i++) {
		read(a[i<<1]);
		bool flag=false;
		ll x=a[i<<1], s, t;
		ll k=1ll*(int)sqrt(x);
		for(ll j=k;j>=1;--j)
			if(x%j==0) {
				s=j, t=x/j;
				if((s+t)&1) continue;
				flag=true;
				ll a1=1ll*(s+t)/2, a2=1ll*(t-s)/2;
				a1*=a1, a2*=a2;
				if(a2<=last) continue;
				a[i*2-1]=a2-sum;
				if(a[i*2-1]<=0||a[i*2]!=a1-a2||a[i*2-1]>max||a[i*2]>max) {
					puts("No");
					return 0;
				}
				sum+=a[i*2-1]+a[i*2];
				break;
			}
		if(!flag) {
			puts("No");
			return 0;
		}
	}
	puts("Yes");
	for(int i=1;i<=n;i++) printf("%lld ", a[i]);
	puts("");
	return 0;
}


#include <cstdio>
#include <cstring>
#include <algorithm>
#include <cmath>
typedef long long ll;

template<typename T>inline void read(T &x) {
	x=0;char c=getchar();
	while(c<'0'||c>'9')c=getchar();
	while(c>='0'&&c<='9')x=(x<<1)+(x<<3)+(c^48), c=getchar();
}

const int N = (int)1e5+5;
const long long max=(ll)1e13;
ll n, a[N], sum;

int main() {
#ifndef ONLINE_JUDGE
	freopen("e.in", "r", stdin);
#endif
	read(n);
	for(int i=1;i<=n>>1;i++) {
		read(a[i<<1]);
		bool flag=false;
		ll x=a[i<<1], s, t;
		ll k=1ll*(int)sqrt(x);
		for(ll j=k;j>=1;--j)
			if(x%j==0) {
				s=j, t=x/j;
				if((s+t)&1) continue;
				flag=true;
				ll a1=1ll*(s+t)/2, a2=1ll*(t-s)/2;
				a1*=a1, a2*=a2;
				if(a2<=sum) continue;
				a[i*2-1]=a2-sum;
				if(a[i*2-1]<=0||a[i*2]!=a1-a2||a[i*2-1]>max||a[i*2]>max) {
					puts("No");
					return 0;
				}
				sum+=a[i*2-1]+a[i*2];
				break;
			}
		if(!flag) {
			puts("No");
			return 0;
		}
	}
	puts("Yes");
	for(int i=1;i<=n;i++) printf("%lld ", a[i]);
	puts("");
	return 0;
}


#include <cstdio>
#include <cstring>
#include <algorithm>
#include <cmath>
typedef long long ll;

template<typename T>inline void read(T &x) {
	x=0;char c=getchar();
	while(c<'0'||c>'9')c=getchar();
	while(c>='0'&&c<='9')x=(x<<1)+(x<<3)+(c^48), c=getchar();
}

const int N = (int)1e5+5;
const long long max=(ll)1e13;
ll n, a[N], sum;

int main() {
#ifndef ONLINE_JUDGE
	freopen("e.in", "r", stdin);
#endif
	read(n);
	for(int i=1;i<=n>>1;i++) {
		read(a[i<<1]);
		bool flag=false;
		ll x=a[i<<1], s, t;
		ll k=1ll*(int)sqrt(x);
		for(ll j=k;j>=1;--j)
			if(x%j==0) {
				s=j, t=x/j;
				if((s+t)&1) continue;
				ll a1=1ll*(s+t)/2, a2=1ll*(t-s)/2;
				a1*=a1, a2*=a2;
				if(a2<=sum) continue;
				a[i*2-1]=a2-sum;
				if(a[i*2-1]<=0||a[i*2]<=0||a[i*2]!=a1-a2||a[i*2-1]>max||a[i*2]>max)
					continue;
				sum=a1;
				flag=true;
				break;
			}
		if(!flag) {
			puts("No");
			return 0;
		}
	}
	puts("Yes");
	for(int i=1;i<=n;i++) printf("%lld ", a[i]);
	puts("");
	return 0;
}


#include <cstdio>
#include <cstring>
#include <algorithm>
#include <cmath>
typedef long long ll;

template<typename T>inline void read(T &x) {
	x=0;char c=getchar();
	while(c<'0'||c>'9')c=getchar();
	while(c>='0'&&c<='9')x=(x<<1)+(x<<3)+(c^48), c=getchar();
}

const int N = (int)1e5+5;
const long long max=(ll)1e13;
ll n, a[N], sum;

int main() {
#ifndef ONLINE_JUDGE
	freopen("e.in", "r", stdin);
#endif
	read(n);
	for(int i=1;i<=n>>1;i++) {
		read(a[i<<1]);
		bool flag=false;
		ll x=a[i<<1], s, t;
		ll k=1ll*(int)sqrt(x);
		for(ll j=k;j>=1;--j)
			if(x%j==0) {
				s=j, t=x/j;
				if((s+t)&1) continue;
				flag=true;
				break;
			}
		if(flag) {
			puts("No");
			return 0;
		}
		ll a1=1ll*(s+t)/2, a2=1ll*(t-s)/2;
		a1*=a1, a2*=a2;
		a[i*2-1]=a2-sum;
		if(a[i*2-1]<=0||a[i*2]!=a1-a2||a[i*2-1]>max||a[i*2]>max) {
			puts("No");
			return 0;
		}
		sum+=a[i*2-1]+a[i*2];
	}
	puts("Yes");
	for(int i=1;i<=n;i++) printf("%lld ", a[i]);
	puts("");
	return 0;
}


#include <vector>
#include <set>
#include <map>
#include <queue>
#include <stack>
#include <deque>
#include <bitset>

#include <iostream>
#include <algorithm>
#include <cmath>
#include <chrono>
#include <iterator>
#include <iomanip>
#include <random>
#include <numeric>

// #include <bits/stdc++.h>
// #include <ext/pb_ds/tree_policy.hpp>
// #include <ext/pb_ds/assoc_container.hpp>

using namespace std;
// using namespace __gnu_pbds;

typedef int int2;
#define int long long

typedef long long ll;
typedef long double ld;
typedef pair<int, int> pi;
typedef pair<ll,ll> pl;
typedef pair<double,double> pd;
typedef priority_queue<int, vector<int>, greater<int> > min_heap;

// template <class T> using Tree = tree<T, null_type, less<T>, rb_tree_tag,tree_order_statistics_node_update>;

#define mp make_pair
#define pb push_back
#define f first
#define s second
#define lb lower_bound
#define ub upper_bound
#define all(x) x.begin(), x.end()

mt19937 mt_rand(chrono::high_resolution_clock::now().time_since_epoch().count());

const double PI = 4*atan(1);
const ll INF = 1e18;
const int MX = 100001;

const int maxn = 1e5 + 5;
int t;
int a[maxn], upper[maxn], lower[maxn];
int n;

int compute(int l, int r) {
    int num_elements = (r - l) / 2 + 1;
    int mid_elt = (l + r) / 2;
    return mid_elt * num_elements;
}

int2 main() {
    ios::sync_with_stdio(0);
    cin.tie(0);
    // freopen("A.in", "r", stdin);
    // freopen("A.out", "w", stdout);
    cin >> n;
    for (int i = 2; i <= n; i += 2) {
        cin >> a[i];
        if (a[i] % 4 == 2) {
            cout << "No\n";
            return 0;
        }
    }
    if (a[n] % 2 == 0) {
        upper[n] = (a[n] + 2) / 2;
        lower[n] = (a[n] - 2) / 2;
    } else {
        upper[n] = lower[n] = a[n];
    }
    upper[0] = lower[0] = -1;
    for (int i = n - 2; i >= 2; i -= 2) {
        int elt = a[i];
        bool done = false;
        for (int j = elt % 2; j <= sqrt(elt); j += 2) {
            if (elt % j == 0) {
                int mid_elt = elt / j;
                int last_elt = mid_elt + (j / 2) * 2;
                int first_elt = mid_elt - ((j - 1) / 2) * 2;
                if (first_elt >= 1 and last_elt < lower[i + 2]) {
                    lower[i] = first_elt;
                    upper[i] = last_elt;
                    done = true;
                    break;
                }
                if (first_elt < 1) {
                    break;
                }
            }
        }
        if (!done) {
            cout << "No\n";
            return 0;
        }
    }
    if (lower[2] == 1) {
        cout << "No\n";
        return 0;
    }
    // for (int i = 2; i <= n; i += 2) {
    //     cout << "i: " << i << ", lower: " << lower[i] << ", upper: " << upper[i] << "\n";
    // }
    cout << "Yes\n";
    for (int i = 2; i <= n; i += 2) {
        int s1 = compute(upper[i - 2] + 2, lower[i] - 2);
        int s2 = compute(lower[i], upper[i]);
        cout << s1 << " " << s2 << " ";
    }
    cout << "\n";
}

/*
    Potential bugs:
    - Not resetting the arrays properly
    - Out of bounds
*/


#include <vector>
#include <set>
#include <map>
#include <queue>
#include <stack>
#include <deque>
#include <bitset>

#include <iostream>
#include <algorithm>
#include <cmath>
#include <chrono>
#include <iterator>
#include <iomanip>
#include <random>
#include <numeric>

// #include <bits/stdc++.h>
// #include <ext/pb_ds/tree_policy.hpp>
// #include <ext/pb_ds/assoc_container.hpp>

using namespace std;
// using namespace __gnu_pbds;

typedef int int2;
#define int long long

typedef long long ll;
typedef long double ld;
typedef pair<int, int> pi;
typedef pair<ll,ll> pl;
typedef pair<double,double> pd;
typedef priority_queue<int, vector<int>, greater<int> > min_heap;

// template <class T> using Tree = tree<T, null_type, less<T>, rb_tree_tag,tree_order_statistics_node_update>;

#define mp make_pair
#define pb push_back
#define f first
#define s second
#define lb lower_bound
#define ub upper_bound
#define all(x) x.begin(), x.end()

mt19937 mt_rand(chrono::high_resolution_clock::now().time_since_epoch().count());

const double PI = 4*atan(1);
const ll INF = 1e18;
const int MX = 100001;

const int maxn = 2e5 + 5;
int t;
int a[maxn], upper[maxn], lower[maxn];
int n;

int compute(int l, int r) {
    int num_elements = (r - l) / 2 + 1;
    int mid_elt = (l + r) / 2;
    return mid_elt * num_elements;
}

int2 main() {
    ios::sync_with_stdio(0);
    cin.tie(0);
    // freopen("A.in", "r", stdin);
    // freopen("A.out", "w", stdout);
    cin >> n;
    for (int i = 2; i <= n; i += 2) {
        cin >> a[i];
        if (a[i] % 4 == 2) {
            cout << "No\n";
            return 0;
        }
    }
    if (a[n] % 2 == 0) {
        upper[n] = (a[n] + 2) / 2;
        lower[n] = (a[n] - 2) / 2;
    } else {
        upper[n] = lower[n] = a[n];
    }
    upper[0] = lower[0] = -1;
    for (int i = n - 2; i >= 2; i -= 2) {
        int elt = a[i];
        bool done = false;
        for (int j = elt % 2; j <= sqrt(elt); j += 2) {
            if (elt % j == 0) {
                int mid_elt = elt / j;
                int last_elt = mid_elt + (j / 2) * 2;
                int first_elt = mid_elt - ((j - 1) / 2) * 2;
                if (first_elt >= 1 and last_elt < lower[i + 2]) {
                    lower[i] = first_elt;
                    upper[i] = last_elt;
                    done = true;
                    break;
                }
                if (first_elt < 1) {
                    break;
                }
            }
        }
        if (!done) {
            cout << "No\n";
            return 0;
        }
    }
    if (lower[2] == 1) {
        cout << "No\n";
        return 0;
    }
    // for (int i = 2; i <= n; i += 2) {
    //     cout << "i: " << i << ", lower: " << lower[i] << ", upper: " << upper[i] << "\n";
    // }
    cout << "Yes\n";
    for (int i = 2; i <= n; i += 2) {
        int s1 = compute(upper[i - 2] + 2, lower[i] - 2);
        int s2 = compute(lower[i], upper[i]);
        cout << s1 << " " << s2 << " ";
    }
    cout << "\n";
}

/*
    Potential bugs:
    - Not resetting the arrays properly
    - Out of bounds
*/


#include <vector>
#include <set>
#include <map>
#include <queue>
#include <stack>
#include <deque>
#include <bitset>

#include <iostream>
#include <algorithm>
#include <cmath>
#include <chrono>
#include <iterator>
#include <iomanip>
#include <random>
#include <numeric>

// #include <bits/stdc++.h>
// #include <ext/pb_ds/tree_policy.hpp>
// #include <ext/pb_ds/assoc_container.hpp>

using namespace std;
// using namespace __gnu_pbds;

typedef int int2;
#define int long long

typedef long long ll;
typedef long double ld;
typedef pair<int, int> pi;
typedef pair<ll,ll> pl;
typedef pair<double,double> pd;
typedef priority_queue<int, vector<int>, greater<int> > min_heap;

// template <class T> using Tree = tree<T, null_type, less<T>, rb_tree_tag,tree_order_statistics_node_update>;

#define mp make_pair
#define pb push_back
#define f first
#define s second
#define lb lower_bound
#define ub upper_bound
#define all(x) x.begin(), x.end()

mt19937 mt_rand(chrono::high_resolution_clock::now().time_since_epoch().count());

const double PI = 4*atan(1);
const ll INF = 1e18;
const int MX = 100001;

const int maxn = 1e5 + 5;
int t;
int a[maxn], upper[maxn], lower[maxn];
int n;

int compute(int l, int r) {
    int num_elements = (r - l) / 2 + 1;
    int mid_elt = (l + r) / 2;
    return mid_elt * num_elements;
}

int2 main() {
    ios::sync_with_stdio(0);
    cin.tie(0);
    // freopen("A.in", "r", stdin);
    // freopen("A.out", "w", stdout);
    cin >> n;
    for (int i = 2; i <= n; i += 2) {
        cin >> a[i];
        if (a[i] % 4 == 2) {
            cout << "No\n";
            return 0;
        }
    }
    if (a[n] % 2 == 0) {
        upper[n] = (a[n] + 2) / 2;
        lower[n] = (a[n] - 2) / 2;
    } else {
        upper[n] = lower[n] = a[n];
    }
    upper[0] = lower[0] = -1;
    for (int i = n - 2; i >= 2; i -= 2) {
        int elt = a[i];
        bool done = false;
        for (int j = elt % 2; j <= (int)sqrt(elt); j += 2) {
            if (j == 0) continue;
            if (elt % j == 0) {
                int mid_elt = elt / j;
                int last_elt = mid_elt + (j / 2) * 2;
                int first_elt = mid_elt - ((j - 1) / 2) * 2;
                if (last_elt % 2 == 0) continue;
                if (first_elt > 1 and last_elt < lower[i + 2]) {
                    lower[i] = first_elt;
                    upper[i] = last_elt;
                    done = true;
                    break;
                }
                if (first_elt <= 1) {
                    break;
                }
            }
        }
        if (!done) {
            cout << "No\n";
            return 0;
        }
    }
    if (lower[2] == 1) {
        cout << "No\n";
        return 0;
    }
    // for (int i = 2; i <= n; i += 2) {
    //     cout << "i: " << i << ", lower: " << lower[i] << ", upper: " << upper[i] << "\n";
    }
    cout << "Yes\n";
    for (int i = 2; i <= n; i += 2) {
        int s1 = compute(upper[i - 2] + 2, lower[i] - 2);
        int s2 = compute(lower[i], upper[i]);
        cout << s1 << " " << s2 << " ";
    }
    cout << "\n";
}

/*
    Potential bugs:
    - Not resetting the arrays properly
    - Out of bounds
*/


#include <vector>
#include <set>
#include <map>
#include <queue>
#include <stack>
#include <deque>
#include <bitset>

#include <iostream>
#include <algorithm>
#include <cmath>
#include <chrono>
#include <iterator>
#include <iomanip>
#include <random>
#include <numeric>

// #include <bits/stdc++.h>
// #include <ext/pb_ds/tree_policy.hpp>
// #include <ext/pb_ds/assoc_container.hpp>

using namespace std;
// using namespace __gnu_pbds;

typedef int int2;
#define int long long

typedef long long ll;
typedef long double ld;
typedef pair<int, int> pi;
typedef pair<ll,ll> pl;
typedef pair<double,double> pd;
typedef priority_queue<int, vector<int>, greater<int> > min_heap;

// template <class T> using Tree = tree<T, null_type, less<T>, rb_tree_tag,tree_order_statistics_node_update>;

#define mp make_pair
#define pb push_back
#define f first
#define s second
#define lb lower_bound
#define ub upper_bound
#define all(x) x.begin(), x.end()

mt19937 mt_rand(chrono::high_resolution_clock::now().time_since_epoch().count());

const double PI = 4*atan(1);
const ll INF = 1e18;
const int MX = 100001;

const int maxn = 1e5 + 5;
int t;
int a[maxn], upper[maxn], lower[maxn];
int n;

int compute(int l, int r) {
    int num_elements = (r - l) / 2 + 1;
    int mid_elt = (l + r) / 2;
    return mid_elt * num_elements;
}

int2 main() {
    ios::sync_with_stdio(0);
    cin.tie(0);
    // freopen("A.in", "r", stdin);
    // freopen("A.out", "w", stdout);
    cin >> n;
    for (int i = 2; i <= n; i += 2) {
        cin >> a[i];
        if (a[i] % 4 == 2) {
            cout << "No\n";
            return 0;
        }
    }
    if (a[n] % 2 == 0) {
        upper[n] = (a[n] + 2) / 2;
        lower[n] = (a[n] - 2) / 2;
    } else {
        upper[n] = lower[n] = a[n];
    }
    upper[0] = lower[0] = -1;
    for (int i = n - 2; i >= 2; i -= 2) {
        int elt = a[i];
        bool done = false;
        for (int j = elt % 2; j <= (int)sqrt(elt); j += 2) {
            if (j == 0) continue;
            if (elt % j == 0) {
                int mid_elt = elt / j;
                if (mid_elt % 2 == 0) mid_elt--;
                int last_elt = mid_elt + (j / 2) * 2;
                int first_elt = mid_elt - ((j - 1) / 2) * 2;
                if (first_elt > 1 and last_elt < lower[i + 2]) {
                    lower[i] = first_elt;
                    upper[i] = last_elt;
                    done = true;
                    break;
                }
                if (first_elt <= 1) {
                    // cout << "i: " << i << "elt: " << elt << ", next lower: " << lower[i + 2] << ", first_elt: " << first_elt << "\n";
                    break;
                }
            }
        }
        // cout << "processing " << i << ": " << elt << "\n";
        // cout << "lower: "<< lower[i] << ", upper: " << upper[i] << "\n";
        if (!done) {
            cout << "No\n";
            return 0;
        }
    }
    if (lower[2] == 1) {
        cout << "No\n";
        return 0;
    }
    // for (int i = 2; i <= n; i += 2) {
    //     cout << "i: " << i << ", lower: " << lower[i] << ", upper: " << upper[i] << "\n";
    // }
    cout << "Yes\n";
    for (int i = 2; i <= n; i += 2) {
        int s1 = compute(upper[i - 2] + 2, lower[i] - 2);
        int s2 = compute(lower[i], upper[i]);
        cout << s1 << " " << s2 << " ";
    }
    cout << "\n";
}

/*
    Potential bugs:
    - Not resetting the arrays properly
    - Out of bounds
*/


#include <vector>
#include <set>
#include <map>
#include <queue>
#include <stack>
#include <deque>
#include <bitset>

#include <iostream>
#include <algorithm>
#include <cmath>
#include <chrono>
#include <iterator>
#include <iomanip>
#include <random>
#include <numeric>

// #include <bits/stdc++.h>
// #include <ext/pb_ds/tree_policy.hpp>
// #include <ext/pb_ds/assoc_container.hpp>

using namespace std;
// using namespace __gnu_pbds;

typedef int int2;
#define int long long

typedef long long ll;
typedef long double ld;
typedef pair<int, int> pi;
typedef pair<ll,ll> pl;
typedef pair<double,double> pd;
typedef priority_queue<int, vector<int>, greater<int> > min_heap;

// template <class T> using Tree = tree<T, null_type, less<T>, rb_tree_tag,tree_order_statistics_node_update>;

#define mp make_pair
#define pb push_back
#define f first
#define s second
#define lb lower_bound
#define ub upper_bound
#define all(x) x.begin(), x.end()

mt19937 mt_rand(chrono::high_resolution_clock::now().time_since_epoch().count());

const double PI = 4*atan(1);
const ll INF = 1e18;
const int MX = 100001;

const int maxn = 2e5 + 5;
int t;
int a[maxn], upper[maxn], lower[maxn];
int n;

int compute(int l, int r) {
    int num_elements = (r - l) / 2 + 1;
    int mid_elt = (l + r) / 2;
    return mid_elt * num_elements;
}

int2 main() {
    ios::sync_with_stdio(0);
    cin.tie(0);
    // freopen("A.in", "r", stdin);
    // freopen("A.out", "w", stdout);
    cin >> n;
    for (int i = 2; i <= n; i += 2) {
        cin >> a[i];
        if (a[i] % 4 == 2) {
            cout << "No\n";
            return 0;
        }
    }
    if (a[n] % 2 == 0) {
        upper[n] = (a[n] + 2) / 2;
        lower[n] = (a[n] - 2) / 2;
    } else {
        upper[n] = lower[n] = a[n];
    }
    upper[0] = lower[0] = -1;
    for (int i = n - 2; i >= 2; i -= 2) {
        int elt = a[i];
        bool done = false;
        for (int j = elt % 2; j <= (int)sqrt(elt); j += 2) {
            if (elt % j == 0) {
                int mid_elt = elt / j;
                int last_elt = mid_elt + (j / 2) * 2;
                int first_elt = mid_elt - ((j - 1) / 2) * 2;
                if (first_elt > 1 and last_elt < lower[i + 2]) {
                    lower[i] = first_elt;
                    upper[i] = last_elt;
                    done = true;
                    break;
                }
                if (first_elt <= 1) {
                    break;
                }
            }
        }
        if (!done) {
            cout << "No\n";
            return 0;
        }
    }
    if (lower[2] == 1) {
        cout << "No\n";
        return 0;
    }
    // for (int i = 2; i <= n; i += 2) {
    //     cout << "i: " << i << ", lower: " << lower[i] << ", upper: " << upper[i] << "\n";
    // }
    cout << "Yes\n";
    for (int i = 2; i <= n; i += 2) {
        int s1 = compute(upper[i - 2] + 2, lower[i] - 2);
        int s2 = compute(lower[i], upper[i]);
        cout << s1 << " " << s2 << " ";
    }
    cout << "\n";
}

/*
    Potential bugs:
    - Not resetting the arrays properly
    - Out of bounds
*/


#include <vector>
#include <set>
#include <map>
#include <queue>
#include <stack>
#include <deque>
#include <bitset>

#include <iostream>
#include <algorithm>
#include <cmath>
#include <chrono>
#include <iterator>
#include <iomanip>
#include <random>
#include <numeric>

// #include <bits/stdc++.h>
// #include <ext/pb_ds/tree_policy.hpp>
// #include <ext/pb_ds/assoc_container.hpp>

using namespace std;
// using namespace __gnu_pbds;

typedef int int2;
#define int long long

typedef long long ll;
typedef long double ld;
typedef pair<int, int> pi;
typedef pair<ll,ll> pl;
typedef pair<double,double> pd;
typedef priority_queue<int, vector<int>, greater<int> > min_heap;

// template <class T> using Tree = tree<T, null_type, less<T>, rb_tree_tag,tree_order_statistics_node_update>;

#define mp make_pair
#define pb push_back
#define f first
#define s second
#define lb lower_bound
#define ub upper_bound
#define all(x) x.begin(), x.end()

mt19937 mt_rand(chrono::high_resolution_clock::now().time_since_epoch().count());

const double PI = 4*atan(1);
const ll INF = 1e18;
const int MX = 100001;

const int maxn = 1e5 + 5;
int t;
int a[maxn], upper[maxn], lower[maxn];
int n;

int compute(int l, int r) {
    int num_elements = (r - l) / 2 + 1;
    int mid_elt = (l + r) / 2;
    return mid_elt * num_elements;
}

int2 main() {
    ios::sync_with_stdio(0);
    cin.tie(0);
    // freopen("A.in", "r", stdin);
    // freopen("A.out", "w", stdout);
    cin >> n;
    for (int i = 2; i <= n; i += 2) {
        cin >> a[i];
        if (a[i] % 4 == 2) {
            cout << "No\n";
            return 0;
        }
    }
    if (a[n] % 2 == 0) {
        upper[n] = (a[n] + 2) / 2;
        lower[n] = (a[n] - 2) / 2;
    } else {
        upper[n] = lower[n] = a[n];
    }
    upper[0] = lower[0] = -1;
    for (int i = n - 2; i >= 2; i -= 2) {
        int elt = a[i];
        bool done = false;
        for (int j = elt % 2; j <= (int)sqrt(elt); j += 2) {
            if (j == 0) continue;
            if (elt % j == 0) {
                int mid_elt = elt / j;
                if (mid_elt % 2 == 1 and elt % 2 == 0) continue;
                int last_elt = mid_elt + (j / 2) * 2;
                int first_elt = mid_elt - ((j - 1) / 2) * 2;
                if (first_elt > 1 and last_elt < lower[i + 2]) {
                    lower[i] = first_elt;
                    upper[i] = last_elt;
                    done = true;
                    break;
                }
                if (first_elt <= 1) {
                    break;
                }
            }
        }
        if (!done) {
            cout << "No\n";
            return 0;
        }
    }
    if (lower[2] == 1) {
        cout << "No\n";
        return 0;
    }
    // for (int i = 2; i <= n; i += 2) {
    //     cout << "i: " << i << ", lower: " << lower[i] << ", upper: " << upper[i] << "\n";
    // }
    cout << "Yes\n";
    for (int i = 2; i <= n; i += 2) {
        int s1 = compute(upper[i - 2] + 2, lower[i] - 2);
        int s2 = compute(lower[i], upper[i]);
        cout << s1 << " " << s2 << " ";
    }
    cout << "\n";
}

/*
    Potential bugs:
    - Not resetting the arrays properly
    - Out of bounds
*/


#include <vector>
#include <set>
#include <map>
#include <queue>
#include <stack>
#include <deque>
#include <bitset>

#include <iostream>
#include <algorithm>
#include <cmath>
#include <chrono>
#include <iterator>
#include <iomanip>
#include <random>
#include <numeric>

// #include <bits/stdc++.h>
// #include <ext/pb_ds/tree_policy.hpp>
// #include <ext/pb_ds/assoc_container.hpp>

using namespace std;
// using namespace __gnu_pbds;

typedef int int2;
#define int long long

typedef long long ll;
typedef long double ld;
typedef pair<int, int> pi;
typedef pair<ll,ll> pl;
typedef pair<double,double> pd;
typedef priority_queue<int, vector<int>, greater<int> > min_heap;

// template <class T> using Tree = tree<T, null_type, less<T>, rb_tree_tag,tree_order_statistics_node_update>;

#define mp make_pair
#define pb push_back
#define f first
#define s second
#define lb lower_bound
#define ub upper_bound
#define all(x) x.begin(), x.end()

mt19937 mt_rand(chrono::high_resolution_clock::now().time_since_epoch().count());

const double PI = 4*atan(1);
const ll INF = 1e18;
const int MX = 100001;

const int maxn = 1e5 + 5;
int t;
int a[maxn], upper[maxn], lower[maxn];
int n;

int compute(int l, int r) {
    int num_elements = (r - l) / 2 + 1;
    int mid_elt = (l + r) / 2;
    return mid_elt * num_elements;
}

int2 main() {
    ios::sync_with_stdio(0);
    cin.tie(0);
    // freopen("A.in", "r", stdin);
    // freopen("A.out", "w", stdout);
    cin >> n;
    for (int i = 2; i <= n; i += 2) {
        cin >> a[i];
        if (a[i] % 4 == 2) {
            cout << "No\n";
            return 0;
        }
    }
    if (a[n] % 2 == 0) {
        upper[n] = (a[n] + 2) / 2;
        lower[n] = (a[n] - 2) / 2;
    } else {
        upper[n] = lower[n] = a[n];
    }
    upper[0] = lower[0] = -1;
    for (int i = n - 2; i >= 2; i -= 2) {
        int elt = a[i];
        bool done = false;
        for (int j = elt % 2; j <= (int)sqrt(elt); j += 2) {
            if (j == 0) continue;
            if (elt % j == 0) {
                int mid_elt = elt / j;
                // if (mid_elt % 2 == 0) mid_elt--;
                int last_elt = mid_elt + (j / 2) * 2;
                int first_elt = mid_elt - ((j - 1) / 2) * 2;
                if (first_elt > 1 and last_elt < lower[i + 2]) {
                    lower[i] = first_elt;
                    upper[i] = last_elt;
                    done = true;
                    break;
                }
                if (first_elt <= 1) {
                    // cout << "i: " << i << "elt: " << elt << ", next lower: " << lower[i + 2] << ", first_elt: " << first_elt << "\n";
                    break;
                }
            }
        }
        // cout << "processing " << i << ": " << elt << "\n";
        // cout << "lower: "<< lower[i] << ", upper: " << upper[i] << "\n";
        if (!done) {
            cout << "No\n";
            return 0;
        }
    }
    if (lower[2] == 1) {
        cout << "No\n";
        return 0;
    }
    // for (int i = 2; i <= n; i += 2) {
    //     cout << "i: " << i << ", lower: " << lower[i] << ", upper: " << upper[i] << "\n";
    // }
    cout << "Yes\n";
    for (int i = 2; i <= n; i += 2) {
        int s1 = compute(upper[i - 2] + 2, lower[i] - 2);
        int s2 = compute(lower[i], upper[i]);
        cout << s1 << " " << s2 << " ";
    }
    cout << "\n";
}

/*
    Potential bugs:
    - Not resetting the arrays properly
    - Out of bounds
*/


#include <vector>
#include <set>
#include <map>
#include <queue>
#include <stack>
#include <deque>
#include <bitset>

#include <iostream>
#include <algorithm>
#include <cmath>
#include <chrono>
#include <iterator>
#include <iomanip>
#include <random>
#include <numeric>

// #include <bits/stdc++.h>
// #include <ext/pb_ds/tree_policy.hpp>
// #include <ext/pb_ds/assoc_container.hpp>

using namespace std;
// using namespace __gnu_pbds;

typedef int int2;
#define int long long

typedef long long ll;
typedef long double ld;
typedef pair<int, int> pi;
typedef pair<ll,ll> pl;
typedef pair<double,double> pd;
typedef priority_queue<int, vector<int>, greater<int> > min_heap;

// template <class T> using Tree = tree<T, null_type, less<T>, rb_tree_tag,tree_order_statistics_node_update>;

#define mp make_pair
#define pb push_back
#define f first
#define s second
#define lb lower_bound
#define ub upper_bound
#define all(x) x.begin(), x.end()

mt19937 mt_rand(chrono::high_resolution_clock::now().time_since_epoch().count());

const double PI = 4*atan(1);
const ll INF = 1e18;
const int MX = 100001;

const int maxn = 1e5 + 5;
int t;
int a[maxn], upper[maxn], lower[maxn];
int n;

int compute(int l, int r) {
    int num_elements = (r - l) / 2 + 1;
    int mid_elt = (l + r) / 2;
    return mid_elt * num_elements;
}

int2 main() {
    ios::sync_with_stdio(0);
    cin.tie(0);
    // freopen("A.in", "r", stdin);
    // freopen("A.out", "w", stdout);
    cin >> n;
    for (int i = 2; i <= n; i += 2) {
        cin >> a[i];
        if (a[i] % 4 == 2) {
            cout << "No\n";
            return 0;
        }
    }
    if (a[n] % 2 == 0) {
        upper[n] = (a[n] + 2) / 2;
        lower[n] = (a[n] - 2) / 2;
    } else {
        upper[n] = lower[n] = a[n];
    }
    upper[0] = lower[0] = -1;
    for (int i = n - 2; i >= 2; i -= 2) {
        int elt = a[i];
        bool done = false;
        for (int j = elt % 2; j <= (int)sqrt(elt); j += 2) {
            if (elt % j == 0) {
                int mid_elt = elt / j;
                if (mid_elt % 2 == 1 and elt % 2 == 0) continue;
                int last_elt = mid_elt + (j / 2) * 2;
                int first_elt = mid_elt - ((j - 1) / 2) * 2;
                if (first_elt > 1 and last_elt < lower[i + 2]) {
                    lower[i] = first_elt;
                    upper[i] = last_elt;
                    done = true;
                    break;
                }
                if (first_elt <= 1) {
                    break;
                }
            }
        }
        if (!done) {
            cout << "No\n";
            return 0;
        }
    }
    if (lower[2] == 1) {
        cout << "No\n";
        return 0;
    }
    // for (int i = 2; i <= n; i += 2) {
    //     cout << "i: " << i << ", lower: " << lower[i] << ", upper: " << upper[i] << "\n";
    // }
    cout << "Yes\n";
    for (int i = 2; i <= n; i += 2) {
        int s1 = compute(upper[i - 2] + 2, lower[i] - 2);
        int s2 = compute(lower[i], upper[i]);
        cout << s1 << " " << s2 << " ";
    }
    cout << "\n";
}

/*
    Potential bugs:
    - Not resetting the arrays properly
    - Out of bounds
*/


#include <vector>
#include <set>
#include <map>
#include <queue>
#include <stack>
#include <deque>
#include <bitset>

#include <iostream>
#include <algorithm>
#include <cmath>
#include <chrono>
#include <iterator>
#include <iomanip>
#include <random>
#include <numeric>

// #include <bits/stdc++.h>
// #include <ext/pb_ds/tree_policy.hpp>
// #include <ext/pb_ds/assoc_container.hpp>

using namespace std;
// using namespace __gnu_pbds;

typedef int int2;
#define int long long

typedef long long ll;
typedef long double ld;
typedef pair<int, int> pi;
typedef pair<ll,ll> pl;
typedef pair<double,double> pd;
typedef priority_queue<int, vector<int>, greater<int> > min_heap;

// template <class T> using Tree = tree<T, null_type, less<T>, rb_tree_tag,tree_order_statistics_node_update>;

#define mp make_pair
#define pb push_back
#define f first
#define s second
#define lb lower_bound
#define ub upper_bound
#define all(x) x.begin(), x.end()

mt19937 mt_rand(chrono::high_resolution_clock::now().time_since_epoch().count());

const double PI = 4*atan(1);
const ll INF = 1e18;
const int MX = 100001;

const int maxn = 1e5 + 5;
int t;
int a[maxn], upper[maxn], lower[maxn];
int n;

int compute(int l, int r) {
    int num_elements = (r - l) / 2 + 1;
    int mid_elt = (l + r) / 2;
    return mid_elt * num_elements;
}

int2 main() {
    ios::sync_with_stdio(0);
    cin.tie(0);
    // freopen("A.in", "r", stdin);
    // freopen("A.out", "w", stdout);
    cin >> n;
    for (int i = 2; i <= n; i += 2) {
        cin >> a[i];
        if (a[i] % 4 == 2) {
            cout << "No\n";
            return 0;
        }
    }
    if (a[n] % 2 == 0) {
        upper[n] = (a[n] + 2) / 2;
        lower[n] = (a[n] - 2) / 2;
    } else {
        upper[n] = lower[n] = a[n];
    }
    upper[0] = lower[0] = -1;
    for (int i = n - 2; i >= 2; i -= 2) {
        int elt = a[i];
        bool done = false;
        for (int j = elt % 2; j <= (int)sqrt(elt); j += 2) {
            if (j == 0) continue;
            if (elt % j == 0) {
                int mid_elt = elt / j;
                int last_elt = mid_elt + (j / 2) * 2;
                int first_elt = mid_elt - ((j - 1) / 2) * 2;
                if (last_elt % 2 == 0) continue;
                if (first_elt > 1 and last_elt < lower[i + 2]) {
                    lower[i] = first_elt;
                    upper[i] = last_elt;
                    done = true;
                    break;
                }
                if (first_elt <= 1) {
                    break;
                }
            }
        }
        if (!done) {
            cout << "No\n";
            return 0;
        }
    }
    if (lower[2] == 1) {
        cout << "No\n";
        return 0;
    }
    for (int i = 2; i <= n; i += 2) {
        cout << "i: " << i << ", lower: " << lower[i] << ", upper: " << upper[i] << "\n";
    }
    cout << "Yes\n";
    for (int i = 2; i <= n; i += 2) {
        int s1 = compute(upper[i - 2] + 2, lower[i] - 2);
        int s2 = compute(lower[i], upper[i]);
        cout << s1 << " " << s2 << " ";
    }
    cout << "\n";
}

/*
    Potential bugs:
    - Not resetting the arrays properly
    - Out of bounds
*/


#include <vector>
#include <set>
#include <map>
#include <queue>
#include <stack>
#include <deque>
#include <bitset>

#include <iostream>
#include <algorithm>
#include <cmath>
#include <chrono>
#include <iterator>
#include <iomanip>
#include <random>
#include <numeric>

// #include <bits/stdc++.h>
// #include <ext/pb_ds/tree_policy.hpp>
// #include <ext/pb_ds/assoc_container.hpp>

using namespace std;
// using namespace __gnu_pbds;

typedef int int2;
#define int long long

typedef long long ll;
typedef long double ld;
typedef pair<int, int> pi;
typedef pair<ll,ll> pl;
typedef pair<double,double> pd;
typedef priority_queue<int, vector<int>, greater<int> > min_heap;

// template <class T> using Tree = tree<T, null_type, less<T>, rb_tree_tag,tree_order_statistics_node_update>;

#define mp make_pair
#define pb push_back
#define f first
#define s second
#define lb lower_bound
#define ub upper_bound
#define all(x) x.begin(), x.end()

mt19937 mt_rand(chrono::high_resolution_clock::now().time_since_epoch().count());

const double PI = 4*atan(1);
const ll INF = 1e18;
const int MX = 100001;

const int maxn = 1e5 + 5;
int t;
int a[maxn], upper[maxn], lower[maxn];
int n;

int compute(int l, int r) {
    int num_elements = (r - l) / 2 + 1;
    int mid_elt = (l + r) / 2;
    return mid_elt * num_elements;
}

int2 main() {
    ios::sync_with_stdio(0);
    cin.tie(0);
    // freopen("A.in", "r", stdin);
    // freopen("A.out", "w", stdout);
    cin >> n;
    for (int i = 2; i <= n; i += 2) {
        cin >> a[i];
        if (a[i] % 4 == 2) {
            cout << "No\n";
            return 0;
        }
    }
    if (a[n] % 2 == 0) {
        upper[n] = (a[n] + 2) / 2;
        lower[n] = (a[n] - 2) / 2;
    } else {
        upper[n] = lower[n] = a[n];
    }
    upper[0] = lower[0] = -1;
    for (int i = n - 2; i >= 2; i -= 2) {
        int elt = a[i];
        bool done = false;
        for (int j = elt % 2; j <= (int)sqrt(elt); j += 2) {
            if (elt % j == 0) {
                int mid_elt = elt / j;
                if (mid_elt % 2 == 1 and elt % 2 == 0) continue;
                int last_elt = mid_elt + (j / 2) * 2;
                int first_elt = mid_elt - ((j - 1) / 2) * 2;
                if (first_elt > 1 and last_elt < lower[i + 2]) {
                    lower[i] = first_elt;
                    upper[i] = last_elt;
                    done = true;
                    break;
                }
                if (first_elt <= 1) {
                    break;
                }
            }
        }
        if (!done) {
            cout << "No\n";
            return 0;
        }
    }
    if (lower[2] == 1) {
        cout << "No\n";
        return 0;
    }
    // for (int i = 2; i <= n; i += 2) {
    //     cout << "i: " << i << ", lower: " << lower[i] << ", upper: " << upper[i] << "\n";
    // }
    cout << "Yes\n";
    for (int i = 2; i <= n; i += 2) {
        // int s1 = compute(upper[i - 2] + 2, lower[i] - 2);
        // int s2 = compute(lower[i], upper[i]);
        cout << -1 << " " << -1 << " ";
    }
    cout << "\n";
}

/*
    Potential bugs:
    - Not resetting the arrays properly
    - Out of bounds
*/


#include <vector>
#include <set>
#include <map>
#include <queue>
#include <stack>
#include <deque>
#include <bitset>

#include <iostream>
#include <algorithm>
#include <cmath>
#include <chrono>
#include <iterator>
#include <iomanip>
#include <random>
#include <numeric>

// #include <bits/stdc++.h>
// #include <ext/pb_ds/tree_policy.hpp>
// #include <ext/pb_ds/assoc_container.hpp>

using namespace std;
// using namespace __gnu_pbds;

typedef int int2;
#define int long long

typedef long long ll;
typedef long double ld;
typedef pair<int, int> pi;
typedef pair<ll,ll> pl;
typedef pair<double,double> pd;
typedef priority_queue<int, vector<int>, greater<int> > min_heap;

// template <class T> using Tree = tree<T, null_type, less<T>, rb_tree_tag,tree_order_statistics_node_update>;

#define mp make_pair
#define pb push_back
#define f first
#define s second
#define lb lower_bound
#define ub upper_bound
#define all(x) x.begin(), x.end()

mt19937 mt_rand(chrono::high_resolution_clock::now().time_since_epoch().count());

const double PI = 4*atan(1);
const ll INF = 1e18;
const int MX = 100001;

const int maxn = 1e5 + 5;
int t;
int a[maxn], upper[maxn], lower[maxn];
int n;

int compute(int l, int r) {
    int num_elements = (r - l) / 2 + 1;
    int mid_elt = (l + r) / 2;
    return mid_elt * num_elements;
}

int2 main() {
    ios::sync_with_stdio(0);
    cin.tie(0);
    // freopen("A.in", "r", stdin);
    // freopen("A.out", "w", stdout);
    cin >> n;
    for (int i = 2; i <= n; i += 2) {
        cin >> a[i];
        if (a[i] % 4 == 2) {
            cout << "No\n";
            return 0;
        }
    }
    if (a[n] % 2 == 0) {
        upper[n] = (a[n] + 2) / 2;
        lower[n] = (a[n] - 2) / 2;
    } else {
        upper[n] = lower[n] = a[n];
    }
    upper[0] = lower[0] = -1;
    for (int i = n - 2; i >= 2; i -= 2) {
        int elt = a[i];
        bool done = false;
        for (int j = elt % 2; j <= (int)sqrt(elt); j += 2) {
            if (j == 0) continue;
            if (elt % j == 0) {
                int mid_elt = elt / j;
                int last_elt = mid_elt + (j / 2) * 2;
                int first_elt = mid_elt - ((j - 1) / 2) * 2;
                if (last_elt % 2 == 0) continue;
                if (first_elt > 1 and last_elt < lower[i + 2]) {
                    lower[i] = first_elt;
                    upper[i] = last_elt;
                    done = true;
                    break;
                }
                if (first_elt <= 1) {
                    break;
                }
            }
        }
        if (!done) {
            cout << "No\n";
            return 0;
        }
    }
    if (lower[2] == 1) {
        cout << "No\n";
        return 0;
    }
    // for (int i = 2; i <= n; i += 2) {
    //     cout << "i: " << i << ", lower: " << lower[i] << ", upper: " << upper[i] << "\n";
    // }
    cout << "Yes\n";
    for (int i = 2; i <= n; i += 2) {
        int s1 = compute(upper[i - 2] + 2, lower[i] - 2);
        int s2 = compute(lower[i], upper[i]);
        cout << s1 << " " << s2 << " ";
    }
    cout << "\n";
}

/*
    Potential bugs:
    - Not resetting the arrays properly
    - Out of bounds
*/


#include <iostream>
#include <cstdio>
#include <cstdlib>
#include <cstring>
#include <vector>
#include <map>
#include <queue>
#include <algorithm>
#include <string>
#include <stack>
#include <cmath>
#include <set>

int N = 1e6, SZ = 320, INF = 1 << 29;
long long LINF = (1LL<<60),mod = 1e9 + 7;
const long double eps = 1e-9, PI = acos(-1.0);

#define lowbit(x) (x&(-(x)))
#define MAX(a,b) ((a)<(b)?(b):(a))
#define MIN(a,b) ((a)<(b)?(a):(b))
#define rp(a,b,c) for(int a = b;a<=c;++a)
#define RP(a,b,c) for(int a = b;a<c;++a)
#define lp(a,b,c) for(int a = b;a>=c;--a)
#define LP(a,b,c) for(int a = b;a>c;--a)
#define rps(i,s) for(int i = 0;s[i];i++)
#define fson(u) for(int i = g[u];~i;i=edg[i].nxt)
#define adde(u,v) edg[++ecnt]=Edge(u,v,0,g[u]),g[u]=ecnt
#define addew(u,v,w) edg[++ecnt]=Edge(u,v,w,g[u]),g[u]=ecnt
#define MID (l+r>>1)
#define ssr(s) scanf("%s",s)
#define sp(s) printf("%s",s)
#define rvs(a) a.reverse(a.size())
#define mst(a,v) memset(a,v,sizeof(a))
#define bg(x) Edge edg[maxn<<x];int g[maxn],ecnt
#define ex(v) cout<<v;return 0
#define debug(x) cout<<"debug: "<<x<<endl;

using namespace std;
typedef long long ll;
typedef unsigned long long ull;
typedef double db;
typedef long double ld;
typedef pair<int, int> pii;
typedef pair<ll, ll> pll;
typedef vector<int> vi;
typedef vector<ll> vll;
typedef map<int, int> mii;
typedef map<ll, ll> mll;

char READ_DATA;
int SIGNAL_INPUT;
template <typename Type> inline Type ru(Type &v)
{
	SIGNAL_INPUT = 1;
	while ((READ_DATA = getchar()) < '0' || READ_DATA > '9')
		if (READ_DATA == '-')
			SIGNAL_INPUT = -1;
		else if (READ_DATA == EOF)
			return EOF;
	v = READ_DATA - '0';
	while ((READ_DATA = getchar()) >= '0' && READ_DATA <= '9')
		v = v * 10 + READ_DATA - '0';
	v *= SIGNAL_INPUT;
	return v;
}
inline ll modru(ll &v)
{
	ll p = 0;
	SIGNAL_INPUT = 1;
	while ((READ_DATA = getchar()) < '0' || READ_DATA > '9')
		if (READ_DATA == '-')
			SIGNAL_INPUT = -1;
		else if (READ_DATA == EOF)
			return EOF;
	p = v = READ_DATA - '0';
	while ((READ_DATA = getchar()) >= '0' && READ_DATA <= '9')
	{
		v = (v * 10 + READ_DATA - '0') % mod;
		p = (p * 10 + READ_DATA - '0') % (mod - 1);
	}
	v *= SIGNAL_INPUT;
	return p;
}
template <typename Type> inline void swp(Type &a, Type &b)
{
	Type c = a;
	a = b;
	b = c;
}
inline ll gcd(ll a, ll b)
{
	while (b)
	{
		a %= b;
		swp(a, b);
	}
	return a;
}
template<typename A, typename B > inline char ru(A&x, B&y) { if (ru(x) == EOF) return EOF; ru(y); return 2; }
template<typename A, typename B, typename C>inline char ru(A&x, B&y, C&z) { if (ru(x) == EOF) return EOF; ru(y); ru(z); return 3; }
template<typename A, typename B, typename C, typename D>inline char ru(A&x, B&y, C&z, D&w) { if (ru(x) == EOF) return EOF; ru(y); ru(z); ru(w); return 4; }

struct Edge
{
	int u, v, nxt;
	ll w;
	Edge(int _u = 0, int _v = 0, ll _w = 0, int _nxt = 0)
	{
		u = _u;
		v = _v;
		w = _w;
		nxt = _nxt;
	}
};
struct CMP
{

};

const int maxn = 1e5 + 5;
/*------------------------------------------------------------------------yah------------------------------------------------------------------------*/

int n;
ll x[maxn];
int is(ll t)
{
	ll m = sqrt(t);
	return m * m == t;
}

int main()
{
	ru(n);
	for (int i = 2; i <= n; i += 2) ru(x[i]);

	ll cur = 1, s = 0;
	for (int i = 1; i < n; i += 2)
	{
		int ok = 0;
		while (cur*cur-s<=10000000000000LL)
		{
			ll tmp = cur * cur;
			if (is(tmp - s) && is(tmp + x[i + 1]))
			{
				x[i] = tmp - s;
				s = tmp + x[i + 1];
				++cur;
				ok = 1;
				break;
			}
			++cur;
		}
		if (!ok)
		{
			ex("No");
		}
	}
	printf("Yes\n");
	rp(i, 1, n) printf("%lld ", x[i]);
}


#include <iostream>
#include <cstdio>
#include <cstdlib>
#include <cstring>
#include <vector>
#include <map>
#include <queue>
#include <algorithm>
#include <string>
#include <stack>
#include <cmath>
#include <set>

int N = 1e6, SZ = 320, INF = 1 << 29;
long long LINF = (1LL<<60),mod = 1e9 + 7;
const long double eps = 1e-9, PI = acos(-1.0);

#define lowbit(x) (x&(-(x)))
#define MAX(a,b) ((a)<(b)?(b):(a))
#define MIN(a,b) ((a)<(b)?(a):(b))
#define rp(a,b,c) for(int a = b;a<=c;++a)
#define RP(a,b,c) for(int a = b;a<c;++a)
#define lp(a,b,c) for(int a = b;a>=c;--a)
#define LP(a,b,c) for(int a = b;a>c;--a)
#define rps(i,s) for(int i = 0;s[i];i++)
#define fson(u) for(int i = g[u];~i;i=edg[i].nxt)
#define adde(u,v) edg[++ecnt]=Edge(u,v,0,g[u]),g[u]=ecnt
#define addew(u,v,w) edg[++ecnt]=Edge(u,v,w,g[u]),g[u]=ecnt
#define MID (l+r>>1)
#define ssr(s) scanf("%s",s)
#define sp(s) printf("%s",s)
#define rvs(a) a.reverse(a.size())
#define mst(a,v) memset(a,v,sizeof(a))
#define bg(x) Edge edg[maxn<<x];int g[maxn],ecnt
#define ex(v) cout<<v;return 0
#define debug(x) cout<<"debug: "<<x<<endl;

using namespace std;
typedef long long ll;
typedef unsigned long long ull;
typedef double db;
typedef long double ld;
typedef pair<int, int> pii;
typedef pair<ll, ll> pll;
typedef vector<int> vi;
typedef vector<ll> vll;
typedef map<int, int> mii;
typedef map<ll, ll> mll;

char READ_DATA;
int SIGNAL_INPUT;
template <typename Type> inline Type ru(Type &v)
{
	SIGNAL_INPUT = 1;
	while ((READ_DATA = getchar()) < '0' || READ_DATA > '9')
		if (READ_DATA == '-')
			SIGNAL_INPUT = -1;
		else if (READ_DATA == EOF)
			return EOF;
	v = READ_DATA - '0';
	while ((READ_DATA = getchar()) >= '0' && READ_DATA <= '9')
		v = v * 10 + READ_DATA - '0';
	v *= SIGNAL_INPUT;
	return v;
}
inline ll modru(ll &v)
{
	ll p = 0;
	SIGNAL_INPUT = 1;
	while ((READ_DATA = getchar()) < '0' || READ_DATA > '9')
		if (READ_DATA == '-')
			SIGNAL_INPUT = -1;
		else if (READ_DATA == EOF)
			return EOF;
	p = v = READ_DATA - '0';
	while ((READ_DATA = getchar()) >= '0' && READ_DATA <= '9')
	{
		v = (v * 10 + READ_DATA - '0') % mod;
		p = (p * 10 + READ_DATA - '0') % (mod - 1);
	}
	v *= SIGNAL_INPUT;
	return p;
}
template <typename Type> inline void swp(Type &a, Type &b)
{
	Type c = a;
	a = b;
	b = c;
}
inline ll gcd(ll a, ll b)
{
	while (b)
	{
		a %= b;
		swp(a, b);
	}
	return a;
}
template<typename A, typename B > inline char ru(A&x, B&y) { if (ru(x) == EOF) return EOF; ru(y); return 2; }
template<typename A, typename B, typename C>inline char ru(A&x, B&y, C&z) { if (ru(x) == EOF) return EOF; ru(y); ru(z); return 3; }
template<typename A, typename B, typename C, typename D>inline char ru(A&x, B&y, C&z, D&w) { if (ru(x) == EOF) return EOF; ru(y); ru(z); ru(w); return 4; }

struct Edge
{
	int u, v, nxt;
	ll w;
	Edge(int _u = 0, int _v = 0, ll _w = 0, int _nxt = 0)
	{
		u = _u;
		v = _v;
		w = _w;
		nxt = _nxt;
	}
};
struct CMP
{

};

const int maxn = 1e5 + 5;
/*------------------------------------------------------------------------yah------------------------------------------------------------------------*/

int n;
ll x[maxn];
int is(ll t)
{
	ll m = sqrt(t);
	return m * m == t;
}

int main()
{
	ru(n);
	for (int i = 2; i <= n; i += 2) ru(x[i]);

	ll cur = 1, s = 0;
	for (int i = 1; i < n; i += 2)
	{
		int ok = 0;
		cur = sqrt(s);
		if (!is(s)) ++cur;
		if (cur == 0) ++cur;
		while (cur*cur-s<=10000000000000LL)
		{
			ll tmp = cur * cur;
			if (is(tmp + x[i + 1]))
			{
				x[i] = tmp - s;
				s = tmp + x[i + 1];
				ok = 1;
				break;
			}
			++cur;
		}
		if (!ok)
		{
			ex("No");
		}
	}
	printf("Yes\n");
	rp(i, 1, n) printf("%lld ", x[i]);
}


#include <iostream>
#include <cstdio>
#include <cstdlib>
#include <cstring>
#include <vector>
#include <map>
#include <queue>
#include <algorithm>
#include <string>
#include <stack>
#include <cmath>
#include <set>

int N = 1e6, SZ = 320, INF = 1 << 29;
long long LINF = (1LL<<60),mod = 1e9 + 7;
const long double eps = 1e-9, PI = acos(-1.0);

#define lowbit(x) (x&(-(x)))
#define MAX(a,b) ((a)<(b)?(b):(a))
#define MIN(a,b) ((a)<(b)?(a):(b))
#define rp(a,b,c) for(int a = b;a<=c;++a)
#define RP(a,b,c) for(int a = b;a<c;++a)
#define lp(a,b,c) for(int a = b;a>=c;--a)
#define LP(a,b,c) for(int a = b;a>c;--a)
#define rps(i,s) for(int i = 0;s[i];i++)
#define fson(u) for(int i = g[u];~i;i=edg[i].nxt)
#define adde(u,v) edg[++ecnt]=Edge(u,v,0,g[u]),g[u]=ecnt
#define addew(u,v,w) edg[++ecnt]=Edge(u,v,w,g[u]),g[u]=ecnt
#define MID (l+r>>1)
#define ssr(s) scanf("%s",s)
#define sp(s) printf("%s",s)
#define rvs(a) a.reverse(a.size())
#define mst(a,v) memset(a,v,sizeof(a))
#define bg(x) Edge edg[maxn<<x];int g[maxn],ecnt
#define ex(v) cout<<v;return 0
#define debug(x) cout<<"debug: "<<x<<endl;

using namespace std;
typedef long long ll;
typedef unsigned long long ull;
typedef double db;
typedef long double ld;
typedef pair<int, int> pii;
typedef pair<ll, ll> pll;
typedef vector<int> vi;
typedef vector<ll> vll;
typedef map<int, int> mii;
typedef map<ll, ll> mll;

char READ_DATA;
int SIGNAL_INPUT;
template <typename Type> inline Type ru(Type &v)
{
	SIGNAL_INPUT = 1;
	while ((READ_DATA = getchar()) < '0' || READ_DATA > '9')
		if (READ_DATA == '-')
			SIGNAL_INPUT = -1;
		else if (READ_DATA == EOF)
			return EOF;
	v = READ_DATA - '0';
	while ((READ_DATA = getchar()) >= '0' && READ_DATA <= '9')
		v = v * 10 + READ_DATA - '0';
	v *= SIGNAL_INPUT;
	return v;
}
inline ll modru(ll &v)
{
	ll p = 0;
	SIGNAL_INPUT = 1;
	while ((READ_DATA = getchar()) < '0' || READ_DATA > '9')
		if (READ_DATA == '-')
			SIGNAL_INPUT = -1;
		else if (READ_DATA == EOF)
			return EOF;
	p = v = READ_DATA - '0';
	while ((READ_DATA = getchar()) >= '0' && READ_DATA <= '9')
	{
		v = (v * 10 + READ_DATA - '0') % mod;
		p = (p * 10 + READ_DATA - '0') % (mod - 1);
	}
	v *= SIGNAL_INPUT;
	return p;
}
template <typename Type> inline void swp(Type &a, Type &b)
{
	Type c = a;
	a = b;
	b = c;
}
inline ll gcd(ll a, ll b)
{
	while (b)
	{
		a %= b;
		swp(a, b);
	}
	return a;
}
template<typename A, typename B > inline char ru(A&x, B&y) { if (ru(x) == EOF) return EOF; ru(y); return 2; }
template<typename A, typename B, typename C>inline char ru(A&x, B&y, C&z) { if (ru(x) == EOF) return EOF; ru(y); ru(z); return 3; }
template<typename A, typename B, typename C, typename D>inline char ru(A&x, B&y, C&z, D&w) { if (ru(x) == EOF) return EOF; ru(y); ru(z); ru(w); return 4; }

struct Edge
{
	int u, v, nxt;
	ll w;
	Edge(int _u = 0, int _v = 0, ll _w = 0, int _nxt = 0)
	{
		u = _u;
		v = _v;
		w = _w;
		nxt = _nxt;
	}
};
struct CMP
{

};

const int maxn = 1e5 + 5;
/*------------------------------------------------------------------------yah------------------------------------------------------------------------*/

int n;
ll x[maxn];
int is(ll t)
{
	ll m = sqrt(t);
	return m * m == t;
}

int main()
{
	ru(n);
	for (int i = 2; i <= n; i += 2) ru(x[i]);

	ll cur = 1, s = 0;
	for (int i = 1; i < n; i += 2)
	{
		int ok = 0;
		while (cur*cur-s<=10000000000000LL)
		{
			ll tmp = cur * cur;
			if (is(tmp - s) && is(tmp + x[i + 1]))
			{
				x[i] = tmp - s;
				s = tmp + x[i + 1];
				++cur;
				ok = 1;
				break;
			}
			++cur;
		}
		if (!ok) ex("No");
	}
	printf("Yes\n");
	rp(i, 1, n) printf("%lld ", x[i]);
}


#include <iostream>
#include <cstdio>
#include <cstdlib>
#include <cstring>
#include <vector>
#include <map>
#include <queue>
#include <algorithm>
#include <string>
#include <stack>
#include <cmath>
#include <set>

int N = 1e6, SZ = 320, INF = 1 << 29;
long long LINF = (1LL<<60),mod = 1e9 + 7;
const long double eps = 1e-9, PI = acos(-1.0);

#define lowbit(x) (x&(-(x)))
#define MAX(a,b) ((a)<(b)?(b):(a))
#define MIN(a,b) ((a)<(b)?(a):(b))
#define rp(a,b,c) for(int a = b;a<=c;++a)
#define RP(a,b,c) for(int a = b;a<c;++a)
#define lp(a,b,c) for(int a = b;a>=c;--a)
#define LP(a,b,c) for(int a = b;a>c;--a)
#define rps(i,s) for(int i = 0;s[i];i++)
#define fson(u) for(int i = g[u];~i;i=edg[i].nxt)
#define adde(u,v) edg[++ecnt]=Edge(u,v,0,g[u]),g[u]=ecnt
#define addew(u,v,w) edg[++ecnt]=Edge(u,v,w,g[u]),g[u]=ecnt
#define MID (l+r>>1)
#define ssr(s) scanf("%s",s)
#define sp(s) printf("%s",s)
#define rvs(a) a.reverse(a.size())
#define mst(a,v) memset(a,v,sizeof(a))
#define bg(x) Edge edg[maxn<<x];int g[maxn],ecnt
#define ex(v) cout<<v;return 0
#define debug(x) cout<<"debug: "<<x<<endl;

using namespace std;
typedef long long ll;
typedef unsigned long long ull;
typedef double db;
typedef long double ld;
typedef pair<int, int> pii;
typedef pair<ll, ll> pll;
typedef vector<int> vi;
typedef vector<ll> vll;
typedef map<int, int> mii;
typedef map<ll, ll> mll;

char READ_DATA;
int SIGNAL_INPUT;
template <typename Type> inline Type ru(Type &v)
{
	SIGNAL_INPUT = 1;
	while ((READ_DATA = getchar()) < '0' || READ_DATA > '9')
		if (READ_DATA == '-')
			SIGNAL_INPUT = -1;
		else if (READ_DATA == EOF)
			return EOF;
	v = READ_DATA - '0';
	while ((READ_DATA = getchar()) >= '0' && READ_DATA <= '9')
		v = v * 10 + READ_DATA - '0';
	v *= SIGNAL_INPUT;
	return v;
}
inline ll modru(ll &v)
{
	ll p = 0;
	SIGNAL_INPUT = 1;
	while ((READ_DATA = getchar()) < '0' || READ_DATA > '9')
		if (READ_DATA == '-')
			SIGNAL_INPUT = -1;
		else if (READ_DATA == EOF)
			return EOF;
	p = v = READ_DATA - '0';
	while ((READ_DATA = getchar()) >= '0' && READ_DATA <= '9')
	{
		v = (v * 10 + READ_DATA - '0') % mod;
		p = (p * 10 + READ_DATA - '0') % (mod - 1);
	}
	v *= SIGNAL_INPUT;
	return p;
}
template <typename Type> inline void swp(Type &a, Type &b)
{
	Type c = a;
	a = b;
	b = c;
}
inline ll gcd(ll a, ll b)
{
	while (b)
	{
		a %= b;
		swp(a, b);
	}
	return a;
}
template<typename A, typename B > inline char ru(A&x, B&y) { if (ru(x) == EOF) return EOF; ru(y); return 2; }
template<typename A, typename B, typename C>inline char ru(A&x, B&y, C&z) { if (ru(x) == EOF) return EOF; ru(y); ru(z); return 3; }
template<typename A, typename B, typename C, typename D>inline char ru(A&x, B&y, C&z, D&w) { if (ru(x) == EOF) return EOF; ru(y); ru(z); ru(w); return 4; }

struct Edge
{
	int u, v, nxt;
	ll w;
	Edge(int _u = 0, int _v = 0, ll _w = 0, int _nxt = 0)
	{
		u = _u;
		v = _v;
		w = _w;
		nxt = _nxt;
	}
};
struct CMP
{

};

const int maxn = 1e5 + 5;
/*------------------------------------------------------------------------yah------------------------------------------------------------------------*/

int n;
ll x[maxn];
int is(ll t)
{
	ll m = sqrt(t);
	return m * m == t;
}

int main()
{
	ru(n);
	for (int i = 2; i <= n; i += 2) ru(x[i]);

	ll cur = 1, s = 0;
	for (int i = 1; i < n; i += 2)
	{
		int ok = 0;
		cur = sqrt(s);
		if (!is(s)) ++cur;
		while (cur*cur-s<=10000000000000LL)
		{
			ll tmp = cur * cur;
			if (is(tmp + x[i + 1]))
			{
				x[i] = tmp - s;
				s = tmp + x[i + 1];
				++cur;
				ok = 1;
				break;
			}
			++cur;
		}
		if (!ok)
		{
			ex("No");
		}
	}
	printf("Yes\n");
	rp(i, 1, n) printf("%lld ", x[i]);
}