Polycarp has n coins, the value of the i-th coin is a_i. It is guaranteed that all the values are integer powers of 2 (i.e. a_i = 2^d for some non-negative integer number d).

Polycarp wants to know answers on q queries. The j-th query is described as integer number b_j. The answer to the query is the minimum number of coins that is necessary to obtain the value b_j using some subset of coins (Polycarp can use only coins he has). If Polycarp can't obtain the value b_j, the answer to the j-th query is -1.

The queries are independent (the answer on the query doesn't affect Polycarp's coins).

Input

The first line of the input contains two integers n and q (1 ≤ n, q ≤ 2 ⋅ 10^5) — the number of coins and the number of queries.

The second line of the input contains n integers a_1, a_2, ..., a_n — values of coins (1 ≤ a_i ≤ 2 ⋅ 10^9). It is guaranteed that all a_i are integer powers of 2 (i.e. a_i = 2^d for some non-negative integer number d).

The next q lines contain one integer each. The j-th line contains one integer b_j — the value of the j-th query (1 ≤ b_j ≤ 10^9).

Output

Print q integers ans_j. The j-th integer must be equal to the answer on the j-th query. If Polycarp can't obtain the value b_j the answer to the j-th query is -1.

Example

Input

5 4
2 4 8 2 4
8
5
14
10


Output

1
-1
3
2
		import java.io.BufferedReader;
	import java.io.IOException;
	import java.io.InputStream;
	import java.io.InputStreamReader;
	import java.io.PrintWriter;
	import java.util.ArrayList;
	import java.util.Arrays;
