#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 - 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<bits/stdc++.h>
using namespace std;
#define ll long long int
#define v vector<ll>
#define vv vector<v>
#define MAX 15000001
ll MOD=998244353;
int LIM=2e5+10;
    vector<int> least_prime(LIM, 0);
void leastPrimeFactor(ll n)
{
    least_prime[1] = 1;

    for (ll i = 2; i <= n; i++)
    {
        if (least_prime[i] == 0)
        {
            least_prime[i] = i;
            for (ll j = 2*i; j <= n; j += i)
                if (least_prime[j] == 0)
                   least_prime[j] = i;
        }
    }
}
//int LIM=2e5+10;
int main()
{
	ll n;
	cin>>n;
	v arr(n+1,-1);
	for (ll i=1; i<=(n/2); i++)
		cin>>arr[i*2];
	leastPrimeFactor(LIM);
	v k(n+1,0);
	bool ans=true;
	for (ll i=1; i<=n/2; i++)
	{
		ll num=arr[2*i];
		if (least_prime[num]==2)
		{
			if (num%4==0)
			{
				k[2*i]=(num/2+2)/2;
				k[2*i-1]=(num/2-2)/2;
				// for (int j=1; j<=(sqrt(num)+4); j++)
				// {
				// 	if (j%2==0 && (num/j)%2==0 && j)
				// }
			}
			else
				ans=false;
		}
		else
		{
			k[2*i]=(num+1)/2;
			k[2*i-1]=(num-1)/2;
			// for (int j=1; j<=(sqrt(num)+4); j++)
			// {
			// 	if (>k[2*(i-1)] && num%j==0)
			// 	{
			// 		k[2*i]=(j+(num/j))/2;
			// 		k[2*i-1]=(j-(num/j))/2;
			// 	}
			// }
			// if (k[2*i]==0)
			// 	ans=false;
		}
	}
	for (ll i=1; i<=n; i++)
	{
		arr[i]=k[i]*k[i]-k[i-1]*k[i-1];
		if (arr[i]<0)
			ans=false;
	}
	if (ans)
	{
		cout<<"Yes"<<endl;
		for (int i=1; i<=n; i++)
			cout<<arr[i]<<" ";
	}
	else
		cout<<"No"<<endl;
    return 0;
}


#include<bits/stdc++.h>
using namespace std;
#define ll long long int
#define v vector<ll>
#define vv vector<v>
#define MAX 15000001
ll MOD=998244353;
int LIM=2e5+10;
    vector<int> least_prime(LIM, 0);
void leastPrimeFactor(ll n)
{
    least_prime[1] = 1;

    for (ll i = 2; i <= n; i++)
    {
        if (least_prime[i] == 0)
        {
            least_prime[i] = i;
            for (ll j = 2*i; j <= n; j += i)
                if (least_prime[j] == 0)
                   least_prime[j] = i;
        }
    }
}
//int LIM=2e5+10;
int main()
{
	ll n;
	cin>>n;
	v arr(n+1,-1);
	for (ll i=1; i<=(n/2); i++)
		cin>>arr[i*2];
	leastPrimeFactor(LIM);
	v k(n+1,0);
	bool ans=true;
	//cout<<arr[2]<<endl;
	for (ll i=1; i<=n/2; i++)
	{
		ll num=arr[2*i];
		if (least_prime[num]==2)
		{
			if (num%4==0)
			{
				for (int j=1; j<=(min(num,(ll)(sqrt(num)+4))); j++)
				{
					if (j%2==0 && (num/j)%2==0 && abs(num/j-j)/2>k[2*(i-1)] && num%j==0)
					{
						if (k[2*i-1]==0 || k[2*i]>abs(num/j+j)/2)
						{
							k[2*i]=(j+num/j)/2;
							k[2*i-1]=abs(num/j-j)/2;
						}
					}
				}
				if (k[2*i]==0)
				{
					//cout<<i<<endl;
					ans=false;
				}
			}
			else
				ans=false;
		}
		else
		{
			// k[2*i]=(num+1)/2;
			// k[2*i-1]=(num-1)/2;
			for (int j=1; j<=min(num,(ll)(sqrt(num)+4)); j++)
			{
				//if (i==1 && j==5)
			//			cout<<"a"<<endl;
				if (abs(j-(num/j))/2>k[2*(i-1)] && num%j==0)
				{
					if (k[2*i-1]==0 || abs(j+(num/j))/2<k[2*i])
					{
						k[2*i]=(j+(num/j))/2;
						k[2*i-1]=abs(j-(num/j))/2;
					}
				}
			}
			if (k[2*i]==0)
			{
			//	cout<<i<<" "<<k[1]<<" "<<k[2]<<endl;
				ans=false;
			}
		}
	}
	for (ll i=1; i<=n; i++)
	{
		arr[i]=k[i]*k[i]-k[i-1]*k[i-1];
		if (arr[i]<=0)
			ans=false;
	}
	if (ans)
	{
		cout<<"Yes"<<endl;
		for (int i=1; i<=n; i++)
			cout<<arr[i]<<" ";
	}
	else
		cout<<"No"<<endl;
    return 0;
}


#include<bits/stdc++.h>
using namespace std;
#define ll long long int
#define v vector<ll>
#define vv vector<v>
#define MAX 15000001
ll MOD=998244353;
int LIM=2e5+10;
    vector<int> least_prime(LIM, 0);
void leastPrimeFactor(ll n)
{
    least_prime[1] = 1;

    for (ll i = 2; i <= n; i++)
    {
        if (least_prime[i] == 0)
        {
            least_prime[i] = i;
            for (ll j = 2*i; j <= n; j += i)
                if (least_prime[j] == 0)
                   least_prime[j] = i;
        }
    }
}
//int LIM=2e5+10;
int main()
{
	ll n;
	cin>>n;
	v arr(n+1,-1);
	for (ll i=1; i<=(n/2); i++)
		cin>>arr[i*2];
	leastPrimeFactor(LIM);
	v k(n+1,0);
	bool ans=true;
	for (ll i=1; i<=n/2; i++)
	{
		ll num=arr[2*i];
		if (least_prime[num]==2)
		{
			if (num%4==0)
			{
				for (int j=1; j<=(min(n,(ll)(sqrt(num)+4))); j++)
				{
					if (j%2==0 && (num/j)%2==0 && abs(num/j-j)/2>k[2*(i-1)])
					{
						if (k[2*i-1]==0 || k[2*i]>abs(num/j+j)/2)
						{
							k[2*i]=(j+num/j)/2;
							k[2*i-1]=abs(num/j-j)/2;
						}
					}
				}
				if (k[2*i]==0)
				{
					//cout<<i<<endl;
					ans=false;
				}
			}
			else
				ans=false;
		}
		else
		{
			// k[2*i]=(num+1)/2;
			// k[2*i-1]=(num-1)/2;
			for (int j=1; j<=min(n,(ll)(sqrt(num)+4)); j++)
			{
				if (abs(j-(num/j))/2>k[2*(i-1)] && num%j==0)
				{
					if (k[2*i-1]==0 || abs(j+(num/j))/2<k[2*i])
					{
						k[2*i]=(j+(num/j))/2;
						k[2*i-1]=abs(j-(num/j))/2;
					}
				}
			}
			if (k[2*i]==0)
			{
				//cout<<i<<" "<<k[1]<<" "<<k[2]<<endl;
				ans=false;
			}
		}
	}
	for (ll i=1; i<=n; i++)
	{
		arr[i]=k[i]*k[i]-k[i-1]*k[i-1];
		if (arr[i]<=0)
			ans=false;
	}
	if (ans)
	{
		cout<<"Yes"<<endl;
		for (int i=1; i<=n; i++)
			cout<<arr[i]<<" ";
	}
	else
		cout<<"No"<<endl;
    return 0;
}


#include<bits/stdc++.h>
using namespace std;
#define ll long long int
#define v vector<ll>
#define vv vector<v>
#define MAX 15000001
ll MOD=998244353;
int LIM=2e5+10;
    vector<int> least_prime(LIM, 0);
void leastPrimeFactor(ll n)
{
    least_prime[1] = 1;

    for (ll i = 2; i <= n; i++)
    {
        if (least_prime[i] == 0)
        {
            least_prime[i] = i;
            for (ll j = 2*i; j <= n; j += i)
                if (least_prime[j] == 0)
                   least_prime[j] = i;
        }
    }
}
//int LIM=2e5+10;
int main()
{
	ll n;
	cin>>n;
	v arr(n+1,-1);
	for (ll i=1; i<=(n/2); i++)
		cin>>arr[i*2];
	leastPrimeFactor(LIM);
	v k(n+1,0);
	bool ans=true;
	for (ll i=1; i<=n/2; i++)
	{
		ll num=arr[2*i];
		if (least_prime[num]==2)
		{
			if (num%4==0)
			{
				for (int j=1; j<=(min(num,(ll)(sqrt(num)+4))); j++)
				{
					if (j%2==0 && (num/j)%2==0 && abs(num/j-j)/2>k[2*(i-1)])
					{
						if (k[2*i-1]==0 || k[2*i]>abs(num/j+j)/2)
						{
							k[2*i]=(j+num/j)/2;
							k[2*i-1]=abs(num/j-j)/2;
						}
					}
				}
				if (k[2*i]==0)
				{
					//cout<<i<<endl;
					ans=false;
				}
			}
			else
				ans=false;
		}
		else
		{
			// k[2*i]=(num+1)/2;
			// k[2*i-1]=(num-1)/2;
			for (int j=1; j<=min(num,(ll)(sqrt(num)+4)); j++)
			{
				//if (i==1 && j==5)
			//			cout<<"a"<<endl;
				if (abs(j-(num/j))/2>k[2*(i-1)] && num%j==0)
				{
					if (k[2*i-1]==0 || abs(j+(num/j))/2<k[2*i])
					{
						k[2*i]=(j+(num/j))/2;
						k[2*i-1]=abs(j-(num/j))/2;
					}
				}
			}
			if (k[2*i]==0)
			{
			//	cout<<i<<" "<<k[1]<<" "<<k[2]<<endl;
				ans=false;
			}
		}
	}
	for (ll i=1; i<=n; i++)
	{
		arr[i]=k[i]*k[i]-k[i-1]*k[i-1];
		if (arr[i]<=0)
			ans=false;
	}
	if (ans)
	{
		cout<<"Yes"<<endl;
		for (int i=1; i<=n; i++)
			cout<<arr[i]<<" ";
	}
	else
		cout<<"No"<<endl;
    return 0;
}


#include<bits/stdc++.h>
using namespace std;
#define ll long long int
#define v vector<ll>
#define vv vector<v>
#define MAX 15000001
ll MOD=998244353;
int LIM=2e5+10;
    vector<int> least_prime(LIM, 0);
void leastPrimeFactor(ll n)
{
    least_prime[1] = 1;

    for (ll i = 2; i <= n; i++)
    {
        if (least_prime[i] == 0)
        {
            least_prime[i] = i;
            for (ll j = 2*i; j <= n; j += i)
                if (least_prime[j] == 0)
                   least_prime[j] = i;
        }
    }
}
//int LIM=2e5+10;
int main()
{
	ll n;
	cin>>n;
	v arr(n+1,-1);
	for (ll i=1; i<=(n/2); i++)
		cin>>arr[i*2];
	leastPrimeFactor(LIM);
	v k(n+1,0);
	bool ans=true;
	for (ll i=1; i<=n/2; i++)
	{
		ll num=arr[2*i];
		if (least_prime[num]==2)
		{
			if (num%4==0)
			{
				for (int j=1; j<=(min(n,(ll)(sqrt(num)+4))); j++)
				{
					if (j%2==0 && (num/j)%2==0 && abs(num/j-j)/2>k[2*(i-1)])
					{
						k[2*i]=(j+num/j)/2;
						k[2*i-1]=abs(num/j-j)/2;
					}
				}
				if (k[2*i]==0)
				{
					cout<<i<<endl;
					ans=false;
				}
			}
			else
				ans=false;
		}
		else
		{
			// k[2*i]=(num+1)/2;
			// k[2*i-1]=(num-1)/2;
			for (int j=1; j<=min(n,(ll)(sqrt(num)+4)); j++)
			{
				if (abs(j-(num/j))/2>k[2*(i-1)] && num%j==0)
				{
					k[2*i]=(j+(num/j))/2;
					k[2*i-1]=abs(j-(num/j))/2;
				}
			}
			if (k[2*i]==0)
			{
				//cout<<i<<" "<<k[1]<<" "<<k[2]<<endl;
				ans=false;
			}
		}
	}
	for (ll i=1; i<=n; i++)
	{
		arr[i]=k[i]*k[i]-k[i-1]*k[i-1];
		if (arr[i]<=0)
			ans=false;
	}
	if (ans)
	{
		cout<<"Yes"<<endl;
		for (int i=1; i<=n; i++)
			cout<<arr[i]<<" ";
	}
	else
		cout<<"No"<<endl;
    return 0;
}


#include<bits/stdc++.h>
using namespace std;
#define ll long long int
#define v vector<ll>
#define vv vector<v>
#define MAX 15000001
ll MOD=998244353;
int LIM=2e5+10;
    vector<int> least_prime(LIM, 0);
