Polycarp invited all his friends to the tea party to celebrate the holiday. He has n cups, one for each of his n friends, with volumes a1, a2, ..., an. His teapot stores w milliliters of tea (w ≤ a1 + a2 + ... + an). Polycarp wants to pour tea in cups in such a way that:

  * Every cup will contain tea for at least half of its volume 
  * Every cup will contain integer number of milliliters of tea 
  * All the tea from the teapot will be poured into cups 
  * All friends will be satisfied. 



Friend with cup i won't be satisfied, if there exists such cup j that cup i contains less tea than cup j but ai > aj.

For each cup output how many milliliters of tea should be poured in it. If it's impossible to pour all the tea and satisfy all conditions then output -1.

Input

The first line contains two integer numbers n and w (1 ≤ n ≤ 100, <image>).

The second line contains n numbers a1, a2, ..., an (1 ≤ ai ≤ 100).

Output

Output how many milliliters of tea every cup should contain. If there are multiple answers, print any of them.

If it's impossible to pour all the tea and satisfy all conditions then output -1.

Examples

Input

2 10
8 7


Output

6 4 


Input

4 4
1 1 1 1


Output

1 1 1 1 


Input

3 10
9 8 10


Output

-1

Note

In the third example you should pour to the first cup at least 5 milliliters, to the second one at least 4, to the third one at least 5. It sums up to 14, which is greater than 10 milliliters available.
	import java.io.BufferedReader;
	import java.io.IOException;
	import java.io.InputStreamReader;
	import java.io.PrintWriter;
	import java.util.ArrayList;
	import java.util.Arrays;
	import java.util.Map.Entry;
	import java.util.PriorityQueue;
	import java.util.StringTokenizer;
	import java.util.*;
	
	
	   public class Solution {
	
	
	
		/*public static int ispr(int n)
	    	{
	    	//boolean[] isPrime = new boolean[n+1];
	        for (int i = 2; i <= n; i++) {
	            Prime[i] = true;
	        }
	
	        // mark non-primes <= n using Sieve of Eratosthenes
	        for (int factor = 2; factor*factor <= n; factor++) {
	
	            // if factor is prime, then mark multiples of factor as nonprime
	            // suffices to consider mutiples factor, factor+1, ...,  n/factor
	            if (Prime[factor]) {
	                for (int j = factor; factor*j <= n; j++) {
	                    Prime[factor*j] = false;
	                }
	            }	
	        }	
	        // count primes
	
	        /*int primes = 0;
	        for (int i = 2; i <= n; i++) {
	            if (isPrime	[i])System.out.println(i);
	
	
	        }*/
		// System.out.println("The number of primes <= " + n + " is " + primes);
		//return 0;
		// if(isPrime[n]==true)return 1; else return 0;
	
		//}
	
	
	
	
	
	
	
		public static long fact(long x)
		{
			if(x==0)return 1;
			else return x*fact(x-1);
		}
	
	
		public static long exp(long x, long n, long M)
		{
	
			if(n==0) return 1;
	
			else if(n%2==0) return exp((x*x)%M,n/2,M);
			else return (x*exp((x*x)%M,(n-1)/2,M))%M;
	
		}
	
		//fi
	
		static long fib(long n)
		{
			long F[][] = new long[][]{{1,1},{1,0}};
			if (n == 0)
				return 0;
			power(F, n-1);
	
			return F[0][0];
		}
	
		static int mod=1000000007;
		
		static void multiply(long F[][], long M[][])
		{
			long x =  (((F[0][0]%mod)*(M[0][0]%mod))%mod + ((F[0][1]%mod)*(M[1][0]%mod))%mod)%mod;
			long y =  (((F[0][0]%mod)*(M[0][1]%mod))%mod + ((F[0][1]%mod)*(M[1][1]%mod))%mod)%mod;
			long z =  (((F[1][0]%mod)*(M[0][0]%mod))%mod + ((F[1][1]%mod)*(M[1][0]%mod))%mod)%mod;
			long w =  (((F[1][0]%mod)*(M[0][1]%mod))%mod + ((F[1][1]%mod)*(M[1][1]%mod))%mod)%mod;
	
			F[0][0] = x;
			F[0][1] = y;
			F[1][0] = z;
			F[1][1] = w;
		}
	
		/* Optimized version of power() in method 4 */
		static void power(long F[][], long n)				
		{
			if( n == 0 || n == 1)
				return;
			long M[][] = new long[][]{{1,1},{1,0}};
	
			power(F, n/2);
			multiply(F, F);
	
			if (n%2 != 0)
				multiply(F, M);
		}
	
	
	
	
		public static int gcd(int a, int b)
		{
			if(b==0)
				return a;
			else return gcd(b,a%b);
		}
	
		static  class MyScanner {
	
			BufferedReader br;
			StringTokenizer st;
	
			public MyScanner() {
				br = new BufferedReader(new InputStreamReader(System.in));
			}
	
			String next() {
				while (st == null || !st.hasMoreElements()) {
					try {
						st = new StringTokenizer(br.readLine());
					} catch (IOException e) {
						e.printStackTrace();
					}
				}
				return st.nextToken();
			}
	
			int nextInt() {
				return Integer.parseInt(next());
			}
	
			long nextLong() {
				return Long.parseLong(next());
			}
	
			double nextDouble() {
				return Double.parseDouble(next());
			}
	
			String nextLine(){
				String str = "";
				try {
					str = br.readLine();
				} catch (IOException e) {
					e.printStackTrace();
				}
				return str;
			}
	
		}
	
		static MyScanner sc = new  MyScanner();
		static PrintWriter pw = new PrintWriter(System.out, true);
		
	
		
		static void printPath(int parent[], int j)
		{
		    // Base Case : If j is source
		    if (parent[j]==-1)
		        {pw.print(j+" ");return;}
	
		    printPath(parent, parent[j]);
	
		    pw.print(j+" ");
		}
		
		
		//Main begins here :)
		
		public static class Pair{
		    int a;
		    int b;
		    Pair(int p,int q){
		        a=p;
		        b=q;
		    }
		    public boolean equals(Object o) {
		        if (o instanceof Pair) {
		            Pair p = (Pair)o;
		            return p.a == a && p.b == b;
		        }
		        return false;
		    }
		    public int hashCode() {
		        return new Integer(a).hashCode() * 31 + new Integer(b).hashCode();
		    }
		}
		
	
	
	
		
		public static int max1(String st, int k)
		{
			int n1=0;
			int max=Integer.MIN_VALUE;
			int n = st.length();
			if(n==1)
			{
				if(st.charAt(0)=='1')return 1;
				else return 0;
			}
			
			for(int i=1;i<=k;i++)
			{
				int chp=i-1;
				
				if(st.charAt(chp)=='1')n1++;
				
			}
			max=Math.max(max, n1);
		//	if(k>=n)return max;
			int slides=n-k;
			int ptr1=0, ptr2=k-1;
			
			for(int i=1;i<=slides;i++)
			{
				//pw.println(st.substring(ptr1+i, ptr2+i+1));
				ptr1++; ptr2++;
				if(st.charAt(ptr1-1)=='1')n1--;
				if(st.charAt(ptr2)=='1')n1++;
				//pw.println("m1- "+n1);
				if(n1>max)max=n1;
				if(max==k){return k;}
			}
			
			return max;
			
		}
			
		
		public static String shift(String A)
		{
			char lc = A.charAt(A.length()-1);
			return lc+A.substring(0,A.length()-1);
			
		}
		
	
		
		
		static  class Point 
		{
			long x,y;
	
			public Point(long a, long b)
			{
				x=a;
				y=b;
			}

			public int compareTo(Point o) {
				// TODO Auto-generated method stub
				return Long.compare(this.x, o.x);
				
			}

			
			
	
		}
	
		static class compx implements Comparator<Point>
		{
			public int compare(Point a, Point b)
			{
	
				if(a.x>b.x)return 1;
				if(a.x<b.x) return -1;
					
				return 0;
			}
		}
		
		static class compy implements Comparator<Point>
		{
			public int compare(Point a, Point b)
			{
	
				if(a.y>b.y)return 1;
				if(a.y<b.y) return -1;
					
				return 0;
			}
		}
	
		
		public static int lucky(long y)
		{
			
			long d = y;
			int flg=0;
			//long nd = (long)Math.floor(Math.log10((double)y));
			//pw.println(nd);
			for(;d>=1;d=d/10)
			{
				long dg = d%10;
				if(dg!=0)flg++;
				if(flg==2)return 0;
					
			}
			return 1;
			
		}
		
		public static void main(String[] args) {
	
			
			
			//pw.println(max1("11",2));
			/*String nm = "10011";
			for(int i=0;i<6;i++)
			{
				nm = shift(nm);
				pw.println(nm);
				pw.println(max1(nm,3));
				pw.println("****");
			}*/
	
			
			/*Point arr[] = new Point[4];
			for(int i=0;i<4;i++)
			{
				int a = sc.nextInt();
				int b = sc.nextInt();
				Point p = new Point(a,b);
				arr[i]=p;
			}
			Arrays.sort(arr, new compx());*/
			//for(int i=0;i<4;i++)pw.println(arr[i].x+" "+arr[i].y);
			
		int n  =sc.nextInt();
		int w = sc.nextInt();
		
		Point[] arr =new Point[n];
		int tcap=0;
		int flg=1;
		
		HashMap<Integer,Integer> map = new HashMap<Integer,Integer>();
		HashMap<Integer,Integer> fmap = new HashMap<Integer,Integer>();
		for(int i=0;i<n;i++)
		{
			int tc = sc.nextInt();
			
			Point p = new Point(tc,i);
			arr[i]=p;
			//map.put(arr[i],i);
		tcap+=tc;
		}
		
		if(w>tcap)
		{
			pw.println(-1);
			return;
		}
		int tea=w;
		Arrays.sort(arr, new compx());
		
		/*for(int i=0;i<n;i++)
		{
			fmap.put(i,map.get(arr[i]));
		}
		*/
		Point[] fill = new Point[n];
		
		for(int i=0;i<n;i++)
		{
			fill[i] = new Point(0,arr[i].y);
			
		}
		
		
		for(int i=0;i<n;i++)
		{
			long ccap =  arr[i].x;
			int min = (int)Math.ceil(((double)ccap/2));
			//pw.println("min "+min);
			tea-=min;
			fill[i].x+=min;
			if(tea<0)
			{
				pw.println(-1);
				return;
			}
		}
		int tover=0;
		if(tea==0)
		{
			Arrays.sort(fill, new compy());
			//pw.println("sd");
			for(int i=0;i<n;i++)
				{
				//pw.println(32);
			pw.print(fill[i].x+" ");

				}
			pw.close();
			return;

		}
		
		
		for(int i=n-1;i>=0;i--)
		{
			long mfill = arr[i].x-fill[i].x;
			if(tea<=0)break;
			if(mfill<=tea)
			{
				fill[i].x+=mfill;
				tea-=mfill;
			}
			else
			{
				
				fill[i].x+=tea;
				tea=0;
			}
			if(tea<=0)break;
		}
		

		Arrays.sort(fill, new compy());
		for(int i=0;i<n;i++)pw.print(fill[(i)].x+" ");

		
		
		
		
	pw.close();
		}
	
		
		
		
		
		
		
		
		
		
		
		
		
		
		
		
		
	} 