链接：http://codeforces.com/contest/1256/problem/C

There is a river of width nn. The left bank of the river is cell 00 and the right bank is cell n+1n+1 (more formally, the river can be represented as a sequence of n+2n+2 cells numbered from 00 to n+1n+1). There are also mm wooden platforms on a river, the ii-th platform has length cici (so the ii-th platform takes cici consecutive cells of the river). It is guaranteed that the sum of lengths of platforms does not exceed nn.

You are standing at 00 and want to reach n+1n+1 somehow. If you are standing at the position xx, you can jump to any position in the range [x+1;x+d][x+1;x+d]. However you don't really like the water so you can jump only to such cells that belong to some wooden platform. For example, if d=1d=1, you can jump only to the next position (if it belongs to the wooden platform). You can assume that cells 00 and n+1n+1 belong to wooden platforms.

You want to know if it is possible to reach n+1n+1 from 00 if you can move any platform to the left or to the right arbitrary number of times (possibly, zero) as long as they do not intersect each other (but two platforms can touch each other). It also means that you cannot change the relative order of platforms.

Note that you should move platforms until you start jumping (in other words, you first move the platforms and then start jumping).

For example, if n=7n=7, m=3m=3, d=2d=2 and c=[1,2,1]c=[1,2,1], then one of the ways to reach 88 from 00 is follow:

The first example: n=7n=7.

Input

The first line of the input contains three integers nn, mm and dd (1≤n,m,d≤1000,m≤n1≤n,m,d≤1000,m≤n) — the width of the river, the number of platforms and the maximum distance of your jump, correspondingly.

The second line of the input contains mm integers c1,c2,…,cmc1,c2,…,cm (1≤ci≤n,∑i=1mci≤n1≤ci≤n,∑i=1mci≤n), where cici is the length of the ii-th platform.

Output

If it is impossible to reach n+1n+1 from 00, print NO in the first line. Otherwise, print YES in the first line and the array aa of length nn in the second line — the sequence of river cells (excluding cell 00 and cell n+1n+1).

If the cell ii does not belong to any platform, aiai should be 00. Otherwise, it should be equal to the index of the platform (11-indexed, platforms are numbered from 11 to mm in order of input) to which the cell ii belongs.

Note that all aiai equal to 11 should form a contiguous subsegment of the array aa of length c1c1, all aiai equal to 22 should form a contiguous subsegment of the array aa of length c2c2, ..., all aiai equal to mm should form a contiguous subsegment of the array aa of length cmcm. The leftmost position of 22 in aa should be greater than the rightmost position of 11, the leftmost position of 33 in aa should be greater than the rightmost position of 22, ..., the leftmost position of mm in aa should be greater than the rightmost position of m−1m−1.

See example outputs for better understanding.

Examples

input

Copy

7 3 2
1 2 1

output

Copy

YES
0 1 0 2 2 0 3

input

Copy

10 1 11
1

output

Copy

YES
0 0 0 0 0 0 0 0 0 1

input

Copy

10 1 5
2

output

Copy

YES
0 0 0 0 1 1 0 0 0 0

Note

Consider the first example: the answer is [0,1,0,2,2,0,3][0,1,0,2,2,0,3]. The sequence of jumps you perform is 0→2→4→5→7→80→2→4→5→7→8.

Consider the second example: it does not matter how to place the platform because you always can jump from 00 to 1111.

Consider the third example: the answer is [0,0,0,0,1,1,0,0,0,0][0,0,0,0,1,1,0,0,0,0]. The sequence of jumps you perform is 0→5→6→110→5→6→11.

代码：

#include<bits/stdc++.h>
using namespace std;
int n,t,m,d,sum,s1;
int ans[100001];
int ls[100001];
int c[100001];
int main()
{
	cin>>n>>m>>d;
	sum=0;
	for(int i=1;i<=m;i++) 
	{
		cin>>c[i];
		sum+=(c[i]-1);
	}
	ls[m]=c[m];
	for(int i=m-1;i>=1;i--)
		ls[i]=c[i]+ls[i+1];
	if(d*(m+1)<n-sum+1) 
	{
		printf("NO\n");
	}
	else 
	{
		printf("YES\n");
		int l=0,r=1;
		memset(ans,0,sizeof(ans));
		while(l<n+1) 
		{
			if(n+1-d-l<=ls[r]) 
			{
				int ll=c[r];
				while(l<n+1) 
				{
					l++;
					if(r<=m) 
						ans[l]=r;
					ll--;
					if(ll==0) 
					{
						r++;
						ll=c[r];
					}
				}
				break;	
			}
			else 
			{
				l+=d;
				for(int i=l;i<=l+c[r]-1;i++) 
				{
					ans[i]=r;
				}
				l=l+c[r]-1;
				r++;
			}
		}
		for(int i=1;i<=n;i++)
			cout<<ans[i]<<" ";
		cout<<endl;
	}
	return 0;
}