void leastPrimeFactor(ll n)
{
    least_prime[1] = 1;

    for (ll i = 2; i <= n; i++)
    {
        if (least_prime[i] == 0)
        {
            least_prime[i] = i;
            for (ll j = 2*i; j <= n; j += i)
                if (least_prime[j] == 0)
                   least_prime[j] = i;
        }
    }
}
//int LIM=2e5+10;
int main()
{
	ll n;
	cin>>n;
	v arr(n+1,-1);
	for (ll i=1; i<=(n/2); i++)
		cin>>arr[i*2];
	leastPrimeFactor(LIM);
	v k(n+1,0);
	bool ans=true;
	for (ll i=1; i<=n/2; i++)
	{
		ll num=arr[2*i];
		if (least_prime[num]==2)
		{
			if (num%4==0)
			{
				k[2*i]=(num/2+2)/2;
				k[2*i-1]=(num/2-2)/2;
			}
			else
				ans=false;
		}
		else
		{
			k[2*i]=(num+1)/2;
			k[2*i-1]=(num-1)/2;
		}
	}
	for (ll i=1; i<=n; i++)
	{
		arr[i]=k[i]*k[i]-k[i-1]*k[i-1];
	}
	if (ans)
	{
		cout<<"Yes"<<endl;
		for (int i=1; i<=n; i++)
			cout<<arr[i]<<" ";
	}
	else
		cout<<"No"<<endl;
    return 0;
}


#include<bits/stdc++.h>
using namespace std;
#define ll long long int
#define v vector<ll>
#define vv vector<v>
#define MAX 15000001
ll MOD=998244353;
int LIM=2e5+10;
    vector<int> least_prime(LIM, 0);
void leastPrimeFactor(ll n)
{
    least_prime[1] = 1;

    for (ll i = 2; i <= n; i++)
    {
        if (least_prime[i] == 0)
        {
            least_prime[i] = i;
            for (ll j = 2*i; j <= n; j += i)
                if (least_prime[j] == 0)
                   least_prime[j] = i;
        }
    }
}
//int LIM=2e5+10;
int main()
{
	ll n;
	cin>>n;
	v arr(n+1,-1);
	for (ll i=1; i<=(n/2); i++)
		cin>>arr[i*2];
	leastPrimeFactor(LIM);
	v k(n+1,0);
	bool ans=true;
	for (ll i=1; i<=n/2; i++)
	{
		ll num=arr[2*i];
		if (least_prime[num]==2)
		{
			if (num%4==0)
			{
				for (int j=1; j<=(min(n,(ll)(sqrt(num)+4))); j++)
				{
					if (j%2==0 && (num/j)%2==0 && abs(num/j-j)/2>k[2*(i-1)])
					{
						k[2*i]=(j+num/j)/2;
						k[2*i-1]=abs(num/j-j)/2;
					}
				}
				if (k[2*i]==0)
				{
					//cout<<i<<endl;
					ans=false;
				}
			}
			else
				ans=false;
		}
		else
		{
			// k[2*i]=(num+1)/2;
			// k[2*i-1]=(num-1)/2;
			for (int j=1; j<=min(n,(ll)(sqrt(num)+4)); j++)
			{
				if (abs(j-(num/j))/2>k[2*(i-1)] && num%j==0)
				{
					k[2*i]=(j+(num/j))/2;
					k[2*i-1]=abs(j-(num/j))/2;
				}
			}
			if (k[2*i]==0)
			{
				//cout<<i<<" "<<k[1]<<" "<<k[2]<<endl;
				ans=false;
			}
		}
	}
	for (ll i=1; i<=n; i++)
	{
		arr[i]=k[i]*k[i]-k[i-1]*k[i-1];
		if (arr[i]<=0)
			ans=false;
	}
	if (ans)
	{
		cout<<"Yes"<<endl;
		for (int i=1; i<=n; i++)
			cout<<arr[i]<<" ";
	}
	else
		cout<<"No"<<endl;
    return 0;
}


#include<bits/stdc++.h>
using namespace std;
#define ll long long int
#define v vector<ll>
#define vv vector<v>
#define MAX 15000001
ll MOD=998244353;
int LIM=2e5+10;
    vector<int> least_prime(LIM, 0);
void leastPrimeFactor(ll n)
{
    least_prime[1] = 1;

    for (ll i = 2; i <= n; i++)
    {
        if (least_prime[i] == 0)
        {
            least_prime[i] = i;
            for (ll j = 2*i; j <= n; j += i)
                if (least_prime[j] == 0)
                   least_prime[j] = i;
        }
    }
}
//int LIM=2e5+10;
int main()
{
	ll n;
	cin>>n;
	v arr(n+1,-1);
	for (ll i=1; i<=(n/2); i++)
		cin>>arr[i*2];
	leastPrimeFactor(LIM);
	v k(n+1,0);
	bool ans=true;
	for (ll i=1; i<=n/2; i++)
	{
		ll num=arr[2*i];
		if (least_prime[num]==2)
		{
			if (num%4==0)
			{
				k[2*i]=(num/2+2)/2;
				k[2*i-1]=(num/2-2)/2;
				// for (int j=1; j<=(sqrt(num)+4); j++)
				// {
				// 	if (j%2==0 && (num/j)%2==0 && j)
				// }
			}
			else
				ans=false;
		}
		else
		{
			k[2*i]=(num+1)/2;
			k[2*i-1]=(num-1)/2;
			// for (int j=1; j<=(sqrt(num)+4); j++)
			// {
			// 	if (>k[2*(i-1)] && num%j==0)
			// 	{
			// 		k[2*i]=(j+(num/j))/2;
			// 		k[2*i-1]=(j-(num/j))/2;
			// 	}
			// }
			// if (k[2*i]==0)
			// 	ans=false;
		}
	}
	for (ll i=1; i<=n; i++)
	{
		arr[i]=k[i]*k[i]-k[i-1]*k[i-1];
		if (arr[i]<=0)
			ans=false;
	}
	if (ans)
	{
		cout<<"Yes"<<endl;
		for (int i=1; i<=n; i++)
			cout<<arr[i]<<" ";
	}
	else
		cout<<"No"<<endl;
    return 0;
}


#include <bits/stdc++.h>

using namespace std;

typedef vector<int> vector_t;

typedef pair<int,int> pair_t;

struct prime_t: vector_t
{
    prime_t()
    {
        static constexpr int n = 2e5, p = sqrt(n); bitset<p+1> non_prime;

        for( int x = 2; x <= p; x++ )
            if ( not non_prime[x] )
            {
                for( int y = x*x; y <= p; y += x )
                    non_prime.set(y);

                push_back(x);
            }
    }

} prime;

struct divisors_t: vector<pair_t>
{
    divisors_t() {}

    divisors_t( const int x )
    {
        if( x & 1 )
            emplace_back( 1, x );

        const int y = sqrt(x);

        for( auto p: prime )
            if ( p >= y )
                break;
            else
                if ( x % p == 0 )
                    emplace_back(p,x/p);
    }
};

struct missing_numbers: vector<int>
{
    int m; bool possible; vector_t x; map<int,divisors_t> divisors;

    bool resolve( int i = 0, int j = 1, int k = 2 )
    {
        if ( i == m )
            return true;
        else
            for( auto [p,q]: divisors[x[i]] )
                if ( ( at(j) = (q-p)/2 ) > at(j-1) and ( at(k) = (q+p)/2, resolve(i+1, j+2, k+2) ) )
                    return true;

        return false;
    }

    missing_numbers(int n): m(n/2), possible(true), x(m), divisors()
    {
        resize(n+1), front() = 0;

        for( int i = 0; i < m and possible; i++ )
        {
            cin >> x[i];

            if ( x[i] % 2 == 0 and x[i] % 4 != 0 )
                possible = false;
            else
                if ( divisors.find(x[i]) == divisors.end() )
                    divisors.emplace(x[i],x[i]);
        }

        if ( possible )
            possible = resolve();
    }

    string solution() const
    {
        string s;

        for( int i = 0, j = 1, n = size(); j < n; i = j++ )
            s += to_string((at(j)-at(i))*(at(j)+at(i))), s += ' ';

        return s;
    }
};

int main()
{
    ios_base::sync_with_stdio( false ), cin.tie( nullptr ), cout.tie( nullptr );

     int n; cin >> n; missing_numbers y(n);

     if ( y.possible )
        cout << "Yes\n" << y.solution();
     else
        cout << "No";
}


#include <bits/stdc++.h>

using namespace std;

typedef long long ll;

struct missing_numbers: vector<ll>
{
    bool possible;

    bool resolved( int j, int k, int p, ll x )
    {
        ll q = x / p, u = (q-p)/2, v = (q+p)/2;

        at(j) = u, at(k) = v;

        return false;
    }

    bool unresolved( int j, int k )
    {
        ll x; cin >> x;

        if ( x % 2 == 0 and x % 4 != 0 )
            return true;

        if ( j == 1 )
        {
            for( int p = sqrt(x); p > 0; p-- )
                if ( x % p == 0 and ( p & 1 ) == ( (x / p) & 1 ) )
                    return resolved(j,k,p,x);
        }
        else
        {
            ll y = 2 * at(j-1), p = 2 - (x & 1), w = p * ( p + y );

            if ( w < x )
                return resolved(j,k,p,x);
        }

        return true;
    }

    missing_numbers(int n): possible(true)
    {
        resize(n+1,0);

        for( int i = 0, j = 1, k = 2, l = n / 2; i < l and possible; i++, j += 2, k += 2 )
            if ( unresolved(j,k) )
                possible = false;
    }

    string solution() const
    {
        string s;

        for( int i = 0, j = 1, n = size() - 1; i < n; i = j++ )
            s += to_string((at(j)-at(i))*(at(j)+at(i))), s += ' ';

        return s;
    }
};

int main()
{
    ios_base::sync_with_stdio( false ), cin.tie( nullptr ), cout.tie( nullptr );

     int n; cin >> n; missing_numbers y(n);

     if ( y.possible )
        cout << "Yes\n" << y.solution();
     else
        cout << "No";
}


#include <bits/stdc++.h>

using namespace std;

typedef long long ll;

struct missing_numbers: vector<ll>
{
    bool possible;

    bool resolved( int j, int k, int p, ll x )
    {
        ll q = x / p, u = (q-p)/2, v = (q+p)/2;

        at(j) = u, at(k) = v;

        return false;
    }

    bool unresolved( int j, int k )
    {
        ll x; cin >> x;

        if ( x % 2 == 0 and x % 4 != 0 )
            return true;

        if ( j == 1 )
        {
            for( int q, p = sqrt(x); p > 0; p-- )
                if ( x % p == 0 and ( p & 1 ) == ( (q = x / p) & 1 ) and p != q )
                    return resolved(j,k,p,x);
        }
        else
        {
            ll y = 2 * at(j-1), p = 2 - (x & 1), w = p * ( p + y );

            if ( w < x )
                return resolved(j,k,p,x);
        }

        return true;
    }

    missing_numbers(int n): possible(true)
    {
        resize(n+1,0);

        for( int i = 0, j = 1, k = 2, l = n / 2; i < l and possible; i++, j += 2, k += 2 )
            if ( unresolved(j,k) )
                possible = false;
    }

    string solution() const
    {
        string s;

        for( int i = 0, j = 1, n = size() - 1; i < n; i = j++ )
            s += to_string((at(j)-at(i))*(at(j)+at(i))), s += ' ';

        return s;
    }
};

int main()
{
    ios_base::sync_with_stdio( false ), cin.tie( nullptr ), cout.tie( nullptr );

     int n; cin >> n; missing_numbers y(n);

     if ( y.possible )
        cout << "Yes\n" << y.solution();
     else
        cout << "No";
}


#include <bits/stdc++.h>

using namespace std;

#define mod %

typedef long long         ll;
typedef vector<int> vector_t;
typedef pair<int,int> pair_t;

template<class T> inline T          sqr( const T x )            { return x*x; }
template<class T> inline T       parity( const T x )            { return x * T(1); }
template<class T> inline bool divisible( const T x, const T y ) { return (x mod y) == 0; }

struct prime_t: vector_t
{
    prime_t()
    {
        static const int n = 2e5, p = sqrt(n); bitset<p+1> non_prime;

        for( int x = 2; x <= p; x++ )
            if ( not non_prime[x] )
            {
                for( int y = sqr(x); y <= p; y += x )
                    non_prime.set(y);

                push_back(x);
            }
    }

} prime;

struct divisors_t: set<pair_t>
{
    divisors_t() {}

    void factorize( int u, int v, const vector_t& p, int n, int i = 0)
    {
        if ( parity(u) == parity(v) )
            emplace(u,v);

        if ( i == n )
            return;

        for( int s = u, t = v, k = p[++i]; (t mod k) == 0 and (s *= k) < (t /= k); factorize(s,t,p,i) );

        factorize(u,v,p,n,i);
    }

    divisors_t( const int x )
    {
        vector_t p;

        for( auto q: prime )
            if ( sqr(q) >= x )
                break;
            else
                if ( divisible(x,q) )
                    p.push_back(q);

        factorize(1,x,p,p.size());
    }
};

struct missing_numbers: vector<int>
{
    int m; bool possible; vector_t x; map<int,divisors_t> divisors;

    bool resolve( int i = 0, int j = 1, int k = 2 )
    {
        if ( i == m )
            return true;
        else
            for( auto [p,q]: divisors[x[i]] )
                if ( ( at(j) = (q-p)/2 ) > at(j-1) and ( at(k) = (q+p)/2, resolve(i+1, j+2, k+2) ) )
                    return true;

        return false;
    }

    missing_numbers(int n): m(n/2), possible(true), x(m), divisors()
    {
        resize(n+1), front() = 0;

        for( int i = 0; i < m and possible; i++ )
        {
            cin >> x[i];

            if ( divisible(x[i],2) and not divisible(x[i],4) )
                possible = false;
            else
                if ( divisors.find(x[i]) == divisors.end() )
                    divisors.emplace(x[i],x[i]);
        }

        if ( possible )
            possible = resolve();
    }