import java.util.Collections;
import java.util.Comparator;
import java.util.InputMismatchException;
	import java.util.Iterator;
	import java.util.TreeMap;
			public class Main implements Runnable
			{
				static final long MOD = 1000000007L;
				static final long MOD2 = 1000000009L;
				static class InputReader
				{
					private InputStream stream;
					private byte[] buf = new byte[1024];
					private int curChar;
					private int numChars;
					private SpaceCharFilter filter;
					private BufferedReader br=new BufferedReader(new InputStreamReader(System.in));
			 
					public InputReader(InputStream stream)
					{
						this.stream = stream;
					}
					
					public int read()
					{
						if (numChars==-1) 
							throw new InputMismatchException();
						
						if (curChar >= numChars)
						{
							curChar = 0;
							try 
							{
								numChars = stream.read(buf);
							}
							catch (IOException e)
							{
								throw new InputMismatchException();
							}
							
							if(numChars <= 0)				
								return -1;
						}
						return buf[curChar++];
					}
				 
					public String nextLine()
					{
						String str = "";
			            try
			            {
			                str = br.readLine();
			            }
			            catch (IOException e)
			            {
			                e.printStackTrace();
			            }
			            return str;
					}
					public int nextInt()
					{
						int c = read();
						
						while(isSpaceChar(c)) 
							c = read();
						
						int sgn = 1;
						
						if (c == '-') 
						{
							sgn = -1;
							c = read();
						}
						
						int res = 0;
						do 
						{
							if(c<'0'||c>'9') 
								throw new InputMismatchException();
							res *= 10;
							res += c - '0';
							c = read();
						}
						while (!isSpaceChar(c)); 
						
						return res * sgn;
					}
					
					public long nextLong() 
					{
						int c = read();
						while (isSpaceChar(c))
							c = read();
						int sgn = 1;
						if (c == '-') 
						{
							sgn = -1;
							c = read();
						}
						long res = 0;
						
						do 
						{
							if (c < '0' || c > '9')
								throw new InputMismatchException();
							res *= 10;
							res += c - '0';
							c = read();
						}
						while (!isSpaceChar(c));
							return res * sgn;
					}
					
					public double nextDouble() 
					{
						int c = read();
						while (isSpaceChar(c))
							c = read();
						int sgn = 1;
						if (c == '-') 
						{
							sgn = -1;
							c = read();
						}
						double res = 0;
						while (!isSpaceChar(c) && c != '.') 
						{
							if (c == 'e' || c == 'E')
								return res * Math.pow(10, nextInt());
							if (c < '0' || c > '9')
								throw new InputMismatchException();
							res *= 10;
							res += c - '0';
							c = read();
						}
						if (c == '.') 
						{
							c = read();
							double m = 1;
							while (!isSpaceChar(c)) 
							{
								if (c == 'e' || c == 'E')
									return res * Math.pow(10, nextInt());
								if (c < '0' || c > '9')
									throw new InputMismatchException();
								m /= 10;
								res += (c - '0') * m;
								c = read();
							}
						}
						return res * sgn;
					}
					
					public String readString() 
					{
						int c = read();
						while (isSpaceChar(c))
							c = read();
						StringBuilder res = new StringBuilder();
						do 
						{
							res.appendCodePoint(c);
							c = read();
						} 
						while (!isSpaceChar(c));
						
						return res.toString();
					}
				 
					public boolean isSpaceChar(int c) 
					{
						if (filter != null)
							return filter.isSpaceChar(c);
						return c == ' ' || c == '\n' || c == '\r' || c == '\t' || c == -1;
					}
				 
					public String next() 
					{
						return readString();
					}
					
					public interface SpaceCharFilter 
					{
						public boolean isSpaceChar(int ch);
					}
				}
			 	
				public static void main(String args[]) throws Exception
				{
					new Thread(null, new Main(),"Main",1<<26).start();
				}
				int MAXN = 100001;
				ArrayList<Integer> adj[];
				int V;
				public void run() 
				{
					InputReader sc= new InputReader(System.in);
					PrintWriter w= new PrintWriter(System.out);
					int n = sc.nextInt();
					int q = sc.nextInt();
					long count2 = 0;
					long count1= 0;
					TreeMap<Long,Long> tmap = new TreeMap();
					for(int i = 0;i < n;i++) {
						long x = sc.nextLong();
						if(!tmap.containsKey(x)) {
							tmap.put(x,0L);
						}
						tmap.put(x,tmap.get(x)+1);
					}
					while(q-- > 0) {
						long a = sc.nextLong();
						ArrayList<Long> keys = new ArrayList(tmap.keySet());
						long ans = 0;
						for(int i = keys.size()-1;i >= 0;i--) {
							long y = tmap.get(keys.get(i));
							long need = a / keys.get(i);
							if(need >= y) {
								ans += y;
								a = a - (y * keys.get(i));
							}else {
								ans += need;
								a = a - (need * keys.get(i));
							}
 						}
						if(a == 0) {
							w.println(ans);
						}else {
							w.println("-1");
						}
					}
					w.close();
				}
				int bsearch(int[] ar,int val,int[] arr,int length){
					int l = 0;
					int r = length-1;
					int ans = -1;
					while(l <= r) {
						int mid = (l + r)/2;
						if(arr[ar[mid]] >= val) {
							ans = mid;
							r = mid - 1;
						}else {
							l = mid + 1;
						}
					}
					if(ans == -1) {
						return length;
					}
					return ans;
				}
				boolean[] visited;
				void dfs(int a) {
					visited[a] = true;
					Iterator<Integer> it = adj[a].iterator();
					while(it.hasNext()) {
						int x = it.next();
						if(!visited[x]) {
							dfs(x);
						}
					}
				}
				int cnt=  0;
				void dfsUtil(int a,boolean[] visit) {
					visit[a] = true;
					Iterator<Integer> it = adj[a].iterator();
					while(it.hasNext()) {
						int x = it.next();
						if(!visit[x]) {
							cnt++;
							dfsUtil(x,visit);
						}
					}
				}
				
				String reverse(String a) {
					String navi = "";
					for(int i = a.length()-1;i >= 0;i--) {
						navi += a.charAt(i);
					}
					return navi;
				}
				static boolean isPrime(long n)
			    {
			        // Corner cases
			        if (n <= 1) return false;
			        if (n <= 3) return true;
			     
			        // This is checked so that we can skip 
			        // middle five numbers in below loop
			        if (n % 2 == 0 || n % 3 == 0) return false;
			     
			        for (int i = 5; i * i <= n; i = i + 6)
			            if (n % i == 0 || n % (i + 2) == 0)
			            return false;
			     
			        return true;
			    }
			 
				long count = 0;
				long[][] dist;
				void flydwarShall(int k,int size) {
					for(int i = 0;i < size;i++) {
						for(int j = 0;j < size;j++) {
							if(dist[i][j] > dist[i][k] + dist[k][j]) {
								dist[i][j] = dist[i][k] + dist[k][j];
							}
						}
					}
				}
				Pair[] segTree;
				int[] arr;
				void build(int l,int r,int pos) {
					if(l == r) {
						segTree[pos] = new Pair(1,1,1,arr[l],arr[l],true);
						return;
					}
					int mid = (l + r) >> 1;
					build(l,mid,2*pos+1);
					build(mid+1, r, 2*pos+2);
					segTree[pos] = merge(segTree[2*pos+1], segTree[2*pos+2]);
				}
				Pair merge(Pair p1,Pair p2) {
					if(p1.val1 == 0) {
						return p2;
					}else if(p2.val1 == 0) {
						return p1;
					}
					Pair navi = new Pair();
					navi.val1 = p1.val1;
					navi.val2 = p2.val2;
					if(p1.val2 == p2.val1) {
						navi.max = Math.max(p1.max,p2.max);
						navi.first = p1.first;
						navi.second = p2.second;
						navi.whole = false;
					}else {
						navi.max = Math.max(p1.max,Math.max(p2.max,p1.second + p2.first));
						if(p1.whole && p2.whole) {
							navi.first = p1.first + p2.first;
							navi.second = p1.first + p2.first;
							navi.whole = true;
						}else if(p1.whole) {
							navi.first = p1.first + p2.first;
							navi.second = p2.second;
							navi.whole = false;
						}else if(p2.whole) {
							navi.first = p1.first;
							navi.second = p1.second + p2.first;
							navi.whole = false;
						}else {
							navi.first = p1.first;
							navi.second = p2.second;
							navi.whole = false;
						}
					}
					return navi;
				}
				Pair query(int pos, int l, int r, int start, int end)
				{
				    if(end < l || r < start)
				    {
				        return new Pair(0,0,0,0,0,false);
				    }
				    if(start <= l && r <= end)
				    {
				        // range represented by a node is completely inside the given range
				        return segTree[pos];
				    }
				    // range represented by a node is partially inside and partially outside the given range
				    int mid = (l + r) / 2;
				    Pair p1 = query(2*pos + 1, l, mid, start, end);
				    Pair p2 = query(2*pos+2, mid+1, r, start, end);
				    return merge(p1, p2);
				}
				int bsearch(Integer[] arr,int l,int r,int val) {
					int ind = -1;
					while(l <= r) {
						int mid = (l + r)/2;
						if(arr[mid] <= val) {
							l = mid + 1;
							ind = mid;
						}else {
							r = mid - 1;
						}
					}
					return ind;
				}
				
				
				long modExpo(long a,long pow,long mod) {
					long res = 1;
					while(pow > 0) {
						if(pow % 2 == 1) {
							res = (res * a) % mod;
						}
						pow = pow/2;
						a = (a * a) % mod;
					}
					return res;
				}
				  static long modInverse(long a, long m)
				    {
				        
				       
				            // If a and m are relatively prime, then modulo inverse
				            // is a^(m-2) mode m
				         
				                        return        power(a, m - 2, m);
				        
				    }
				     
				    // To compute x^y under modulo m
				// Iterative Java program to 
				// compute modular power
				
				    static long power(long x, long y,long p)
				    {
				        // Initialize result
				        long res = 1;     
				        
				        // Update x if it is more  
				        // than or equal to p
				        x = x % p; 
				     
				        while (y > 0)
				        {
				            // If y is odd, multiply x
				            // with result
				            if((y & 1)==1)
				                res = (res * x) % p;
				     
				            // y must be even now
				            // y = y / 2
				            y = y >> 1; 
				            x = (x * x) % p; 
				        }
				        return res;
				    }
				static class Temp implements Comparable<Temp>{
					String a;
					int b;
					Temp(String a,int b){
						this.a = a;
						this.b = b;
					}
					@Override
					public int compareTo(Temp t){
						return Integer.compare(t.b,this.b);
					}
				}
				static class Pair implements Comparable<Pair>{
					int first;
					int max;
					int second;
					int val1;
					int val2;
					boolean whole;
					
					Pair (int a,int b,int c,int val1,int val2,boolean whole){
						this.first = a;
						this.max = b;
						this.second = c;
						this.val1= val1;
						this.val2 = val2;
						this.whole = whole;
					}
					Pair(){
						
					}
					public boolean equals(Object o)
					{
						Pair p = (Pair)o;
						return (p.first==first && p.max==max) || (p.first == max && p.first == max);
					}
					public int hashCode()
					{
						return new Long(first).hashCode()*31 + new Long(max).hashCode();
					}
					public int compareTo(Pair p){
						return Long.compare(p.first,this.first);
					}
				}
			
			}