import java.io.BufferedWriter;
import java.io.IOException;
import java.io.InputStream;
import java.io.OutputStream;
import java.io.OutputStreamWriter;
import java.io.PrintWriter;
import java.io.Writer;
import java.util.InputMismatchException;
import java.util.StringTokenizer;
public class Main {
	
   public interface SpaceCharFilter {
       public boolean isSpaceChar(int ch);
       }
   class InputReader {
       private InputStream stream;
       private byte[] buf = new byte[1024];
       private int curChar;
       private int numChars;
       private SpaceCharFilter filter;
       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 int readInt() {

           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 readLong() {
           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 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();
       }
   }
class OutputWriter {
       private final PrintWriter writer;
       public OutputWriter(OutputStream outputStream) {
           writer = new PrintWriter(new BufferedWriter(new OutputStreamWriter(outputStream)));
       }
       public OutputWriter(Writer writer) {
           this.writer = new PrintWriter(writer);
       }
       public void print(Object...objects) {
           for (int i = 0; i < objects.length; i++) {
               if (i != 0)
                   writer.print(' ');
               writer.print(objects[i]);
           }
       }
       public void printLine(Object...objects) {
           print(objects);
           writer.println();
       }
       public void close() {
           writer.close();
       }
       public void flush() {
           writer.flush();
       }
       }
   /**
    * @param args
    */
   InputReader in= new InputReader(System.in);
   OutputWriter out = new OutputWriter(System.out);
   StringTokenizer tok;
       public static void main(String[] args) throws IOException
       {
          new Main().run();
       }
       void run() throws IOException
       {      
          solve();
          out.flush();
          tok=null;
       }

       public void  printBinary(long x){
    	   String str=Long.toBinaryString(x);
    	   int len=str.length();
    	   for (int k=len-2;k>=0;k--){
    		   if (str.charAt(k)=='1'){
    			   out.print(len-1-k+" ");
    		   }
    	   }
    		   out.printLine();
       }
       void solve() throws IOException{
    
    	   long[] dp=new long[1000*60+1];
    	   int[] V=new int[60];
    	   dp[0]=1;
    	   int N,Q;
    	   N=in.readInt();
    	   Q=in.readInt();
    	   while (N+Q>0){
    		   int mSum=0;
    		  
    		   for (int i=0;i<N;++i) {
    			   V[i]=in.readInt();
    			   mSum+=V[i];
    		   }
    		   for (int i=0;i<=mSum;++i) dp[i]=0;
    		   dp[0]=1;
    		   for (int i=0;i<N;++i){
    			   for (int a=mSum;a>=V[i];a--){
    					   dp[a]|=((dp[a-V[i]])<<1);
    			   }
    		   }
    		   for (int q=0;q<Q;++q){
    			   int qi=in.readInt();
    			   if (qi>mSum) {
    				   out.printLine("That's impossible!");
    			   }else{
    			   if (dp[qi]==0){
    				   out.printLine("That's impossible!");
    			   }else{
    				  
    				   printBinary(dp[qi]);
    			   }}
    			   
    		   }
    		   N=in.readInt();
    		   Q=in.readInt();
    	   }
       }
}