    string solution() const
    {
        string s; ll z;

        for( int y1, y2, i = 0, j = 1, n = size(); j < n; i = j++ )
            y1 = at(i), y2 = at(j), z = y2-y1, z *= y2+y1, s += to_string(z), s += ' ';

        return s;
    }
};

int main()
{
    ios_base::sync_with_stdio( false ), cin.tie( nullptr ), cout.tie( nullptr );

     int n; cin >> n; missing_numbers y(n);

     if ( y.possible )
        cout << "Yes\n" << y.solution();
     else
        cout << "No";
}


#include <bits/stdc++.h>

using namespace std;

typedef vector<int> vector_t;

typedef pair<int,int> pair_t;

struct prime_t: vector_t
{
    prime_t()
    {
        static constexpr int n = 2e5, p = sqrt(n); bitset<p+1> non_prime;

        for( int x = 2; x <= p; x++ )
            if ( not non_prime[x] )
            {
                for( int y = x*x; y <= p; y += x )
                    non_prime.set(y);

                push_back(x);
            }
    }

} prime;

struct divisors_t: vector<pair_t>
{
    divisors_t() {}

    divisors_t( const int x )
    {
        if( x & 1 )
            emplace_back( 1, x );

        const int y = sqrt(x);

        for( auto p: prime )
            if ( p >= y )
                break;
            else
                if ( x % p == 0 )
                    emplace_back(p,x/p);
    }
};

struct missing_numbers: vector<int>
{
    int m; bool possible; vector_t x; map<int,divisors_t> divisors;

    bool resolve( int i = 0, int j = 1, int k = 2 )
    {
        if ( i == m )
            return true;
        else
            for( auto [p,q]: divisors[x[i]] )
                if ( ( at(j) = (q-p)/2, at(k) = (q+p)/2, resolve(i+1, j+2, k+2) ) )
                    return true;

        return false;
    }

    missing_numbers(int n): m(n/2), possible(true), x(m), divisors()
    {
        resize(n+1), front() = 0;

        for( int i = 0; i < m and possible; i++ )
        {
            cin >> x[i];

            if ( x[i] % 2 == 0 and x[i] % 4 != 0 )
                possible = false;
            else
                if ( divisors.find(x[i]) == divisors.end() )
                    divisors.emplace(x[i],x[i]);
        }

        if ( possible )
            possible = resolve();
    }

    string solution() const
    {
        string s;

        for( int i = 0, j = 1, n = size(); j < n; i = j++ )
            s += to_string((at(j)-at(i))*(at(j)+at(i))), s += ' ';

        return s;
    }
};

int main()
{
    ios_base::sync_with_stdio( false ), cin.tie( nullptr ), cout.tie( nullptr );

     int n; cin >> n; missing_numbers y(n);

     if ( y.possible )
        cout << "Yes\n" << y.solution();
     else
        cout << "No";
}


#include <bits/stdc++.h>

using namespace std;

typedef long long         ll;
typedef vector<int> vector_t;
typedef pair<int,int> pair_t;

struct prime_t: vector_t
{
    prime_t()
    {
        static const int n = 2e5, p = sqrt(n); bitset<p+1> non_prime;

        for( int x = 2; x <= p; x++ )
            if ( not non_prime[x] )
            {
                for( int y = x*x; y <= p; y += x )
                    non_prime.set(y);

                push_back(x);
            }
    }

} prime;

struct divisors_t: set<pair_t>
{
    divisors_t() {}

    void factorize( int u, int v, const vector_t& p, int n, int i = 0)
    {
        if ( (u&1) == (v&1) )
            emplace(u,v);

        if ( i == n )
            return;

        int j = i+1, s = u, t = v, w = p[i];

        while(t % w == 0 and (s *= w) < (t /= w))
            factorize(s,t,p,j);

        factorize(u,v,p,n,j);
    }

    divisors_t( const int x )
    {
        vector_t p;

        for( auto q: prime )
            if ( q * q >= x )
                break;
            else
                if ( x % q == 0 )
                    p.push_back(q);

        factorize(1,x,p,p.size());
    }

    pair_t best_factors( const int r, bool first ) const
    {
        auto it = cbegin(), iu = cend(); auto [p,q] = *it;

        if ( not first )
        {
            do
            {
                if ( (p+q)/2 < r )
                    first = true;
                else
                    if ( ++it == iu )
                        break;
                    else
                        p = it->first, q = it->second;
            }
            while( not first );

            if ( not first )
                p = q = 0;
        }

        return make_pair(p,q);
    }
};

struct missing_numbers: vector<int>
{
    bool found; vector_t x; map<int,divisors_t> divisors;

    missing_numbers(int n): found(true), x(n/2), divisors()
    {
        resize(n+2), front() = back() = 0;

        for( int i = 0, m = n/2; found and i < m; ++i )
        {
            cin >> x[i];

            if ( x[i] % 2 == 0 and x[i] % 4 != 0 )
                found = false;
            else
                if ( divisors.find(x[i]) == divisors.end() )
                    divisors.emplace(x[i],x[i]);
        }

        for( int i = n/2-1, j = n-1, k = n; found and i >= 0; --i, k = --j, --j )
        {
            auto [p,q] = divisors[x[i]].best_factors(at(k+1),k==n);

            if ( p == 0 )
                found = false;
            else
                at(j) = (q-p)/2, at(k) =(q+p)/2;
        }
    }

    string solution() const
    {
        string s; ll z;

        for( auto a: *this )
            cout << a << ' ';

        cout << endl;

        for( int y1, y2, i = 0, j = 1, n = size() - 1; j < n; i = j++ )
            y1 = at(i), y2 = at(j), z = y2-y1, s += to_string(z *= (y2+y1)), s += ' ';

        return s;
    }
};

int main()
{
    ios_base::sync_with_stdio( false ), cin.tie( nullptr ), cout.tie( nullptr );

     int n; cin >> n; missing_numbers x(n);

     if ( x.found )
        cout << "Yes\n" << x.solution();
     else
        cout << "No";
}


#include <bits/stdc++.h>

using namespace std;

typedef vector<int> vector_t;

typedef pair<int,int> pair_t;

struct prime_t: vector_t
{
    prime_t()
    {
        static constexpr int n = 2e5, p = sqrt(n); bitset<p+1> non_prime;

        for( int x = 2; x <= p; x++ )
            if ( not non_prime[x] )
            {
                for( int y = x*x; y <= p; y += x )
                    non_prime.set(y);

                push_back(x);
            }
    }

} prime;

struct divisors_t: vector<pair_t>
{
    divisors_t() {}

    divisors_t( const int x )
    {
        if( x & 1 )
            emplace_back( 1, x );

        int q, y = sqrt(x);

        for( auto p: prime )
            if ( p > y )
                break;
            else
                if ( x % p == 0 and ( q = x/p ) > p )
                    emplace_back(p,x/p);
    }
};

struct missing_numbers: vector<int>
{
    int m; bool possible; vector_t x; map<int,divisors_t> divisors;

    bool resolve( int i = 0, int j = 1, int k = 2 )
    {
        if ( i == m )
            return true;
        else
            for( auto [p,q]: divisors[x[i]] )
                if ( ( at(j) = (q-p)/2 ) > at(j-1) and ( at(k) = (q+p)/2, resolve(i+1, j+2, k+2) ) )
                    return true;

        return false;
    }

    missing_numbers(int n): m(n/2), possible(true), x(m), divisors()
    {
        resize(n+1), front() = 0;

        for( int i = 0; i < m and possible; i++ )
        {
            cin >> x[i];

            if ( x[i] % 2 == 0 and x[i] % 4 != 0 )
                possible = false;
            else
                if ( divisors.find(x[i]) == divisors.end() )
                    divisors.emplace(x[i],x[i]);
        }

        if ( possible )
            possible = resolve();
    }

    string solution() const
    {
        string s;

        for( int i = 0, j = 1, n = size(); j < n; i = j++ )
            s += to_string((at(j)-at(i))*(at(j)+at(i))), s += ' ';

        return s;
    }
};

int main()
{
    ios_base::sync_with_stdio( false ), cin.tie( nullptr ), cout.tie( nullptr );

     int n; cin >> n; missing_numbers y(n);

     if ( y.possible )
        cout << "Yes\n" << y.solution();
     else
        cout << "No";
}


#include <bits/stdc++.h>

using namespace std;

typedef long long ll;

struct prime_t: vector<int>
{
    static constexpr ll N = 1e13, p = sqrt(N);

    prime_t()
    {
        bitset<p+1> non_prime;

        for( ll x = 2; x <= p; x++ )
            if ( not non_prime[x] )
            {
                for( ll y = x*x; y <= p; y += x )
                    non_prime.set(y);

                push_back(x);
            }
    }

} prime;

inline ll least_divisor( ll x )
{
    for( auto p: prime )
        if ( x % p == 0 )
        {
            if ( p * p < x )
                return p;
            else
                break;
        }

    return 1;
}

struct missing_numbers: vector<ll>
{
    bool possible;

    bool resolved( int j, int k, int p, ll x )
    {
        ll q = x / p, u = (q-p)/2, v = (q+p)/2;

        at(j) = u, at(k) = v;

        return false;
    }

    bool unresolved( int j, int k )
    {
        ll x; cin >> x;

        if ( x % 2 == 0 and x % 4 != 0 )
            return true;

        if ( j == 1 )
        {
            for( int q, p = sqrt(x); p > 0; p-- )
                if ( x % p == 0 and ( p & 1 ) == ( (q = x / p) & 1 ) and p != q )
                    return resolved(j,k,p,x);
        }
        else
        {
            ll y = 2 * at(j-1), p = least_divisor(x), w = p * ( p + y );

            if ( w < x )
                return resolved(j,k,p,x);
        }

        return true;
    }

    missing_numbers(int n): possible(true)
    {
        resize(n+1,0);

        for( int i = 0, j = 1, k = 2, l = n / 2; i < l and possible; i++, j += 2, k += 2 )
            if ( unresolved(j,k) )
                possible = false;
    }

    string solution() const
    {
        string s;

        for( int i = 0, j = 1, n = size() - 1; i < n; i = j++ )
            s += to_string((at(j)-at(i))*(at(j)+at(i))), s += ' ';

        return s;
    }
};

int main()
{
    ios_base::sync_with_stdio( false ), cin.tie( nullptr ), cout.tie( nullptr );

     int n; cin >> n; missing_numbers y(n);

     if ( y.possible )
        cout << "Yes\n" << y.solution();
     else
        cout << "No";
}


#include <bits/stdc++.h>

using namespace std;

typedef long long         ll;
typedef vector<int> vector_t;
typedef pair<int,int> pair_t;

struct prime_t: vector_t
{
    prime_t()
    {
        static const int n = 2e5, p = sqrt(n); bitset<p+1> non_prime;

        for( int x = 2; x <= p; x++ )
            if ( not non_prime[x] )
            {
                for( int y = x*x; y <= p; y += x )
                    non_prime.set(y);

                push_back(x);
            }
    }

} prime;

struct divisors_t: set<pair_t>
{
    divisors_t() {}

    void factorize( int u, int v, const vector_t& p, int n, int i = 0)
    {
        if ( (u&1) == (v&1) )
            emplace(u,v);

        if ( i == n )
            return;

        int j = i+1, s = u, t = v, w = p[i];

        while(t % w == 0 and (s *= w) < (t /= w))
            factorize(s,t,p,j);

        factorize(u,v,p,n,j);
    }

    divisors_t( const int x )
    {
        vector_t p;

        for( auto q: prime )
            if ( q * q >= x )
                break;
            else
                if ( x % q == 0 )
                    p.push_back(q);

        factorize(1,x,p,p.size());
    }

    pair_t best_factors( const int r, bool first ) const
    {
        auto it = cbegin(), iu = cend(); auto [p,q] = *it;

        if ( not first )
        {
            do
            {
                if ( (p+q)/2 < r )
                    first = true;
                else
                    if ( ++it == iu )
                        break;
                    else
                        p = it->first, q = it->second;
            }
            while( not first );

            if ( not first )
                p = q = 0;
        }

        return make_pair(p,q);
    }
};

struct missing_numbers: vector<int>
{
    bool found; vector_t x; map<int,divisors_t> divisors; vector<ll> z;

    missing_numbers(int n): found(true), x(n/2), divisors(), z(n)
    {
        resize(n+2), front() = back() = 0;

        for( int i = 0, m = n/2; found and i < m; ++i )
        {
            cin >> x[i];

            if ( x[i] % 2 == 0 and x[i] % 4 != 0 )
                found = false;
            else
                if ( divisors.find(x[i]) == divisors.end() )
                    divisors.emplace(x[i],x[i]);
        }

        for( int i = n/2-1, j = n-1, k = n; found and i >= 0; --i, k = --j, --j )
        {
            auto [p,q] = divisors[x[i]].best_factors(at(k+1),k==n);

            if ( p == 0 )
                found = false;
            else
                at(j) = (q-p)/2, at(k) =(q+p)/2;
        }

        for( int y1, y2, i = 0, j = 1; found and i < n; i = j++ )
            if ( ( y1 = at(i), y2 = at(j), z[i] = y2-y1, z[i] *= (y2+y1) ) < 1 or z[i] > 10000000000LL )
                found = false;
    }

    string solution() const
    {
        string s = to_string(z[0]);

        for( int i = 1, n = z.size(); i < n; ++i )
            s += ' ', s += to_string(z[i]);

        return s;
    }
};

