#include <bits/stdc++.h>
using namespace std;
# define rep(i,a,b) for(int i=(a); i<=(b); ++i)
typedef long long int_;
inline int_ readint(){
	int_ a = 0; char c = getchar(), f = 1;
	for(; c<'0'||c>'9'; c=getchar())
		if(c == '-') f = -f;
	for(; '0'<=c&&c<='9'; c=getchar())
		a = (a<<3)+(a<<1)+(c^48);
	return a*f;
}
inline void writeint(int_ x){
	if(x < 0) putchar('-'), x = -x;
	if(x > 9) writeint(x/10);
	putchar((x-x/10*10)^48);
}

const int MaxN = 1000001;

struct Range{
	long long l, r;
	Range(){ l = r = 0; }
	Range(int_ L,int_ R){
		l = L, r = R;
	}
	int_& operator[](const int &x){
		return x ? r : l;
	}
};
struct BestList{
	struct Node{
		Range r; Node *nxt[2];
	};
	int dir, sgn; int_ adv;
	Node *head, *tail;
	# define unzip(x) (sgn*(x)+adv)

	BestList(){
		dir = sgn = 1, adv = 0;
		head = new Node();
		tail = new Node();
		head->nxt[dir] = tail;
		tail->nxt[dir^1] = head;
	}

	bool empty() const {
		return head->nxt[dir] == tail;
	}

	struct Event{
		int opt; Range r;
		Event(const Range &R):r(R){
			opt = 1; // default
		}
	};
	vector<Event> sta; // for undo

	void reverse(){
		dir ^= 1; // change direction
		swap(head,tail); // keep ordered
		adv = -adv, sgn = -sgn;
		sta.push_back(Event(Range()));
		sta.back().opt = 2; // inversion
	}
	void shift(int_ x){
		adv += x; // stupid
		sta.push_back(Event(Range(x,x)));
		sta.back().opt = 3; // shift
	}
	void pop_back(){
		Node *t = tail->nxt[dir^1];
		tail->nxt[dir^1] = t->nxt[dir^1];
		tail->nxt[dir^1]->nxt[dir] = tail;
		t->r[0] = unzip(t->r[0]);
		t->r[1] = unzip(t->r[1]);
		if(t->r[0] > t->r[1])
			swap(t->r[0],t->r[1]);
		sta.push_back(Event(t->r));
		delete t; // delete from list
	}

	void truncate(int_ x){
		while(!empty()){
			Node *t = tail->nxt[dir^1];
			if(unzip(t->r[dir^1]) > x){
				pop_back(); continue;
			}
			if(sgn == 1 && t->r[dir] > x-adv){
				sta.push_back(Event(
					Range(x+1,unzip(t->r[dir]))
				));
				sta.back().opt = 5;
				t->r[dir] = x-adv;
			}
			if(!(~sgn) && t->r[dir] < adv-x){
				sta.push_back(Event(
					Range(x+1,unzip(t->r[dir]))
				));
				sta.back().opt = 5;
				t->r[dir] = adv-x;
			}
			break; // tackled all
		}
	}

	bool check(int_ x){
		Node *t = tail->nxt[dir^1];
		return t != head && unzip(t->r[dir]) == x;
	}
	int_ front() const {
		return unzip(head->nxt[dir]->r[dir^1]);
	}
	bool tiny(int_ x){
		return !empty() && front() != x;
	}

	void insert(int_ l,int_ r,bool f = false){
		Node *t = tail->nxt[dir^1];
		// printf("insert %lld %lld\n",l,r);
		if(t != head && unzip(t->r[dir]) >= r)
			return ; // involved already
		if(f && t != head && unzip(t->r[dir]) >= l-1){
			t->r[dir] = (r-adv)*sgn; return ; // link
		}
		t->nxt[dir] = new Node();
		l = (l-adv)*sgn, r = (r-adv)*sgn;
		t->nxt[dir]->r[dir^1] = l;
		t->nxt[dir]->r[dir] = r; // range
		t->nxt[dir]->nxt[dir^1] = t;
		t->nxt[dir]->nxt[dir] = tail;
		tail->nxt[dir^1] = t->nxt[dir];
		sta.push_back(Event(Range()));
		sta.back().opt = 4; // insert
	}
	void fillUp(int_ x){
		while(!empty()) pop_back();
		insert(0,x); // the whole thing
	}
	void stepback(){
		vector<Event> jb; jb.swap(sta);
		Range &r = jb.back().r;
		switch(jb.back().opt){
			case 2: reverse(); break;
			case 3: shift(-r.r); break;
			case 4: pop_back(); break;
			case 1: insert(r.l,r.r); break;
			case 5: insert(r.l,r.r,true);
		}
		jb.swap(sta); sta.pop_back();
	}

	void debug() const {
		printf("STRUCTURE:");
		for(Node *i=head->nxt[dir]; i!=tail; i=i->nxt[dir])
			printf(" [%lld,%lld]",
				unzip(i->r[dir^1]),
				unzip(i->r[dir]));
		puts("");
	}
};

BestList lis;
int cnt[MaxN][2];
int_ dif[MaxN], w[MaxN];
int main(){
	int n = readint(); readint();
	lis.insert(0,1e18);
	for(int i=1; i<=n-2; ++i){
		w[i] = readint();
		cnt[i][0] = -lis.sta.size();
		lis.truncate(w[i]);
		cnt[i][1] = -lis.sta.size();
		cnt[i][0] -= cnt[i][1];
		if(lis.check(w[i])){
			lis.fillUp(w[i]);
			cnt[i][1] += lis.sta.size();
			// printf("i = %d, ",i); lis.debug();
			continue;
		}
		bool corner = lis.tiny(w[i]);
		lis.reverse(); lis.shift(w[i]);
		if(corner) lis.insert(w[i],w[i]);
		cnt[i][1] += lis.sta.size();
		// printf("i = %d, ",i); lis.debug();
	}
	if(lis.empty()){
		puts("NO"); return 0;
	} else puts("YES");
	// printf("sta:");
	// for(auto it : lis.sta)
	// 	printf("<%d,[%lld,%lld]> ",it.opt,it.r[0],it.r[1]);
	// puts("");
	int_ now = lis.front();
	for(int i=n-2,sgn=1; i>=1; --i){
		// printf("cnt[%d] = %d, %d\n",i,cnt[i][0],cnt[i][1]);
		dif[i] = sgn*now;
		for(; cnt[i][1]; --cnt[i][1])
			lis.stepback();
		if(lis.check(w[i]))
			now = w[i], sgn = -sgn;
		else if(lis.tiny(w[i]) && now == w[i])
			now = lis.front(), sgn = -sgn;
		else now = w[i]-now;
		while(cnt[i][0] --) lis.stepback();
		if(i == 1 && !(~sgn)) now = -now;
		// printf("dif[%d] = %lld\n",i,dif[i]);
		// printf("i = %d, ",i-1); lis.debug();
	}
	dif[0] = now; int_ low = 0;
	rep(i,now=0,n-2) // find valley
		low = min(low,now += dif[i]);
	writeint(now = -low);
	rep(i,0,n-2){
		putchar(' ');
		writeint(now += dif[i]);
	}
	putchar('\n');
	return 0;
}