int main()
{
    ios_base::sync_with_stdio( false ), cin.tie( nullptr ), cout.tie( nullptr );

     int n; cin >> n; missing_numbers x(n);

     if ( x.found )
        cout << "Yes\n" << x.solution();
     else
        cout << "No";
}


#include <bits/stdc++.h>

using namespace std;

typedef long long         ll;
typedef vector<int> vector_t;
typedef pair<int,int> pair_t;

struct prime_t: vector_t
{
    prime_t()
    {
        static const int n = 2e5, p = sqrt(n); bitset<p+1> non_prime;

        for( int x = 2; x <= p; x++ )
            if ( not non_prime[x] )
            {
                for( int y = x*x; y <= p; y += x )
                    non_prime.set(y);

                push_back(x);
            }
    }

} prime;

struct divisors_t: set<pair_t>
{
    divisors_t() {}

    void factorize( int u, int v, const vector_t& p, int n, int i = 0)
    {
        if ( (u&1) == (v&1) )
            emplace(u,v);

        if ( i == n )
            return;

        int j = i+1, s = u, t = v, w = p[i];

        while(t % w == 0 and (s *= w) < (t /= w))
            factorize(s,t,p,j);

        factorize(u,v,p,n,j);
    }

    divisors_t( const int x )
    {
        vector_t p;

        for( auto q: prime )
            if ( q * q >= x )
                break;
            else
                if ( x % q == 0 )
                    p.push_back(q);

        factorize(1,x,p,p.size());
    }

    pair_t best_factors( const int r, bool first ) const
    {
        auto it = cbegin(), iu = cend(); auto [p,q] = *it;

        if ( not first )
        {
            do
            {
                if ( (p+q)/2 < r )
                    first = true;
                else
                    if ( ++it == iu )
                        break;
                    else
                        p = it->first, q = it->second;
            }
            while( not first );

            if ( not first )
                p = q = 0;
        }

        return make_pair(p,q);
    }
};

struct missing_numbers: vector<int>
{
    bool found; vector_t x; map<int,divisors_t> divisors;

    missing_numbers(int n): found(true), x(n/2), divisors()
    {
        resize(n+2), front() = back() = 0;

        for( int i = 0, m = n/2; found and i < m; ++i )
        {
            cin >> x[i];

            if ( x[i] % 2 == 0 and x[i] % 4 != 0 )
                found = false;
            else
                if ( divisors.find(x[i]) == divisors.end() )
                    divisors.emplace(x[i],x[i]);
        }

        for( int i = n/2-1, j = n-1, k = n; found and i >= 0; --i, k = --j, --j )
        {
            auto [p,q] = divisors[x[i]].best_factors(at(k+1),k==n);

            if ( p == 0 )
                found = false;
            else
                at(j) = (q-p)/2, at(k) =(q+p)/2;
        }
    }

    string solution() const
    {
        string s; ll z;

        for( int y1, y2, i = 0, j = 1, n = size() - 1; j < n; i = j++ )
            y1 = at(i), y2 = at(j), z = y2-y1, s += to_string(z *= (y2+y1)), s += ' ';

        return s;
    }
};

int main()
{
    ios_base::sync_with_stdio( false ), cin.tie( nullptr ), cout.tie( nullptr );

     int n; cin >> n; missing_numbers x(n);

     if ( x.found )
        cout << "Yes\n" << x.solution();
     else
        cout << "No";
}


#include <bits/stdc++.h>

using namespace std;

typedef vector<int> vector_t;

typedef pair<int,int> pair_t;

struct prime_t: vector_t
{
    prime_t()
    {
        static const int n = 2e5, p = sqrt(n); bitset<p+1> non_prime;

        for( int x = 2; x <= p; x++ )
            if ( not non_prime[x] )
            {
                for( int y = x*x; y <= p; y += x )
                    non_prime.set(y);

                push_back(x);
            }
    }

} prime;

struct divisors_t: set<pair_t>
{
    divisors_t() {}

    void factorize( int u, int v, const vector_t& p, int n, int i = 0)
    {
        if ( (u&1) == (v&1) )
            emplace(u,v);

        if ( i == n )
            return;

        int j = i+1, s = u, t = v, w = p[i];

        while(t % w == 0 and (s *= w) < (t /= w))
            factorize(s,t,p,j);

        factorize(u,v,p,n,j);
    }

    divisors_t( const int x )
    {
        vector_t p;

        for( auto q: prime )
            if ( q * q >= x )
                break;
            else
                if ( x % q == 0 )
                    p.push_back(q);

        factorize(1,x,p,p.size());
    }
};

struct missing_numbers: vector<int>
{
    int m; bool possible; vector_t x; map<int,divisors_t> divisors;

    bool resolve( int i = 0, int j = 1, int k = 2 )
    {
        if ( i == m )
            return true;
        else
            for( auto [p,q]: divisors[x[i]] )
                if ( ( at(j) = (q-p)/2 ) > at(j-1) and ( at(k) = (q+p)/2, resolve(i+1, j+2, k+2) ) )
                    return true;

        return false;
    }

    missing_numbers(int n): m(n/2), possible(true), x(m), divisors()
    {
        resize(n+1), front() = 0;

        for( int i = 0; i < m and possible; i++ )
        {
            cin >> x[i];

            if ( x[i] % 2 == 0 and x[i] % 4 != 0 )
                possible = false;
            else
                if ( divisors.find(x[i]) == divisors.end() )
                    divisors.emplace(x[i],x[i]);
        }

        if ( possible )
            possible = resolve();
    }

    string solution() const
    {
        string s;

        for( int y1, y2, i = 0, j = 1, n = size(); j < n; i = j++ )
            y1 = at(j), y2 = at(i), s += to_string((y2-y1)*(y2+y1)), s += ' ';

        return s;
    }
};

int main()
{
    ios_base::sync_with_stdio( false ), cin.tie( nullptr ), cout.tie( nullptr );

     int n; cin >> n; missing_numbers y(n);

     if ( y.possible )
        cout << "Yes\n" << y.solution();
     else
        cout << "No";
}


#include <bits/stdc++.h>

using namespace std;

typedef vector<int> vector_t;

typedef pair<int,int> pair_t;

struct prime_t: vector_t
{
    prime_t()
    {
        static const int n = 2e5, p = sqrt(n); bitset<p+1> non_prime;

        for( int x = 2; x <= p; x++ )
            if ( not non_prime[x] )
            {
                for( int y = x*x; y <= p; y += x )
                    non_prime.set(y);

                push_back(x);
            }
    }

} prime;

struct divisors_t: set<pair_t>
{
    divisors_t() {}

    void factorize( int u, int v, const vector_t& p, int n, int i = 0)
    {
        if ( (u&1) == (v&1) )
            emplace(u,v);

        if ( i == n )
            return;

        int j = i+1, s = u, t = v, w = p[i];

        while(t % w == 0 and (s *= w) < (t /= w))
            factorize(s,t,p,j);

        factorize(u,v,p,n,j);
    }

    divisors_t( const int x )
    {
        vector_t p;

        for( auto q: prime )
            if ( q * q >= x )
                break;
            else
                if ( x % q == 0 )
                    p.push_back(q);

        factorize(1,x,p,p.size());
    }
};

struct missing_numbers: vector<int>
{
    int m; bool possible; vector_t x; map<int,divisors_t> divisors;

    bool resolve( int i = 0, int j = 1, int k = 2 )
    {
        if ( i == m )
            return true;
        else
            for( auto [p,q]: divisors[x[i]] )
                if ( ( at(j) = (q-p)/2 ) > at(j-1) and ( at(k) = (q+p)/2, resolve(i+1, j+2, k+2) ) )
                    return true;

        return false;
    }

    missing_numbers(int n): m(n/2), possible(true), x(m), divisors()
    {
        resize(n+1), front() = 0;

        for( int i = 0; i < m and possible; i++ )
        {
            cin >> x[i];

            if ( x[i] % 2 == 0 and x[i] % 4 != 0 )
                possible = false;
            else
                if ( divisors.find(x[i]) == divisors.end() )
                    divisors.emplace(x[i],x[i]);
        }

        if ( possible )
            possible = resolve();
    }

    string solution() const
    {
        string s;

        for( int y1, y2, i = 0, j = 1, n = size(); j < n; i = j++ )
            y1 = at(i), y2 = at(j), s += to_string((y2-y1)*(y2+y1)), s += ' ';

        return s;
    }
};

int main()
{
    ios_base::sync_with_stdio( false ), cin.tie( nullptr ), cout.tie( nullptr );

     int n; cin >> n; missing_numbers y(n);

     if ( y.possible )
        cout << "Yes\n" << y.solution();
     else
        cout << "No";
}


#include <bits/stdc++.h>

using namespace std;

typedef long long         ll;
typedef vector<int> vector_t;
typedef pair<int,int> pair_t;

struct prime_t: vector_t
{
    prime_t()
    {
        static const int n = 2e5, p = sqrt(n); bitset<p+1> non_prime;

        for( int x = 2; x <= p; x++ )
            if ( not non_prime[x] )
            {
                for( int y = x*x; y <= p; y += x )
                    non_prime.set(y);

                push_back(x);
            }
    }

} prime;

struct divisors_t: set<pair_t>
{
    divisors_t() {}

    void factorize( int u, int v, const vector_t& p, int n, int i = 0)
    {
        if ( (u&1) == (v&1) )
            emplace(u,v);

        if ( i == n )
            return;

        int j = i+1, s = u, t = v, w = p[i];

        while(t % w == 0 and (s *= w) < (t /= w))
            factorize(s,t,p,j);

        factorize(u,v,p,n,j);
    }

    divisors_t( const int x )
    {
        vector_t p;

        for( auto q: prime )
            if ( q * q >= x )
                break;
            else
                if ( x % q == 0 )
                    p.push_back(q);

        factorize(1,x,p,p.size());
    }
};

struct missing_numbers: vector<int>
{
    int m; bool possible; vector_t x; map<int,divisors_t> divisors;

    bool resolve( int i = 0, int j = 1, int k = 2 )
    {
        if ( i == m )
            return true;
        else
            for( auto [p,q]: divisors[x[i]] )
                if ( ( at(j) = (q-p)/2 ) > at(j-1) and ( at(k) = (q+p)/2, resolve(i+1, j+2, k+2) ) )
                    return true;

        return false;
    }

    missing_numbers(int n): m(n/2), possible(true), x(m), divisors()
    {
        resize(n+1), front() = 0;

        for( int i = 0; i < m and possible; i++ )
        {
            cin >> x[i];

            if ( x[i] % 2 == 0 and x[i] % 4 != 0 )
                possible = false;
            else
                if ( divisors.find(x[i]) == divisors.end() )
                    divisors.emplace(x[i],x[i]);
        }

        if ( possible )
            possible = resolve();
    }

    string solution() const
    {
        string s; ll z;

        for( int y1, y2, i = 0, j = 1, n = size(); j < n; i = j++ )
            y1 = at(i), y2 = at(j), z = y2-y1, s += to_string(z *= y2+y1), s += ' ';

        return s;
    }
};

int main()
{
    ios_base::sync_with_stdio( false ), cin.tie( nullptr ), cout.tie( nullptr );

     int n; cin >> n; missing_numbers y(n);

     if ( y.possible )
        cout << "Yes\n" << y.solution();
     else
        cout << "No";
}


#include<iostream>
using namespace std;
long long int a[100000 + 1], temp1 = 0, temp2 = 0;
int main() {
	int n; cin >> n;
	for (auto i = 1; i <= n; i += 2) {
		cin >> a[i + 1];
		for (long long int j = temp1 + 1; ; j += 1) {
			if (floor(sqrt(j * j + a[i + 1])) == ceil(sqrt(j * j + a[i + 1]))) {
				a[i] = j * j - temp1 * temp1; temp1 = sqrt(j * j + a[i + 1]);
				break;
			}
			if (j * j - (j - 1) * (j - 1) > a[i + 1]) {
				temp2 = j;
				break;
			}
		}
		if (temp2) {
			cout << "No" << "\n"; break;
		}
	}
	if (!temp2) {
		cout << "Yes" << "\n";
		for (auto i = 1; i <= n; i += 1)
			cout << a[i] << " ";
		cout << "\n";
	}
}


#include<iostream>
using namespace std;
int a[100000 + 1], temp1 = 0, temp2 = 0;
int main() {
	int n; cin >> n;
	for (auto i = 1; i <= n; i += 2) {
		cin >> a[i + 1];
		for (auto j = temp1 + 1; ; j += 1) {
			if (floor(sqrt(j * j + a[i + 1])) == ceil(sqrt(j * j + a[i + 1]))) {
				a[i] = j * j - temp1 * temp1; temp1 = sqrt(j * j + a[i + 1]);
				break;
			}
			if (j * j - (j - 1) * (j - 1) > a[i + 1]) {
				temp2 = j;
				break;
			}
		}
		if (temp2) {
			cout << "No" << "\n"; break;
		}
	}
	if (!temp2) {
		cout << "Yes" << "\n";
		for (auto i = 1; i <= n; i += 1)
			cout << a[i] << " ";
		cout << "\n";
	}
}


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

typedef long long ll;

using namespace std;

const int MAXN = 100000;

int n;
ll X[MAXN];

void solve()
{
	int n, m, k;
	scanf("%d", &n);
	ll y = 0;
	for (int i=0; i<n; i+=2)
	{
		scanf("%I64d", &X[i+1]);
		ll x = X[i+1];
		ll a = y+1;
		ll yn = a*a;
		ll yd = 0;
		ll b;
		for (b = y+2; ; ++b)
		{
			yn += b+b-1;
			yd += b+b-1;
			if (yn>10000000000000LL)
			{
				printf("No\n");
				return;
			}
			while(yd > x)
			{
				yd -= a+a+1;
				++a;
			}
			if (yd == x)
				break;
		}
		X[i+0] = a*a-y*y;
		y = b;
	}
	printf("Yes\n");
	for (int i=0; i<n; ++i)
		printf("%I64d ", X[i]);
}

int main()
{
	solve();
	return 0;
}


#include <iostream>
#include <vector>
#include <string>
#include <map>
#include <algorithm>
#include <queue>
#include <stdio.h>
#include <iostream>
#include <vector>
#include <string>
#include <set>
#include <math.h>

#pragma warning (disable:4996)
using namespace std;

long long x[100007];
int main() {
#ifdef _DEBUG
    freopen("input.txt", "r", stdin);
    freopen("output.txt", "w", stdout);
#endif
    long long n, m, k;
    cin >> n;
    for (int i = 1; i < n; i += 2) {
        cin >> x[i];
    }
    long long last = 0;
    for (int i = 0; i < n; i += 2) {
        long long c = x[i + 1], xx;
        if (c % 2 == 1) {
            xx = (c - 1) / 2;
        } else {
            if (c % 4 != 0) {
                cout << "No";
                return 0;
            }
            xx = (c / 2 - 2) / 2;
        }
        x[i] = xx * xx - last;
        last += x[i] + x[i + 1];
    }
    cout << "Yes" << endl;
    for (int i = 0; i < n; ++i) {
        cout << x[i] << ' ';
    }
    return 0;
}


#include <iostream>
#include <vector>
#include <string>
#include <map>
#include <algorithm>
#include <queue>
#include <stdio.h>
#include <iostream>
#include <vector>
#include <string>
#include <set>
#include <math.h>

#pragma warning (disable:4996)
using namespace std;

long long find(int c, long long last) {
    long long x, y, ans = 2e18, xx;
    for (int i = 1; i <= sqrt(double(c)); ++i) {
        if (c % i == 0) {
            x = c / i;
            y = i;
            xx = (x - y) / 2;
            if ((x - y) % 2 == 0 && xx * xx > last) {
                ans = min(ans, xx);
            }
        }
    }
    return ans;
}

long long x[100007];
int main() {
#ifdef _DEBUG
    freopen("input.txt", "r", stdin);
    freopen("output.txt", "w", stdout);
#endif
    long long n, m, k;
    cin >> n;
    for (int i = 1; i < n; i += 2) {
        cin >> x[i];
    }
    long long last = 0;
    for (int i = 0; i < n; i += 2) {
        long long c = x[i + 1], xx;
        xx = find(c, last);
        if (xx == 2e18) {
            cout << "No";
            return 0;
        }
        x[i] = xx * xx - last;
        last += x[i] + x[i + 1];
    }
    cout << "Yes" << endl;
    for (int i = 0; i < n; ++i) {
        cout << x[i] << ' ';
    }
    return 0;
}


#include <iostream>
#include <vector>
#include <string>
#include <map>
#include <algorithm>
#include <queue>
#include <stdio.h>
#include <iostream>
#include <vector>
#include <string>
#include <set>
#include <math.h>

#pragma warning (disable:4996)
using namespace std;

long long x[100007];
int main() {
#ifdef _DEBUG
    freopen("input.txt", "r", stdin);
    freopen("output.txt", "w", stdout);
#endif
    long long n, m, k;
    cin >> n;
    for (int i = 1; i < n; i += 2) {
        cin >> x[i];
    }
    long long last = 0;
    for (int i = 0; i < n; i += 2) {
        int c = x[i + 1], xx;
        if (c % 2 == 1) {
            xx = (c - 1) / 2;
        } else {
            if (c % 4 != 0) {
                cout << "No";
                return 0;
            }
            xx = (c / 2 - 2) / 2;
        }
        x[i] = xx * xx - last;
        last += x[i] + x[i + 1];
    }
    cout << "Yes" << endl;
    for (int i = 0; i < n; ++i) {
        cout << x[i] << ' ';
    }
    return 0;
}


#include <iostream>
#include <vector>
#include <string>
#include <map>
#include <algorithm>
#include <queue>
#include <stdio.h>
#include <iostream>
#include <vector>
#include <string>
#include <set>
#include <math.h>

#pragma warning (disable:4996)
using namespace std;

long long x[100007];
int main() {
#ifdef _DEBUG
    freopen("input.txt", "r", stdin);
    freopen("output.txt", "w", stdout);
#endif
    long long n, m, k;
    cin >> n;
    for (int i = 1; i < n; i += 2) {
        cin >> x[i];
    }
    long long last = 0;
    for (int i = 0; i < n; i += 2) {
        long long c = x[i + 1], xx;
        if (c % 2 == 1) {
            xx = (c - 1) / 2;
        } else {
            if (c % 4 != 0) {
                cout << "No";
                return 0;
            }
            xx = (c / 2 - 2) / 2;
        }
        x[i] = xx * xx - last;
        if (x[i] <= 0) {
            cout << "No";
            return 0;
        }
        last += x[i] + x[i + 1];
    }
    cout << "Yes" << endl;
    for (int i = 0; i < n; ++i) {
        cout << x[i] << ' ';
    }
    return 0;
}


#define _USE_MATH_DEFINES
#include <assert.h>
#include <limits.h>
#include <math.h>
#include <memory.h>
#include <algorithm>
#include <bitset>
#include <vector>
#include <string>
#include <list>
#include <set>
#include <map>
#include <unordered_map>
#include <unordered_set>
#include <queue>
#include <sstream>
#include <iostream>
#include <fstream>
#include <iomanip>

using namespace std;
typedef long long     ll;
typedef unsigned int  UInt;
#define ALL(a)          (a).begin(), (a).end()
#define FOR(i,a,b)      for(int i = a;   i <  (int)(b); ++i)
#define FOR_REV(i,a,b)  for(int i = b-1; i >= (int)(a); --i)
#define FOR_EACH(it,a)  for(remove_reference<decltype(a)>::type::iterator it = (a).begin(); it != (a).end(); ++it)
#define FOR_EACH_REV(it,a) for(remove_reference<decltype(a)>::type::reverse_iterator it = (a).rbegin(); it != (a).rend(); ++it)
#define FOR_EACH_CONST(it,a) for(remove_reference<decltype(a)>::type::const_iterator it = (a).begin(); it != (a).end(); ++it)
#define FOR_EACH_CONST_REV(it,a) for(remove_reference<decltype(a)>::type::const_reverse_iterator it = (a).rbegin(); it != (a).rend(); ++it)
template<class T> inline T   sqr(T v)  { return v * v; }
template<class T> inline int sign(T v) { return v == 0 ? 0 : (v > 0 ? 1 : -1); }
template<class T> inline int round_i(T t) { return int(t < 0 ? t-0.5f : t+0.5f); } //округлить до ближайшего целого
template<class T> inline int get_bit(T v, int bit_index) { return (v >> bit_index) & 1; } //return {0,1}
template<class T> inline T   gcd(T a, T b) { while(b) { T t = b; b   = a % b; a   = t; } return a; }
#define IN_INT(a)            int a;       is >> a;
#define IN_INT2(a,b)         int a,b;     is >> a >> b;
#define IN_INT3(a,b,c)       int a,b,c;   is >> a >> b >> c;
#define IN_INT4(a,b,c,d)     int a,b,c,d; is >> a >> b >> c >> d;
#define IN_LL(a)             ll a;        is >> a;
#define IN_LL2(a,b)          ll a,b;      is >> a >> b;
#define IN_LL3(a,b,c)        ll a,b,c;    is >> a >> b >> c;
#define IN_LL4(a,b,c,d)      ll a,b,c,d;  is >> a >> b >> c >> d;
#define IN_CHAR(c)           char c;      is >> c;
#define IN_STR(s)            string s;    is >> s;

//////////////////////////////////////////////////////////////////////////
bool io_interactive = true;

istream& input()
{
  ios_base::sync_with_stdio(false);
  if (io_interactive)
    return cin;
#ifdef INPUT_FROM_FILE
  static ifstream is("CodeForces/input.txt");
  return is;
#endif
  if (!io_interactive)
    cin.tie(NULL);
  return cin;
}

ostream& output()
{
  cout << setprecision(15);
  if (!io_interactive)
    cout.tie(NULL);
  return cout;
}

template<class T>
ostream& out_array(ostream& os, const vector<T>& v, bool with_size = true, bool size_on_separate_line = true, bool each_value_on_separate_line = false)
{
  if (with_size)
    os << v.size() << (size_on_separate_line?"\n":" ");
  FOR_EACH_CONST (it, v)
    os << *it << (each_value_on_separate_line?"\n":" ");
  return os;
}

template <typename T>
void init_v2(vector<vector<T>>& v, int lx, int ly, const T& val = T())
{
  v.resize(lx);
  FOR (i,0,lx)
    v[i].resize(ly, val);
};

//////////////////////////////////////////////////////////////////////////

//////////////////////////////////////////////////////////////////////////
//////////////////////////////////////////////////////////////////////////

//////////////////////////////////////////////////////////////////////////
////a
//void main()
//{
//  io_interactive = false;
//  istream& is = input();
//  ostream& os = output();
//
//  IN_INT(n);
//  os << (n<=2?n:1);
//}

//////////////////////////////////////////////////////////////////////////
//b
//void main()
//{
//  io_interactive = false;
//  istream& is = input();
//  ostream& os = output();
//
//  IN_INT(n);
//
//  vector<int> a(n),b(n);
//  map<int,vector<int>> m;
//  FOR (i,0,n)
//  {
//    is >> a[i];
//    m[a[i]].push_back(i);
//  }
//
//  int c = 1;
//  FOR_EACH (it,m)
//  {
//    int same = n-it->first;
//    if (it->second.size()%same)
//    {
//      b.clear();
//      break;
//    }
//    for (int i = 0; i<it->second.size() ; ++c,i+=same)
//      FOR (j,0,same)
//        b[it->second[i+j]] = c;
//  }
//
//  if (b.empty())
//    os<<"Impossible";
//  else
//  {
//    os<<"Possible\n";
//    out_array(os,b,false);
//  }
//}

//////////////////////////////////////////////////////////////////////////
////c
//int mod =  998244353;
//void main()
//{
//  io_interactive = false;
//  istream& is = input();
//  ostream& os = output();
//
//  IN_INT3(n,m,k);
//
//  vector<vector<int>> dp;
//  init_v2(dp,n+1,n+1,0);
//  dp[0][0] = m;
//  FOR (i,0,n)
//  {
//    FOR (j,0,n)
//    {
//      dp[i+1][j]=(dp[i+1][j]+dp[i][j])%mod;
//      dp[i+1][j+1]=(dp[i+1][j+1]+(ll)(m-1)*dp[i][j])%mod;
//    }
//  }
//  os<<dp[n-1][k];
//}

////////////////////////////////////////////////////////////////////////////
////d
//void main()
//{
//  io_interactive = false;
//  istream& is = input();
//  ostream& os = output();
//
//  IN_INT3(n,m,k);
//
//  vector<int> a(k),w(n,0);
//  FOR (i,0,k)
//  {
//    is >> a[i];
//    --a[i];
//    w[a[i]]=1;
//  }
//
//  map<int,vector<pair<int,int>>> e;
//  FOR (i,0,m)
//  {
//    IN_INT3(u,v,w);;
//    --u,--v;
//    e[w].push_back(make_pair(u,v));
//  }
//
//
//  DSUWithWeight dsu(w);
//
//  FOR_EACH (it,e)
//  {
//    int w = it->first;
//    FOR_EACH (it1,it->second)
//    {
//      int u = it1->first;
//      int v = it1->second;
//      int c = dsu.unite(u,v);
//      if (dsu.weight(c)==k)
//      {
//        FOR(i,0,k)
//          os<<w<< " ";
//        return;
//      }
//    }
//  }
//}

//////////////////////////////////////////////////////////////////////////
//e
void main()
{
  io_interactive = false;
  istream& is = input();
  ostream& os = output();

  IN_INT(n);
  vector<int> xx(n/2);
  vector<ll> y;
  FOR (i,0,n/2)
    is >> xx[i];

  ll last = 0;
  FOR (i,0,xx.size())
  {
    int x = xx[i];
    //d = (b-a)(b+a) = b0(b0 + 2a)
    //FOR (b0,1,x)
    //{
    //  так не ищется min b
    //  if (b0*b0>=x)
    //  {
    //    y.clear();
    //    break;
    //  }
    FOR_REV (b0,1,sqrt((double)x)+1)
    {
      if (x%b0==0)
      {
        int a2 = x/b0-b0;
        if (a2>0&&(a2&1)==0)
        {
          int a = a2>>1;
          int b = b0+a;
          if ((ll)a*a > last)
          {
            y.push_back((ll)a*a-last);
            last = (ll)b*b;
            break;
          }
        }
      }
    }

    if (y.size()!=i+1)
    {
      os<<"No";
      return;
    }
  }

  os<<"Yes\n";
  FOR (i,0,n/2)
    os << y[i] << " "<<xx[i]<<" ";
}

//////////////////////////////////////////////////////////////////////////
////f - для четных n  - прав-но
////для нечетных в эдиториале написано решение - делим на отрезки разной четности выбирая два подряд идущих, так можно определить в каком произошел xor
//void main()
//{
//  io_interactive = true;
//  istream& is = input();
//  ostream& os = output();
//
//  IN_INT2(n,t);
//
//  vector<int> a(n,0);
//  if ((n&1)==0)
//  {
//    int p = 0;
//    FOR (i,0,n)
//    {
//      for (int num=0;;++num)
//      {
//        os<<"? "<<i+1<< " "<<i+1<<endl;
//        IN_INT (t1);
//        os<<"? "<<i+1<< " "<<i+1<<endl;
//        IN_INT (t2);
//
//        if (t2==t)
//        {
//          //оба одинак - стало как было
//        }
//        else
//        {
//          //оба разные - инвертир все кроме i-го
//          a[i] = (p^(t2 == n-t-1?0:1));
//          p^=1;
//          t=t2;
//          //for (int t = t2; ;)
//          //{
//          //  os<<"? "<<i+1<< " "<<i+1<<endl;
//          //  IN_INT (t1);
//          //  os<<"? "<<i+1<< " "<<i+1<<endl;
//          //  IN_INT (t2);
//          //  if (t2 != t)
//          //    break;
//          //}
//          break;
//        }
//      }
//    }
//  }
//  else
//  {
//    int p = 0,inv=0;
//    FOR (i,0,n)
//    {
//      os<<"? "<<i+1<< " "<<i+1<<endl;
//      IN_INT (t1);
//
//      if (t1==i+t-2*p)
//      {
//        a[i]=inv;
//        p=i-p;
//      }
//      else if (t1==n+2*p-t-i)
//      {
//        a[i]=inv;
//        inv^=1;
//      }
//      else if (t1==i+t-2*p-1)
//      {
//        a[i]=1^inv;
//        p=i-p;
//        //++p;
//      }
//      else
//      {
//        a[i]=1^inv;
//        //++p;
//        inv^=1;
//      }
//      t=t1;
//    }
//  }
//
//
//  os<<"! ";
//  FOR_EACH(it,a)
//    os<<*it;
//}

//////////////////////////////////////////////////////////////////////////

//void main()
//{
//  io_interactive = false;
//  istream& is = input();
//  ostream& os = output();
//
//  IN_INT(n);
//
//  //vector<int> a(n);
//  //FOR (i,0,n)
//  //  is >> a[i];
//
//  //int res = 0;
//  //os << res;
//}


#define DEBUG 0

#include <unordered_set>
#include <algorithm>
#include <functional>
#include <numeric>
#include <iostream>
#include <iomanip>
#include <cstdio>
#include <cmath>
#include <complex>
#include <cstdlib>
#include <ctime>
#include <cstring>
#include <cassert>
#include <string>
#include <vector>
#include <list>
#include <map>
#include <set>
#include <deque>
#include <queue>
#include <stack>
#include <bitset>
#include <sstream>
using namespace std;

#define LL long long
#define LD long double
#define PR pair<int,int>

#define Fox(i,n) for (i=0; i<n; i++)
#define Fox1(i,n) for (i=1; i<=n; i++)
#define FoxI(i,a,b) for (i=a; i<=b; i++)
#define FoxR(i,n) for (i=(n)-1; i>=0; i--)
#define FoxR1(i,n) for (i=n; i>0; i--)
#define FoxRI(i,a,b) for (i=b; i>=a; i--)
#define Foxen(i,s) for (i=s.begin(); i!=s.end(); i++)
#define Min(a,b) a=min(a,b)
#define Max(a,b) a=max(a,b)
#define Sz(s) int((s).size())
#define All(s) (s).begin(),(s).end()
#define Fill(s,v) memset(s,v,sizeof(s))
#define pb push_back
#define mp make_pair
#define x first
#define y second

template<typename T> T Abs(T x) { return(x<0 ? -x : x); }
template<typename T> T Sqr(T x) { return(x*x); }
string plural(string s) { return(Sz(s) && s[Sz(s)-1]=='x' ? s+"en" : s+"s"); }

const int INF = (int)1e9;
const LD EPS = 1e-12;
const LD PI = acos(-1.0);

//#if DEBUG
#define GETCHAR getchar
/*#else
#define GETCHAR getchar_unlocked
#endif*/

bool Read(int &x)
{
	char c,r=0,n=0;
	x=0;
		for(;;)
		{
			c=GETCHAR();
				if ((c<0) && (!r))
					return(0);
				if ((c=='-') && (!r))
					n=1;
				else
				if ((c>='0') && (c<='9'))
					x=x*10+c-'0',r=1;
				else
				if (r)
					break;
		}
		if (n)
			x=-x;
	return(1);
}

bool ReadLL(LL &x)
{
	char c,r=0,n=0;
	x=0;
		for(;;)
		{
			c=GETCHAR();
				if ((c<0) && (!r))
					return(0);
				if ((c=='-') && (!r))
					n=1;
				else
				if ((c>='0') && (c<='9'))
					x=x*10+c-'0',r=1;
				else
				if (r)
					break;
		}
		if (n)
			x=-x;
	return(1);
}

#define MOD 998244353
#define LIM 100005

unordered_set<LL> S;
int V[LIM];

int main()
{
		if (DEBUG)
			freopen("in.txt","r",stdin);
	int N,M;
	int i,j,k,a,b,c,x,y,z,v,q;
	Read(N);
	LL K=1,s=0;
		for (i=1; i<N; i+=2)
		{
			Read(v);
			V[i]=v;
			S.clear();
				while (K*K-v-s<=0 || !S.count(K*K-v))
				{
					S.insert(K*K);
					K++;
						if (K>100001)
							goto Imp;
				}
			V[i-1]=K*K-v-s;
			s+=V[i-1]+V[i];
		}
	printf("Yes\n");
		Fox(i,N)
			printf("%d ",V[i]);
	printf("\n");
	return(0);
Imp:;
	printf("No\n");
	return(0);
}


#define DEBUG 0

#include <unordered_set>
#include <algorithm>
#include <functional>
#include <numeric>
#include <iostream>
#include <iomanip>
#include <cstdio>
#include <cmath>
#include <complex>
#include <cstdlib>
#include <ctime>
#include <cstring>
#include <cassert>
#include <string>
#include <vector>
#include <list>
#include <map>
#include <set>
#include <deque>
#include <queue>
#include <stack>
#include <bitset>
#include <sstream>
using namespace std;

#define LL long long
#define LD long double
#define PR pair<int,int>

#define Fox(i,n) for (i=0; i<n; i++)
#define Fox1(i,n) for (i=1; i<=n; i++)
#define FoxI(i,a,b) for (i=a; i<=b; i++)
#define FoxR(i,n) for (i=(n)-1; i>=0; i--)
#define FoxR1(i,n) for (i=n; i>0; i--)
#define FoxRI(i,a,b) for (i=b; i>=a; i--)
#define Foxen(i,s) for (i=s.begin(); i!=s.end(); i++)
#define Min(a,b) a=min(a,b)
#define Max(a,b) a=max(a,b)
#define Sz(s) int((s).size())
#define All(s) (s).begin(),(s).end()
#define Fill(s,v) memset(s,v,sizeof(s))
#define pb push_back
#define mp make_pair
#define x first
#define y second

template<typename T> T Abs(T x) { return(x<0 ? -x : x); }
template<typename T> T Sqr(T x) { return(x*x); }
string plural(string s) { return(Sz(s) && s[Sz(s)-1]=='x' ? s+"en" : s+"s"); }

const int INF = (int)1e9;
const LD EPS = 1e-12;
const LD PI = acos(-1.0);

//#if DEBUG
#define GETCHAR getchar
/*#else
#define GETCHAR getchar_unlocked
#endif*/

bool Read(int &x)
{
	char c,r=0,n=0;
	x=0;
		for(;;)
		{
			c=GETCHAR();
				if ((c<0) && (!r))
					return(0);
				if ((c=='-') && (!r))
					n=1;
				else
				if ((c>='0') && (c<='9'))
					x=x*10+c-'0',r=1;
				else
				if (r)
					break;
		}
		if (n)
			x=-x;
	return(1);
}

bool ReadLL(LL &x)
{
	char c,r=0,n=0;
	x=0;
		for(;;)
		{
			c=GETCHAR();
				if ((c<0) && (!r))
					return(0);
				if ((c=='-') && (!r))
					n=1;
				else
				if ((c>='0') && (c<='9'))
					x=x*10+c-'0',r=1;
				else
				if (r)
					break;
		}
		if (n)
			x=-x;
	return(1);
}

#define MOD 998244353
#define LIM 100005

unordered_set<LL> S;
LL V[LIM];

int main()
{
		if (DEBUG)
			freopen("in.txt","r",stdin);
	int N,M;
	int i,j,k,a,b,c,x,y,z,v,q;
	Read(N);
	LL K=1,s=0;
		for (i=1; i<N; i+=2)
		{
			Read(v);
			V[i]=v;
			S.clear();
				while (K*K-v-s<=0 || !S.count(K*K-v))
				{
					S.insert(K*K);
					K++;
						if (K>100001)
							goto Imp;
				}
			V[i-1]=K*K-v-s;
			s+=V[i-1]+V[i];
		}
	printf("Yes\n");
		Fox(i,N)
			cout << V[i] << " ";
	printf("\n");
	return(0);
Imp:;
	printf("No\n");
	return(0);
}


#!/usr/bin/env python
"""
This file is part of https://github.com/Cheran-Senthil/PyRival.

Copyright 2018 Cheran Senthilkumar all rights reserved,
Cheran Senthilkumar <hello@cheran.io>
Permission to use, modify, and distribute this software is given under the
terms of the MIT License.

"""
from __future__ import division, print_function

import cmath
import itertools
import math
import operator as op
# import random
import sys
from atexit import register
from bisect import bisect_left, bisect_right
# from collections import Counter, MutableSequence, defaultdict, deque
# from copy import deepcopy
# from decimal import Decimal
# from difflib import SequenceMatcher
# from fractions import Fraction
# from heapq import heappop, heappush

if sys.version_info[0] < 3:
    # from cPickle import dumps
    from io import BytesIO as stream
    # from Queue import PriorityQueue, Queue
else:
    from functools import reduce
    from io import StringIO as stream
    from math import gcd
    # from pickle import dumps
    # from queue import PriorityQueue, Queue

if sys.version_info[0] < 3:
    class dict(dict):
        """dict() -> new empty dictionary"""
        def items(self):
            """D.items() -> a set-like object providing a view on D's items"""
            return dict.iteritems(self)

        def keys(self):
            """D.keys() -> a set-like object providing a view on D's keys"""
            return dict.iterkeys(self)

        def values(self):
            """D.values() -> an object providing a view on D's values"""
            return dict.itervalues(self)

    def gcd(x, y):
        """gcd(x, y) -> int
        greatest common divisor of x and y
        """
        while y:
            x, y = y, x % y
        return x

    input = raw_input
    range = xrange

    filter = itertools.ifilter
    map = itertools.imap
    zip = itertools.izip

def sync_with_stdio(sync=True):
    """Set whether the standard Python streams are allowed to buffer their I/O.

    Args:
        sync (bool, optional): The new synchronization setting.

    """
    global input, flush

    if sync:
        flush = sys.stdout.flush
    else:
        sys.stdin = stream(sys.stdin.read())
        input = lambda: sys.stdin.readline().rstrip('\r\n')

        sys.stdout = stream()
        register(lambda: sys.__stdout__.write(sys.stdout.getvalue()))

def memodict(f):
    """ Memoization decorator for a function taking a single argument. """
    class memodict(dict):
        def __missing__(self, key):
            ret = self[key] = f(key)
            return ret
    return memodict().__getitem__

@memodict
def all_factors(n):
    return set(reduce(list.__add__,
                      ([i, n//i] for i in range(1, int(n**0.5) + 1, 2 if n % 2 else 1) if n % i == 0)))

def main():
    n = int(input())
    x = list(map(int, input().split(' ')))

    a, b = 0, 0

    f = all_factors(x[0])
    for fi in f:
        if (fi + (x[0] // fi)) % 2 == 0:
            na = (fi + (x[0] // fi)) // 2
            nb = fi - na if fi > na else (x[0] // fi) - na
            if (a == 0) or (b == 0):
                a, b = na, nb
            else:
                if na < a:
                    a, b = na, nb

    if (a == 0) or (b == 0):
        print('No')
        return

    res = [b*b, x[0]]
    pref_sum = sum(res)

    for i in range(1, n // 2):
        a, b = 0, 0
        pref_sum += x[i]

        f = all_factors(x[i])
        for fi in f:
            if (fi + (x[i] // fi)) % 2 == 0:
                na = (fi + (x[i] // fi)) // 2
                nb = fi - na if fi > na else (x[i] // fi) - na
                if na*na > pref_sum:
                    if (a == 0) or (b == 0):
                        a, b = na, nb
                    else:
                        if na < a:
                            a, b = na, nb

        if (a == 0) or (b == 0):
            print('No')
            return

        res.append(a*a - pref_sum)
        pref_sum += res[-1]
        res.append(x[i])

    print('Yes')
    print(*res)

if __name__ == '__main__':
    sync_with_stdio()
    main()


#!/usr/bin/env python
"""
This file is part of https://github.com/Cheran-Senthil/PyRival.

Copyright 2018 Cheran Senthilkumar all rights reserved,
Cheran Senthilkumar <hello@cheran.io>
Permission to use, modify, and distribute this software is given under the
terms of the MIT License.

"""
from __future__ import division, print_function

import cmath
import itertools
import math
import operator as op
# import random
import sys
from atexit import register
from bisect import bisect_left, bisect_right
# from collections import Counter, MutableSequence, defaultdict, deque
# from copy import deepcopy
# from decimal import Decimal
# from difflib import SequenceMatcher
# from fractions import Fraction
# from heapq import heappop, heappush

if sys.version_info[0] < 3:
    # from cPickle import dumps
    from io import BytesIO as stream
    # from Queue import PriorityQueue, Queue
else:
    from functools import reduce
    from io import StringIO as stream
    from math import gcd
    # from pickle import dumps
    # from queue import PriorityQueue, Queue

if sys.version_info[0] < 3:
    class dict(dict):
        """dict() -> new empty dictionary"""
        def items(self):
            """D.items() -> a set-like object providing a view on D's items"""
            return dict.iteritems(self)

        def keys(self):
            """D.keys() -> a set-like object providing a view on D's keys"""
            return dict.iterkeys(self)

        def values(self):
            """D.values() -> an object providing a view on D's values"""
            return dict.itervalues(self)

    def gcd(x, y):
        """gcd(x, y) -> int
        greatest common divisor of x and y
        """
        while y:
            x, y = y, x % y
        return x

    input = raw_input
    range = xrange

    filter = itertools.ifilter
    map = itertools.imap
    zip = itertools.izip

def sync_with_stdio(sync=True):
    """Set whether the standard Python streams are allowed to buffer their I/O.

    Args:
        sync (bool, optional): The new synchronization setting.

    """
    global input, flush

    if sync:
        flush = sys.stdout.flush
    else:
        sys.stdin = stream(sys.stdin.read())
        input = lambda: sys.stdin.readline().rstrip('\r\n')

        sys.stdout = stream()
        register(lambda: sys.__stdout__.write(sys.stdout.getvalue()))

def memodict(f):
    """ Memoization decorator for a function taking a single argument. """
    class memodict(dict):
        def __missing__(self, key):
            ret = self[key] = f(key)
            return ret
    return memodict().__getitem__

@memodict
def all_factors(n):
    return set(reduce(list.__add__,
                      ([i, n//i] for i in range(1, int(n**0.5) + 1, 2 if n % 2 else 1) if n % i == 0)))

def main():
    n = int(input())
    x = list(map(int, input().split(' ')))

    a, b = 0, 0

    f = all_factors(x[0])
    for fi in f:
        if (fi + (x[0] // fi)) % 2 == 0:
            na = (fi + (x[0] // fi)) // 2
            nb = fi - na if fi > na else (x[0] // fi) - na
            if (a == 0) or (b == 0):
                a, b = na, nb
            else:
                if na < a:
                    a, b = na, nb

    if (a == 0) or (b == 0):
        print('No')
        return

    res = [b*b, x[0]]
    pref_sum = sum(res)

    for i in range(1, n // 2):
        a, b = 0, 0
        pref_sum += x[i]

        f = all_factors(x[i])
        for fi in f:
            if (fi + (x[i] // fi)) % 2 == 0:
                na = (fi + (x[i] // fi)) // 2
                nb = fi - na if fi > na else (x[i] // fi) - na
                if na*na > pref_sum:
                    if (a == 0) or (b == 0):
                        a, b = na, nb
                    else:
                        if na < a:
                            a, b = na, nb

        if (a == 0) or (b == 0):
            print('No')
            return

        res.append(a*a - pref_sum)
        pref_sum += res[-1]
        res.append(x[i])

    print('Yes')
    print(*res)

if __name__ == '__main__':
    sync_with_stdio(False)
    main()


def bi(a, x):
    l  = -1
    u  = len(a)

    while(u-l>1):
        md = int((l+u) / 2)
        if x > a[md]:
            l = md
        else:
            u = md
    return u

d = {}
for x in range(1, 100000):

    for a in range(1, 500):
        diff = a*a + 2*a*x

        if diff > 200000:
            break

        if diff  not in d:
            d[diff] = []

        d[diff].append(x*x)

def solve(a, d):
    cur = 0
    ans = ''

    for x in a:
        if x not in d:
            return 'No', ans

        next_ = bi(d[x], cur)

        if next_ == len(d[x]):
            return 'No', ans

        next_ = d[x][next_]
        ans  +=  str(next_ - cur) + ' ' + str(x) +' '
        cur = next_ + x

    return 'Yes', ans

n   = int(input())
a   = list(map(int, input().split()))
ans = solve(a, d)

print(ans[0])
print(ans[1])


def bi(a, x):
    l  = -1
    u  = len(a)

    while(u-l>1):
        md = int((l+u) / 2)
        if x > a[md]:
            l = md
        else:
            u = md
    return u

d = {}
for x in range(1, 100000):

    for a in range(1, 500):
        diff = a*a + 2*a*x

        if diff > 200000:
            break

        if diff  not in d:
            d[diff] = []

        d[diff].append(x*x)

def solve(a, d):
    cur = 0
    ans = ''

    for x in a:
        if x not in d:
            return 'No', ''

        next_ = bi(d[x], cur)

        if next_ == len(d[x]):
            return 'No', ''

        next_ = d[x][next_]
        ans  +=  str(next_ - cur) + ' ' + str(x) +' '
        cur = next_ + x

    return 'Yes', ans

n   = int(input())
a   = list(map(int, input().split()))
ans = solve(a, d)

print(ans[0])
print(ans[1])


def bi(a, x):
    l  = -1
    u  = len(a)

    while(u-l>1):
        md = int((l+u) / 2)
        if x >= a[md]:
            l = md
        else:
            u = md
    return u

d = {}
for x in range(1, 100000):

    for a in range(1, 500):
        diff = a*a + 2*a*x

        if diff > 200000:
            break

        if diff  not in d:
            d[diff] = []

        d[diff].append(x*x)

def solve(a, d):
    cur = 0
    ans = ''

    for x in a:
        if x not in d:
            return 'No', ''

        next_ = bi(d[x], cur)

        if next_ == len(d[x]):
            return 'No', ''

        next_ = d[x][next_]
        ans  +=  str(next_ - cur) + ' ' + str(x) +' '
        cur = next_ + x

    return 'Yes', ans

n   = int(input())
a   = list(map(int, input().split()))
ans = solve(a, d)

print(ans[0])
print(ans[1])


n = int(input())

cl = list(map(int, input().split()))
sm = 0

cvads = []

def func(t):
  if t%2!=0:
    return ((t-1)//2)**2-sm
  else:
    if t%4==0:
      return ((t//2-2)//2)**2-sm
    else:
      return 0

res = []
for t in cl:
  x = func(t)
  if x==0:
    print("No")
    exit()
  res.append(x)
  sm+=x+t
  res.append(t)

print("Yes")
print(*res)


import math

n = int(input())
cl = list(map(int, input().split()))
sm = 0

def func(p, q):
  if q%2!=0 or q%4==0:
    for i in range(int(math.sqrt(q)), 0, -1):
      if q%i==0:
        k = ((q//i-i)//2)**2
        if k>p:
          return k-p
    return -1
  else:
    return -1

res = []

for i in range(n//2):
  e = func(sm, cl[i])
  if e == -1:
    print('No')
    exit()
  res.append(e)
  res.append(cl[i])
  sm+=e+cl[i]

print('Yes')
print(*res)


import math

n = int(input())
cl = list(map(int, input().split()))
sm = 0

def func(p, q):
  if q%2!=0 or q%4==0:
    for i in range(int(math.sqrt(q)), 0, -1):
      if q%i==0 and (i+q//i)%2==0:
        k = ((q//i-i)//2)**2
        if k>p:
          return k-p
    return -1
  else:
    return -1

res = []

for i in range(n//2):
  e = func(sm, cl[i])
  if e == -1:
    print('No')
    exit()
  res.append(e)
  res.append(cl[i])
  sm+=e+cl[i]

print('Yes')
print(*res)


n = int(input())

cl = list(map(int, input().split()))
sm = 0

cvads = []

def func(t):
  if t%2!=0:
    return ((t-1)//2)**2-sm
  else:
    if t%4==0:
      return ((t//2-2)//2)**2-sm
    else:
      return 0

res = []
for t in cl:
  x = func(t)
  if x<=0:
    print("No")
    exit()
  res.append(x)
  sm+=x+t
  res.append(t)

print("Yes")
print(*res)


# -*- coding:utf-8 -*-

"""

created by shuangquan.huang at 12/20/18

"""

import collections
import time
import os
import sys
import bisect
import heapq
import bisect

S = 2 * 10**5 + 5
V = collections.defaultdict(list)
for i in range(1, S+1):
    if 2*i+1 > S:
        break

    j = i + 1
    while j*j-i*i <= S:
        V[j*j-i*i].append((i, j))
        j += 1

N = int(input())
X = [int(x) for x in input().split()]
ans = [0] * (N+1)
xi = 0
for i in range(2, N+1, 2):
    x = X[xi]
    xi += 1
    for v in V[x]:
        if ans[i-1] < v[0]:
            ans[i-1] = v[0]
            ans[i] = v[1]
            break

    if ans[i-1] == 0:
        print('No')
        exit(0)
print('Yes')

print(' '.join(map(str, [ans[i]**2-ans[i-1]**2 for i in range(1, N+1)])))


# -*- coding:utf-8 -*-

"""

created by shuangquan.huang at 12/20/18

"""

import collections
import time
import os
import sys
import bisect
import heapq
import bisect

S = 2 * 10**5 + 5
V = collections.defaultdict(list)
for i in range(1, S+1):
    if 2*i+1 > S:
        break

    j = i + 1
    while j*j-i*i <= S:
        V[j*j-i*i].append((i, j))
        j += 1

N = int(input())
X = [int(x) for x in input().split()]
ans = [0] * (N+1)
xi = 0
for i in range(2, N+1, 2):
    x = X[xi]
    xi += 1
    for v in V[x]:
        if ans[i-2] < v[0]:
            ans[i-1] = v[0]
            ans[i] = v[1]
            break

    if ans[i-1] == 0:
        print('No')
        exit(0)
print('Yes')

print(' '.join(map(str, [ans[i]**2-ans[i-1]**2 for i in range(1, N+1)])))


n=int(input())
x=list(map(int,input().split()))
currsum=0
others=[]
done=False
for i in range(n//2):
    a=x[i]
    if a%4==2:
        print("No")
        done=True
        break
    elif a%2==1:
        sml=((a-1)//2)**2
        big=sml+a
    else:
        sml=(a//4-1)**2
        big=sml+a
    if sml-currsum<1:
        print("No")
        done=True
        break
    others.append(sml-currsum)
    currsum=big
if not done:
    out=""
    for i in range(n//2):
        out+=str(others[i])+" "+str(x[i])+" "
    print(out[:-1])


import math
n=int(input())
x=list(map(int,input().split()))
currsum=0
others=[]
done=False
for i in range(n//2):
    a=x[i]
    sml=None
    big=None
    if a%4==2:
        print("No")
        done=True
        break
    elif a%2==1:
        for i in range(1,math.ceil(-currsum+(currsum**2+a)**0.5),2):
            if a%i==0:
                sml=((a-i**2)//(2*i))**2
                big=sml+a
    else:
        for i in range(2,math.ceil(-currsum+(currsum**2+a)**0.5),2):
            if a%i==0:
                sml=((a-i**2)//(2*i))**2
                big=sml+a
    if sml==None:
        print("No")
        done=True
        break
    others.append(sml-int(currsum)**2)
    currsum=big**0.5
if not done:
    out=""
    for i in range(n//2):
        out+=str(others[i])+" "+str(x[i])+" "
    print("Yes")
    print(out[:-1])


import math
n=int(input())
x=list(map(int,input().split()))
currsum=0
others=[]
done=False
for i in range(n//2):
    a=x[i]
    sml=None
    big=None
    if a%4==2:
        print("No")
        done=True
        break
    elif a%2==1:
        for i in range(1,math.ceil(-currsum+(currsum**2+a)**0.5),2):
            if a%i==0:
                sml=((a-i**2)//(2*i))**2
                big=sml+a
    else:
        for i in range(2,math.ceil(-currsum+(currsum**2+a)**0.5),2):
            if a%(2*i)==0:
                sml=((a-i**2)//(2*i))**2
                big=sml+a
    if sml==None:
        print("No")
        done=True
        break
    others.append(sml-int(currsum)**2)
    currsum=big**0.5
if not done:
    out=""
    for i in range(n//2):
        out+=str(others[i])+" "+str(x[i])+" "
    print("Yes")
    print(out[:-1])


import math
n=int(input())
x=list(map(int,input().split()))
currsum=0
others=[]
done=False
for i in range(n//2):
    a=x[i]
    if a%4==2:
        print("No")
        done=True
        break
    elif a%2==1:
        for i in range(1,math.ceil(-currsum+(currsum**2+a)**0.5),2):
            if a%i==0:
                sml=((a-i**2)//(2*i))**2
                big=sml+a
    else:
        for i in range(2,math.ceil(-currsum+(currsum**2+a)**0.5),2):
            if a%i==0:
                sml=((a-i**2)//(2*i))**2
                big=sml+a
    if sml-currsum<1:
        print("No")
        done=True
        break
    others.append(sml-int(currsum)**2)
    currsum=big**0.5
if not done:
    out=""
    for i in range(n//2):
        out+=str(others[i])+" "+str(x[i])+" "
    print("Yes")
    print(out[:-1])


n=int(input())
x=list(map(int,input().split()))
currsum=0
others=[]
done=False
for i in range(n//2):
    a=x[i]
    if a%4==2:
        print("No")
        done=True
        break
    elif a%2==1:
        sml=((a-1)//2)**2
        big=sml+a
    else:
        sml=(a//4-1)**2
        big=sml+a
    if sml-currsum<1:
        print("No")
        done=True
        break
    others.append(sml-currsum)
    currsum=big
if not done:
    out=""
    for i in range(n//2):
        out+=str(others[i])+" "+str(x[i])+" "
    print("Yes")
    print(out[:-1])


Z = 100000

n = int(input())
xx = list(map(int, input().split()))

def cal():
    ans = []
    a = 1
    b = 1
    s = 0
    ls = 1
    for x in xx:
        while b <= Z:
            if s < x:
                s += b * 2 + 1
                b += 1
            elif s > x:
                s -= a * 2 + 1
                ls += a * 2 + 1
                a += 1
            else:
                ans.append(ls)
                ans.append(x)
                ls = b * 2 + 1
                b += 1
                a = b
                s = 0
                break
        else:
            return
    return ans

ans = cal()
if ans:
    print('Yes')
    print(' '.join(map(str, ans)))
else:
    print('No')


#include <stdio.h>
#include<stdlib.h>
#include<math.h>
int main(){
long long *input,t=0,j=1;
int n;
 long long p;
input =malloc(2*100000*sizeof(long long));
scanf("%d",&n);
for (int i =1; i<n; i+=2)
  {
    scanf("%I64d",&input[i]);

     j=sqrtl(input[i]+t);
    for ( j++;j*j<1.0000002e13;j++)
    {
         p=(int)sqrtl(j*j-input[i]);
       if(p == sqrtl(j*j-input[i]))
          {
            input[i-1]=p*p-t;
            t=p*p+input[i];
           // j=sqrtl(t);
            break;
          }

    }

      if(j*j>=1.0000002e13)
          {
            printf("No\n");
              return 0;
          }

  }

   printf("Yes\n");
for (int i = 0; i < n; ++i)
{
  printf("%I64d ",input[i]);
}
  printf("\n");

  return 0;
}


#include <stdio.h>
#include<stdlib.h>
#include<math.h>
int main(){
long long *input,t=0,j=1;
int n;
 long long p;
input =malloc(2*100000*sizeof(long long));
scanf("%d",&n);
for (int i =1; i<n; i+=2)
  {
    scanf("%I64d",&input[i]);
     if(i==1)
     {
    j=sqrtl(input[i]);
    }
    for ( j++;j*j<1.0000002e13;j++)
    {
         p=(int)sqrtl(j*j-input[i]);
       if(p == sqrtl(j*j-input[i]))
          {
            input[i-1]=p*p-t;
            t=p*p+input[i];
            j=sqrtl(t);
            break;
          }

    }

      if(j*j>=1.0000002e13)
          {
            printf("No\n");
              return 0;
          }

  }

   printf("Yes\n");
for (int i = 0; i < n; ++i)
{
  printf("%I64d ",input[i]);
}
  printf("\n");

  return 0;
}


#include <stdio.h>
#include<stdlib.h>
#include<math.h>
int main(){
long long *input,t=0,j=1;
int n;
 long long p;
input =malloc(2*100000*sizeof(long long));
scanf("%d",&n);
for (int i =1; i<n; i+=2)
  {
    scanf("%I64d",&input[i]);
     if(i==1)
     {
    j=sqrtl(input[i]);
    }
    for ( j++;j*j<1.0000002e13;j++)
    {
         p=(int)sqrtl(j*j-input[i]);
       if(p == sqrtl(j*j-input[i]))
          {
            input[i-1]=p*p-t;
            t=p*p+input[i];
            j=sqrtl(t);
            break;
          }

    }

      if(j*j>=1.0000002e13)
          {
            printf("NO\n");
              return 0;
          }

  }

   printf("YES\n");
for (int i = 0; i < n; ++i)
{
  printf("%I64d ",input[i]);
}
  printf("\n");

  return 0;
}


#include<stdio.h>
#include<stdlib.h>

typedef long long int int64;

int *factor=NULL;
void init(void){
  const int n=200000;
  factor=(int *)calloc(n+1,sizeof(int));
  int i,j;
  for(i=0;i<=n;i++) factor[i]=i;
  for(i=2;i*i<=n;i++) if(factor[i]==i) for(j=i*i;j<=n;j+=i) factor[j]=i;
}

void factorize(int n,int *f,int *reslen){
  int len=1;
  f[0]=1;
  while(n>1){
    int p=factor[n];
    int c=0;
    do{
      n/=p;
      c++;
    } while(n%p==0);
    int i,j,mul;
    for(i=1,mul=p;i<=c;i++,mul*=p){
      for(j=0;j<len;j++){
	f[i*len+j]=f[j]*mul;
      }
    }
    len*=c+1;
  }
  *reslen=len;
  return;
}

void run(void){
  init();
  int n;
  scanf("%d",&n);
  int64 *x=(int64 *)calloc(n,sizeof(int64));
  int i;
  for(i=1;i<n;i+=2){
    scanf("%lld",x+i);
  }
  int *f=(int *)calloc(100000,sizeof(int));
  const int ini=1000000000;
  int64 sum=0;
  for(i=1;i<n;i+=2){
    int64 aa=ini;
    int64 bb=ini;
    int len;
    factorize(x[i],f,&len);
    int k;
    for(k=0;k<len;k++){
      const int t=f[k];
      if((int64)t*t>x[i]) continue;
      int d=x[i]/t;
      if((d+t)%2!=0) continue;
      int a=(d+t)/2;
      int b=a-t;
      if(b<=0) continue;
      if((int64)b*b-sum>0 && bb>b){
	bb=b;
	aa=a;
      }
    }
    if(bb==ini || (int64)bb*bb-sum<=0){
      printf("No\n");
      return;
    }
    x[i-1]=(int64)bb*bb-sum;
    sum=(int64)aa*aa;
  }
  printf("Yes\n");
  for(i=0;i<n;i++) printf("%lld ",x[i]);
  printf("\n");
}

int main(void){
  run();
  return 0;
}


#include<stdio.h>
#include<stdlib.h>
#include<math.h>

typedef long long int int64;

#define MAX(a,b) ((a)>(b)?(a):(b))
#define MIN(a,b) ((a)<(b)?(a):(b))
#define ABS(a) ((a)>(0)?(a):-(a))

void run(void){
  int n;
  scanf("%d",&n);
  int64 *x=(int64 *)calloc(n,sizeof(int64));
  int i;
  for(i=1;i<n;i+=2){
    scanf("%lld",x+i);
  }
  const int ini=1000000000;
  int64 sum=0;
  for(i=1;i<n;i+=2){
    int64 aa=ini;
    int64 bb=ini;
    int k;
    for(k=1;k*k<=x[i];k++){
      if(x[i]%k!=0) continue;
      int d=x[i]/k;
      if((d+k)%2!=0) continue;
      int a=(d+k)/2;
      int b=a-k;
      if(b<=0) continue;
      aa=a;
      bb=b;
    }
    if(aa==ini || (int64)bb*bb-sum<=0){
      printf("No\n");
      return;
    }
    x[i-1]=(int64)bb*bb-sum;
    sum=(int64)aa*aa;
  }
  printf("Yes\n");
  for(i=0;i<n;i++) printf("%lld ",x[i]);
  printf("\n");
}

int main(void){
  run();
  return 0;
}


using System;
using System.Linq;
using System.Collections.Generic;

static class UtilityMethods
{
	public static void Swap<T>(ref T a, ref T b)
	{
		T t = a;
		a = b;
		b = t;
	}

	public static int StrToInt(string s)
	{
		int number = 0;
		for (int i = s[0] == '-' ? 1 : 0; i < s.Length; i++)
			number = number * 10 + (s[i] - '0');
		return s[0] == '-' ? -number : number;
	}
	public static long StrToLong(string s)
	{
		long number = 0;
		for (int i = s[0] == '-' ? 1 : 0; i < s.Length; i++)
			number = number * 10 + (s[i] - '0');
		return s[0] == '-' ? -number : number;
	}

	public static string ReadString() => Console.ReadLine();
	public static int ReadInt() => StrToInt(ReadString());
	public static long ReadLong() => StrToLong(ReadString());
	public static double ReadDouble() => double.Parse(ReadString());

	public static string[] ReadStringArray() => ReadString().Split();
	public static int[] ReadIntArray() => Array.ConvertAll(ReadStringArray(), StrToInt);
	public static long[] ReadLongArray() => Array.ConvertAll(ReadStringArray(), StrToLong);
	public static double[] ReadDoubleArray() => ReadStringArray().Select(double.Parse).ToArray();

	public static void WriteLine(object a) => Console.WriteLine(a);
	public static void WriteLineArray<T>(string separator, T[] a, int startIndex, int count)
	{
		const int MAXLEN = 1000000;
		int len = 0, j = startIndex, lastIndex = startIndex + count;
		System.Text.StringBuilder str;
		string[] b = Array.ConvertAll(a, x => x.ToString());
		for (int i = startIndex; i < lastIndex - 1; i++)
		{
			len += b[i].Length + separator.Length;
			if (len >= MAXLEN)
			{
				str = new System.Text.StringBuilder(len);
				for (; j <= i; j++)
				{
					str.Append(b[j]);
					str.Append(separator);
				}
				Console.Write(str);
				len = 0;
			}
		}
		str = new System.Text.StringBuilder(len);
		for (; j < lastIndex - 1; j++)
		{
			str.Append(b[j]);
			str.Append(separator);
		}
		Console.Write(str);
		Console.WriteLine(b.Last());
	}
}

class Program
{
	static bool IsSquare(long a)
	{
		long root = (long)Math.Sqrt(a);
		return root * root == a;
	}
	static void Main()
	{
		int n = UtilityMethods.ReadInt();
		long[] x = new long[n + 1], x2 = UtilityMethods.ReadLongArray();
		for (int i = 0; i < x2.Length; i++)
			x[(i + 1) * 2] = x2[i];
		long sum = 0, root = 1;
		for (int i = 1; i < n; i += 2)
		{
			for (long j = root, prevSqr = sum; ; j++)
			{
				long thisSqr = j * j;
				if (thisSqr - prevSqr > x[i + 1])
				{
					UtilityMethods.WriteLine("No");
					return;
				}
				if (IsSquare(thisSqr + x[i + 1]))
				{
					x[i] = thisSqr - sum;
					sum = thisSqr + x[i + 1];
					root = (long)Math.Sqrt(sum);
					break;
				}
				prevSqr = thisSqr;
			}
		}
		UtilityMethods.WriteLine("Yes");
		UtilityMethods.WriteLineArray(" ", x, 1, x.Length - 1);
		Console.ReadLine();
	}
}


using System;
using System.Linq;
using System.Collections.Generic;

static class UtilityMethods
{
	public static void Swap<T>(ref T a, ref T b)
	{
		T t = a;
		a = b;
		b = t;
	}

	public static int StrToInt(string s)
	{
		int number = 0;
		for (int i = s[0] == '-' ? 1 : 0; i < s.Length; i++)
			number = number * 10 + (s[i] - '0');
		return s[0] == '-' ? -number : number;
	}
	public static long StrToLong(string s)
	{
		long number = 0;
		for (int i = s[0] == '-' ? 1 : 0; i < s.Length; i++)
			number = number * 10 + (s[i] - '0');
		return s[0] == '-' ? -number : number;
	}

	public static string ReadString() => Console.ReadLine();
	public static int ReadInt() => StrToInt(ReadString());
	public static long ReadLong() => StrToLong(ReadString());
	public static double ReadDouble() => double.Parse(ReadString());

	public static string[] ReadStringArray() => ReadString().Split();
	public static int[] ReadIntArray() => Array.ConvertAll(ReadStringArray(), StrToInt);
	public static long[] ReadLongArray() => Array.ConvertAll(ReadStringArray(), StrToLong);
	public static double[] ReadDoubleArray() => ReadStringArray().Select(double.Parse).ToArray();

	public static void WriteLine(object a) => Console.WriteLine(a);
	public static void WriteLineArray<T>(string separator, T[] a, int startIndex, int count)
	{
		const int MAXLEN = 1000000;
		int len = 0, j = startIndex, lastIndex = startIndex + count;
		System.Text.StringBuilder str;
		string[] b = Array.ConvertAll(a, x => x.ToString());
		for (int i = startIndex; i < lastIndex - 1; i++)
		{
			len += b[i].Length + separator.Length;
			if (len >= MAXLEN)
			{
				str = new System.Text.StringBuilder(len);
				for (; j <= i; j++)
				{
					str.Append(b[j]);
					str.Append(separator);
				}
				Console.Write(str);
				len = 0;
			}
		}
		str = new System.Text.StringBuilder(len);
		for (; j < lastIndex - 1; j++)
		{
			str.Append(b[j]);
			str.Append(separator);
		}
		Console.Write(str);
		Console.WriteLine(b.Last());
	}
}

class Program
{
	static bool IsSquare(long a)
	{
		long root = (long)Math.Sqrt(a);
		return root * root == a;
	}
	static void Main()
	{
		int n = UtilityMethods.ReadInt();
		long[] x = new long[n + 1], x2 = UtilityMethods.ReadLongArray();
		for (int i = 0; i < x2.Length; i++)
			x[(i + 1) * 2] = x2[i];
		long sum = 0, root = 0;
		for (int i = 1; i < n; i += 2)
		{
			for (long j = root, prevSqr = sum; ; j++)
			{
				long thisSqr = j * j;
				if (thisSqr - prevSqr > x[i + 1])
				{
					UtilityMethods.WriteLine("No");
					return;
				}
				if (IsSquare(thisSqr + x[i + 1]))
				{
					x[i] = thisSqr - sum;
					sum = thisSqr + x[i + 1];
					root = (long)Math.Sqrt(sum);
					break;
				}
				prevSqr = thisSqr;
			}
		}
		UtilityMethods.WriteLine("Yes");
		UtilityMethods.WriteLineArray(" ", x, 1, x.Length - 1);
		Console.ReadLine();
	}
}