import java.io.IOException;
import java.io.OutputStreamWriter;
import java.io.BufferedWriter;
import java.util.Set;
import java.io.OutputStream;
import java.io.PrintWriter;
import java.io.Writer;
import java.util.HashSet;
import java.io.InputStream;

/**
 * Built using CHelper plug-in
 * Actual solution is at the top
 * @author Mahmoud Aladdin <aladdin3>
 */
public class Main {
	public static void main(String[] args) {
		InputStream inputStream = System.in;
		OutputStream outputStream = System.out;
		InputReader in = new InputReader(inputStream);
		OutputWriter out = new OutputWriter(outputStream);
		TaskC solver = new TaskC();
		solver.solve(1, in, out);
		out.close();
	}
}

class TaskC {
    public void solve(int testNumber, InputReader jin, OutputWriter jout) {
        int n = jin.int32();
        int k = jin.int32();

        if(k == 0) {
            if(n == 1) {
                jout.println(1);
            } else {
                jout.println(-1);
            }
        } else {
            if(k < (n >> 1)) {
                jout.println(-1);
            } else {
                Set<Integer> arr = new HashSet<Integer>();
                StringBuffer out = new StringBuffer();
                int up = k - (n >> 1);
                for(int b = 1; b <= (n >> 1); b++) {
                    if(up % b > 0) continue;
                    int a = (up / b) + 1;
                    if((2L * a * b) > (int)1e9) continue;
                    if(a <= 0) continue;
                    out.setLength(0); arr.clear();
                    for(int i = 1; i <= (b * 2); i++) {
                        out.append(a * i);
                        out.append(' ');
                        arr.add(a * i);
                    }
                    int c = ((n >> 1) - b);
                    int start = -1;
                    for(int i = 0; i < c; i += 2) {
                        start += 2;
                        if(arr.contains(start) || arr.contains(start + 1)) {
                            i -= 2;
                            continue;
                        }
                        out.append(start);
                        out.append(' ');
                        out.append(start + 1);
                        out.append(' ');
                        arr.add(start);
                        arr.add(start + 1);
                    }
                    if(n % 2 == 1) {
                        start = 1;
                        while(arr.contains(start)) start++;
                        out.append(start);
                    }
                    jout.println(out);
                    break;
                }
            }
        }
    }
}

class InputReader {
    private static final int bufferMaxLength = 1024;
    private InputStream in;
    private byte[] buffer;
    private int currentBufferSize;
    private int currentBufferTop;
    private static final String tokenizers = " \t\r\f\n";

    public InputReader(InputStream stream) {
        this.in = stream;
        buffer = new byte[bufferMaxLength];
        currentBufferSize = 0;
        currentBufferTop = 0;
    }

    private boolean refill() {
        try {
            this.currentBufferSize = this.in.read(this.buffer);
            this.currentBufferTop = 0;
        } catch(Exception e) {}
        return this.currentBufferSize > 0;
    }

    private Byte readChar() {
        if(currentBufferTop < currentBufferSize) {
            return this.buffer[this.currentBufferTop++];
        } else {
            if(!this.refill()) {
                return null;
            } else {
                return readChar();
            }
        }
    }

    public String token()  {
        StringBuffer tok = new StringBuffer();
        Byte first;
        while((first = readChar()) != null && (tokenizers.indexOf((char) first.byteValue()) != -1));
        if(first == null) return null;
        tok.append((char)first.byteValue());
        while((first = readChar()) != null && (tokenizers.indexOf((char) first.byteValue()) == -1)) {
            tok.append((char)first.byteValue());
        }
        return tok.toString();
    }

    public Integer int32() throws NumberFormatException {
        String tok = token();
        return tok == null? null : Integer.parseInt(tok);
    }

    }

class OutputWriter {
    private final int bufferMaxOut = 1024;
    private PrintWriter out;
    private StringBuilder output;
    private boolean forceFlush = false;

    public OutputWriter(OutputStream outStream) {
        out = new PrintWriter(new BufferedWriter(new OutputStreamWriter(outStream)));
        output = new StringBuilder(2 * bufferMaxOut);
    }

    public OutputWriter(Writer writer) {
        forceFlush = true;
        out = new PrintWriter(writer);
        output = new StringBuilder(2 * bufferMaxOut);
    }

    private void autoFlush() {
        if(forceFlush || output.length() >= bufferMaxOut) {
            flush();
        }
    }

    public void print(Object... tokens) {
        for(int i = 0; i < tokens.length; i++) {
            if(i != 0) output.append(' ');
            output.append(tokens[i]);
        }
        autoFlush();
    }

    public void println(Object... tokens) {
        print(tokens);
        output.append('\n');
        autoFlush();
    }

    public void flush() {
        out.print(output);
        output.setLength(0);
    }

    public void close() {
        flush();
        out.close();
    }
}


import java.io.IOException;
import java.io.OutputStreamWriter;
import java.io.BufferedWriter;
import java.util.Set;
import java.io.OutputStream;
import java.io.PrintWriter;
import java.io.Writer;
import java.util.HashSet;
import java.io.InputStream;

/**
 * Built using CHelper plug-in
 * Actual solution is at the top
 * @author Mahmoud Aladdin <aladdin3>
 */
public class Main {
	public static void main(String[] args) {
		InputStream inputStream = System.in;
		OutputStream outputStream = System.out;
		InputReader in = new InputReader(inputStream);
		OutputWriter out = new OutputWriter(outputStream);
		TaskC solver = new TaskC();
		solver.solve(1, in, out);
		out.close();
	}
}

class TaskC {
    public void solve(int testNumber, InputReader jin, OutputWriter jout) {
        int n = jin.int32();
        int k = jin.int32();

        if(k == 0) {
            if(n == 1) {
                jout.println(1);
            } else {
                jout.println(-1);
            }
        } else {
            if(k < (n >> 1)) {
                jout.println(-1);
            } else {
                Set<Integer> arr = new HashSet<Integer>();
                StringBuffer out = new StringBuffer();
                int up = k - (n >> 1);
                for(int b = 1; b <= (n >> 1); b++) {
                    if(up % b > 0) continue;
                    int a = (up / b) + 1;
                    if((2L * a * b) > (int)1e9) continue;
                    if(a <= 0) continue;
                    out.setLength(0); arr.clear();
                    for(int i = 1; i <= (b * 2); i++) {
                        out.append(a * i);
                        out.append(' ');
                        arr.add(a * i);
                    }
                    int c = ((n >> 1) - b);
                    int start = -1;
                    for(int i = 0; i < c; i++) {
                        start += 2;
                        if(arr.contains(start) || arr.contains(start + 1)) {
                            i--;
                            continue;
                        }
                        out.append(start);
                        out.append(' ');
                        out.append(start + 1);
                        out.append(' ');
                        arr.add(start);
                        arr.add(start + 1);
                    }
                    if(n % 2 == 1) {
                        start = 1;
                        while(arr.contains(start)) start++;
                        out.append(start);
                    }
                    jout.println(out);
                    break;
                }
                if(out.length() == 0) {
                    jout.println(-1);
                }
            }
        }
    }
}

class InputReader {
    private static final int bufferMaxLength = 1024;
    private InputStream in;
    private byte[] buffer;
    private int currentBufferSize;
    private int currentBufferTop;
    private static final String tokenizers = " \t\r\f\n";

    public InputReader(InputStream stream) {
        this.in = stream;
        buffer = new byte[bufferMaxLength];
        currentBufferSize = 0;
        currentBufferTop = 0;
    }

    private boolean refill() {
        try {
            this.currentBufferSize = this.in.read(this.buffer);
            this.currentBufferTop = 0;
        } catch(Exception e) {}
        return this.currentBufferSize > 0;
    }

    private Byte readChar() {
        if(currentBufferTop < currentBufferSize) {
            return this.buffer[this.currentBufferTop++];
        } else {
            if(!this.refill()) {
                return null;
            } else {
                return readChar();
            }
        }
    }

    public String token()  {
        StringBuffer tok = new StringBuffer();
        Byte first;
        while((first = readChar()) != null && (tokenizers.indexOf((char) first.byteValue()) != -1));
        if(first == null) return null;
        tok.append((char)first.byteValue());
        while((first = readChar()) != null && (tokenizers.indexOf((char) first.byteValue()) == -1)) {
            tok.append((char)first.byteValue());
        }
        return tok.toString();
    }

    public Integer int32() throws NumberFormatException {
        String tok = token();
        return tok == null? null : Integer.parseInt(tok);
    }

    }

class OutputWriter {
    private final int bufferMaxOut = 1024;
    private PrintWriter out;
    private StringBuilder output;
    private boolean forceFlush = false;

    public OutputWriter(OutputStream outStream) {
        out = new PrintWriter(new BufferedWriter(new OutputStreamWriter(outStream)));
        output = new StringBuilder(2 * bufferMaxOut);
    }

    public OutputWriter(Writer writer) {
        forceFlush = true;
        out = new PrintWriter(writer);
        output = new StringBuilder(2 * bufferMaxOut);
    }

    private void autoFlush() {
        if(forceFlush || output.length() >= bufferMaxOut) {
            flush();
        }
    }

    public void print(Object... tokens) {
        for(int i = 0; i < tokens.length; i++) {
            if(i != 0) output.append(' ');
            output.append(tokens[i]);
        }
        autoFlush();
    }

    public void println(Object... tokens) {
        print(tokens);
        output.append('\n');
        autoFlush();
    }

    public void flush() {
        out.print(output);
        output.setLength(0);
    }

    public void close() {
        flush();
        out.close();
    }
}


/*
 * @author Rishab Banerjee
 * COE NSIT
 */

/*
 	 *		this is mandatory
 	 * 		BufferedReader in=new BufferedReader(new InputStreamReader(System.in));
 	 * 		PrintStream out=new PrintStream(System.out);
 	 *
 	 * 		single integer input
 	 * 		Integer.parseInt(in.readLine());
 	 *
 	 *
 	 *      when reading inputs seperated by spaces
 	 *      String str[]=in.readLine().split(" ");
 	 *      Integer.parseInt(str[i]);
 	 *      if 2 arrays need to be filled, one on each line, instead of creating 2 string[] use,
 	 *      str=in.readLine().split(" ");
 	 *      Integer.parseInt(str[i]);
 	 *
	 *
	 *
	 *      when reading new inputs in new line
	 *  	Integer.parseInt(in.readLine());
	 *
	 *  	out.close();
*/

import java.io.*;
public class Main {
	public static int n,k;
	public static void main(String[] args) throws IOException {
		 // TODO Auto-generated method stub
		 checker check=new checker();
		 BufferedReader in=new BufferedReader(new InputStreamReader(System.in));
		 PrintStream out = new PrintStream(System.out);
		 String str[]=in.readLine().split(" ");
		 boolean flag=false;
		 int i,temp;
		 n=Integer.parseInt(str[0]);
		 k=Integer.parseInt(str[1]);

		 if(n==1)
		 {
			 if(k>0)
			 {
				 out.print(-1);
				 return;
			 }
			 else
			 {
				 out.print(-1);
				 return ;
			 }
		 }
		 if(check.even(n)==false)
		 {
			 --n;
			 flag=true;
		 }

		 if((n>>1)>k)
		 {
			 out.print(-1);
			 return ;
		 }

		 for(i=1;i<=n-2;++i)
			 out.print(i+" ");
		 if((k-((n-2)>>1))<=i)
			 out.print((i/(k-((n-2)>>1))+1)*(k-((n-2)>>1))+" "+(i/(k-((n-2)>>1))+2)*(k-((n-2)>>1)));
		 else
			 out.print( (k-((n-2)>>1))+" "+((k-((n-2)>>1))<<1));

		 if(flag==true)
			 out.print(" "+"1000000000");
		 out.close();
		 return ;
	}

}
class checker extends Main{
	boolean  even(int x)
	{
		if((x&1)==0)
			return true;
		return false;
	}
}


/*
 * @author Rishab Banerjee
 * COE NSIT
 */

/*
 	 *		this is mandatory
 	 * 		BufferedReader in=new BufferedReader(new InputStreamReader(System.in));
 	 * 		PrintStream out=new PrintStream(System.out);
 	 *
 	 * 		single integer input
 	 * 		Integer.parseInt(in.readLine());
 	 *
 	 *
 	 *      when reading inputs seperated by spaces
 	 *      String str[]=in.readLine().split(" ");
 	 *      Integer.parseInt(str[i]);
 	 *      if 2 arrays need to be filled, one on each line, instead of creating 2 string[] use,
 	 *      str=in.readLine().split(" ");
 	 *      Integer.parseInt(str[i]);
 	 *
	 *
	 *
	 *      when reading new inputs in new line
	 *  	Integer.parseInt(in.readLine());
	 *
	 *  	out.close();
*/

import java.io.*;
public class Main {
	public static int n,k;
	public static void main(String[] args) throws IOException {
		 // TODO Auto-generated method stub
		 checker check=new checker();
		 BufferedReader in=new BufferedReader(new InputStreamReader(System.in));
		 PrintStream out = new PrintStream(System.out);
		 String str[]=in.readLine().split(" ");
		 boolean flag=false;
		 int i,temp;
		 n=Integer.parseInt(str[0]);
		 k=Integer.parseInt(str[1]);

		 if(check.even(n)==false)
		 {
			 --n;
			 flag=true;
		 }

		 if((n>>1)>k)
		 {
			 out.print(-1);
			 return ;
		 }

		 for(i=1;i<=n-2;++i)
			 out.print(i+" ");
		 if((k-((n-2)>>1))<=i)
			 out.print(3*(k-((n-2)>>1))+" "+5*(k-((n-2)>>1)));
		 else
			 out.print( (k-((n-2)>>1))+" "+((k-((n-2)>>1))<<1));

		 if(flag==true)
			 out.print(" "+"1000000000");
		 out.close();
		 return ;
	}

}
class checker extends Main{
	boolean  even(int x)
	{
		if((x&1)==0)
			return true;
		return false;
	}
}


/*
 * @author Rishab Banerjee
 * COE NSIT
 */

/*
 	 *		this is mandatory
 	 * 		BufferedReader in=new BufferedReader(new InputStreamReader(System.in));
 	 * 		PrintStream out=new PrintStream(System.out);
 	 *
 	 * 		single integer input
 	 * 		Integer.parseInt(in.readLine());
 	 *
 	 *
 	 *      when reading inputs seperated by spaces
 	 *      String str[]=in.readLine().split(" ");
 	 *      Integer.parseInt(str[i]);
 	 *      if 2 arrays need to be filled, one on each line, instead of creating 2 string[] use,
 	 *      str=in.readLine().split(" ");
 	 *      Integer.parseInt(str[i]);
 	 *
	 *
	 *
	 *      when reading new inputs in new line
	 *  	Integer.parseInt(in.readLine());
	 *
	 *  	out.close();
*/

import java.io.*;
public class Main {
	public static int n,k;
	public static void main(String[] args) throws IOException {
		 // TODO Auto-generated method stub
		 checker check=new checker();
		 BufferedReader in=new BufferedReader(new InputStreamReader(System.in));
		 PrintStream out = new PrintStream(System.out);
		 String str[]=in.readLine().split(" ");
		 boolean flag=false;
		 int i,temp;
		 n=Integer.parseInt(str[0]);
		 k=Integer.parseInt(str[1]);

		 if(n==1)
		 {
			 if(k>0)
			 {
				 out.print(-1);
				 return;
			 }
			 else
			 {
				 out.print(1);
				 return ;
			 }
		 }
		 if(check.even(n)==false)
		 {
			 --n;
			 flag=true;
		 }

		 if((n>>1)>k)
		 {
			 out.print(-1);
			 return ;
		 }

		 for(i=1;i<=n-2;++i)
			 out.print(i+" ");
		 if((k-((n-2)>>1))<=i)
			 out.print((i/(k-((n-2)>>1))+1)*(k-((n-2)>>1))+" "+(i/(k-((n-2)>>1))+2)*(k-((n-2)>>1)));
		 else
			 out.print( (k-((n-2)>>1))+" "+((k-((n-2)>>1))<<1));

		 if(flag==true)
			 out.print(" "+"1000000000");
		 out.close();
		 return ;
	}

}
class checker extends Main{
	boolean  even(int x)
	{
		if((x&1)==0)
			return true;
		return false;
	}
}


/*
 * @author Rishab Banerjee
 * COE NSIT
 */

/*
 	 *		this is mandatory
 	 * 		BufferedReader in=new BufferedReader(new InputStreamReader(System.in));
 	 * 		PrintStream out=new PrintStream(System.out);
 	 *
 	 * 		single integer input
 	 * 		Integer.parseInt(in.readLine());
 	 *
 	 *
 	 *      when reading inputs seperated by spaces
 	 *      String str[]=in.readLine().split(" ");
 	 *      Integer.parseInt(str[i]);
 	 *      if 2 arrays need to be filled, one on each line, instead of creating 2 string[] use,
 	 *      str=in.readLine().split(" ");
 	 *      Integer.parseInt(str[i]);
 	 *
	 *
	 *
	 *      when reading new inputs in new line
	 *  	Integer.parseInt(in.readLine());
	 *
	 *  	out.close();
*/

import java.io.*;
public class Main {
	public static int n,k;
	public static void main(String[] args) throws IOException {
		 // TODO Auto-generated method stub
		 checker check=new checker();
		 BufferedReader in=new BufferedReader(new InputStreamReader(System.in));
		 PrintStream out = new PrintStream(System.out);
		 String str[]=in.readLine().split(" ");
		 boolean flag=false;
		 int i,temp;
		 n=Integer.parseInt(str[0]);
		 k=Integer.parseInt(str[1]);

		 if(n==1)
		 {
			 out.print(-1);
			 return ;
		 }
		 if(check.even(n)==false)
		 {
			 --n;
			 flag=true;
		 }

		 if((n>>1)>k)
		 {
			 out.print(-1);
			 return ;
		 }

		 for(i=1;i<=n-2;++i)
			 out.print(i+" ");
		 if((k-((n-2)>>1))<=i)
			 out.print(2*(k-((n-2)>>1))+" "+3*(k-((n-2)>>1)));
		 else
			 out.print( (k-((n-2)>>1))+" "+((k-((n-2)>>1))<<1));

		 if(flag==true)
			 out.print(" "+"1000000000");
		 out.close();
		 return ;
	}

}
class checker extends Main{
	boolean  even(int x)
	{
		if((x&1)==0)
			return true;
		return false;
	}
}


/*
 * @author Rishab Banerjee
 * COE NSIT
 */

/*
 	 *		this is mandatory
 	 * 		BufferedReader in=new BufferedReader(new InputStreamReader(System.in));
 	 * 		PrintStream out=new PrintStream(System.out);
 	 *
 	 * 		single integer input
 	 * 		Integer.parseInt(in.readLine());
 	 *
 	 *
 	 *      when reading inputs seperated by spaces
 	 *      String str[]=in.readLine().split(" ");
 	 *      Integer.parseInt(str[i]);
 	 *      if 2 arrays need to be filled, one on each line, instead of creating 2 string[] use,
 	 *      str=in.readLine().split(" ");
 	 *      Integer.parseInt(str[i]);
 	 *
	 *
	 *
	 *      when reading new inputs in new line
	 *  	Integer.parseInt(in.readLine());
	 *
	 *  	out.close();
*/

import java.io.*;
public class Main {
	public static int n,k;
	public static void main(String[] args) throws IOException {
		 // TODO Auto-generated method stub
		 checker check=new checker();
		 BufferedReader in=new BufferedReader(new InputStreamReader(System.in));
		 PrintStream out = new PrintStream(System.out);
		 String str[]=in.readLine().split(" ");
		 boolean flag=false;
		 int i,temp;
		 n=Integer.parseInt(str[0]);
		 k=Integer.parseInt(str[1]);

		 if(n==1)
		 {
			 out.print(-1);
			 return ;
		 }
		 if(check.even(n)==false)
		 {
			 --n;
			 flag=true;
		 }

		 if((n>>1)>k)
		 {
			 out.print(-1);
			 return ;
		 }

		 for(i=1;i<=n-2;++i)
			 out.print(i+" ");
		 if((k-((n-2)>>1))<=i)
			 out.print((i/(k-((n-2)>>1))+1)*(k-((n-2)>>1))+" "+(i/(k-((n-2)>>1))+2)*(k-((n-2)>>1)));
		 else
			 out.print( (k-((n-2)>>1))+" "+((k-((n-2)>>1))<<1));

		 if(flag==true)
			 out.print(" "+"1000000000");
		 out.close();
		 return ;
	}

}
class checker extends Main{
	boolean  even(int x)
	{
		if((x&1)==0)
			return true;
		return false;
	}
}


import java.util.*;

public class Main {

    public static void main(String[] args) {

        Scanner in = new Scanner(System.in);

        int n = in.nextInt();
        int k = in.nextInt();

        if (n == 1) {

            if (k == 0) System.out.print(1);
            else System.out.print(-1);
            System.exit(0);
        }

        int m = n / 2;

        if (m > k || k == 0) {

            System.out.print(-1);
            System.exit(0);
        }

        int[] res = new int[100010];
        res[1] = k - m + 1;
        res[2] = 2 * res[1];

        int cnt = 2;

        for (int i = 1; i <= 1000000000; i += 2) {

            if (i == res[1] || i == res[2]) continue;
            if (i + 1 == res[1] || i + 1 == res[2]) continue;

            res[cnt + 1] = i;
            res[cnt + 2] = i + 1;

            cnt += 2;

            if (cnt >= n) break;
        }

        for (int i = 1; i <= n; i++)
            System.out.print(res[i] + " ");
    }

}


/****************************************
 **     Solution by Bahrom Sultonov    ***
 ****************************************/

import java.io.BufferedReader;
import java.io.BufferedWriter;
import java.io.IOException;
import java.io.InputStreamReader;
import java.io.OutputStreamWriter;
import java.io.PrintWriter;
import java.util.ArrayList;
import java.util.Map;
import java.util.StringTokenizer;
import java.util.TreeMap;

public class C {
	private static BufferedReader in;
	private static StringTokenizer st;
	private static PrintWriter out;

	public static void main(String[] args) throws NumberFormatException,
			IOException {
		in = new BufferedReader(new InputStreamReader(System.in));
		st = new StringTokenizer("");
		out = new PrintWriter(new BufferedWriter(new OutputStreamWriter(
				System.out)));
		int n = nextInt();
		long k = nextLong();
		if (n == 1) {
			if (k == 0) {
				System.out.println(1);
			} else {
				System.out.println(-1);
			}
			return;
		}
		if (n / k > 2) {
			System.out.println(-1);
			return;
		}
		if (n / k == 2) {
			for (int i = 1; i <= n; i++) {
				out.print(i + " ");
			}
		} else {
			long x = 2;
			for (int i = 1; i <= (k - n / 2) * 2; i++) {
				out.print(x+" ");
				x += 2;
			}
			long y =1;
			for (int i =1; i <=n-((k - n / 2) * 2); i++) {
				out.print(y+" ");
				y+=2;
			}
		}
		out.close();
	}

	static String next() throws IOException {
		while (!st.hasMoreTokens()) {
			st = new StringTokenizer(in.readLine());
		}
		return st.nextToken();
	}

	static int nextInt() throws NumberFormatException, IOException {
		return Integer.parseInt(next());
	}

	static long nextLong() throws NumberFormatException, IOException {
		return Long.parseLong(next());
	}

	static double nextDouble() throws NumberFormatException, IOException {
		return Double.parseDouble(next());
	}

}


/****************************************
 **     Solution by Bahrom Sultonov    ***
 ****************************************/

import java.io.BufferedReader;
import java.io.BufferedWriter;
import java.io.IOException;
import java.io.InputStreamReader;
import java.io.OutputStreamWriter;
import java.io.PrintWriter;
import java.util.ArrayList;
import java.util.Map;
import java.util.StringTokenizer;
import java.util.TreeMap;

public class C {
	private static BufferedReader in;
	private static StringTokenizer st;
	private static PrintWriter out;

	public static void main(String[] args) throws NumberFormatException,
			IOException {
		in = new BufferedReader(new InputStreamReader(System.in));
		st = new StringTokenizer("");
		out = new PrintWriter(new BufferedWriter(new OutputStreamWriter(
				System.out)));
		int n = nextInt();
		long k = nextLong();
		if (n == 1) {
			if (k == 0) {
				System.out.println(1);
			} else {
				System.out.println(-1);
			}
			return;
		}
		if (k==0 ||n / k > 2) {
			System.out.println(-1);
			return;
		}
		if (n / k == 2) {
			for (int i = 1; i <= n; i++) {
				out.print(i + " ");
			}
		} else {
			int x=(int)(k-(n-2)/2);
			System.out.print(x+" ");
			System.out.print( (int) (2e8 / x + 1 + 1e-6) * x+" ");
			for (int i = 3; i <=n; i++) {
				out.print((100000000+i)+" ");
			}
		}
		out.close();
	}

	static String next() throws IOException {
		while (!st.hasMoreTokens()) {
			st = new StringTokenizer(in.readLine());
		}
		return st.nextToken();
	}

	static int nextInt() throws NumberFormatException, IOException {
		return Integer.parseInt(next());
	}

	static long nextLong() throws NumberFormatException, IOException {
		return Long.parseLong(next());
	}

	static double nextDouble() throws NumberFormatException, IOException {
		return Double.parseDouble(next());
	}

}


/****************************************
 **     Solution by Bahrom Sultonov    ***
 ****************************************/

import java.io.BufferedReader;
import java.io.BufferedWriter;
import java.io.IOException;
import java.io.InputStreamReader;
import java.io.OutputStreamWriter;
import java.io.PrintWriter;
import java.util.ArrayList;
import java.util.Map;
import java.util.StringTokenizer;
import java.util.TreeMap;

public class C {
	private static BufferedReader in;
	private static StringTokenizer st;
	private static PrintWriter out;

	public static void main(String[] args) throws NumberFormatException,
			IOException {
		in = new BufferedReader(new InputStreamReader(System.in));
		st = new StringTokenizer("");
		out = new PrintWriter(new BufferedWriter(new OutputStreamWriter(
				System.out)));
		int n = nextInt();
		long k = nextLong();
		if(n==1 && k==1){
			System.out.println(1);
			return;
		}
		if (n == 1) {
			if (k == 0) {
				System.out.println(1);
			} else {
				System.out.println(-1);
			}
			return;
		}
		if (k==0 ||n / k > 2) {
			System.out.println(-1);
			return;
		}
		if (n / k == 2) {
			for (int i = 1; i <= n; i++) {
				out.print(i + " ");
			}
		} else {
			int x=(int)(k-(n-2)/2);
			System.out.print(x+" ");
			System.out.print( (int) (2e8 / x + 1 + 1e-6) * x+" ");
			for (int i = 3; i <=n; i++) {
				out.print((100000000+i)+" ");
			}
		}
		out.close();
	}

	static String next() throws IOException {
		while (!st.hasMoreTokens()) {
			st = new StringTokenizer(in.readLine());
		}
		return st.nextToken();
	}

	static int nextInt() throws NumberFormatException, IOException {
		return Integer.parseInt(next());
	}

	static long nextLong() throws NumberFormatException, IOException {
		return Long.parseLong(next());
	}

	static double nextDouble() throws NumberFormatException, IOException {
		return Double.parseDouble(next());
	}

}


/****************************************
 **     Solution by Bahrom Sultonov    ***
 ****************************************/

import java.io.BufferedReader;
import java.io.BufferedWriter;
import java.io.IOException;
import java.io.InputStreamReader;
import java.io.OutputStreamWriter;
import java.io.PrintWriter;
import java.util.ArrayList;
import java.util.Map;
import java.util.StringTokenizer;
import java.util.TreeMap;

public class C {
	private static BufferedReader in;
	private static StringTokenizer st;
	private static PrintWriter out;

	public static void main(String[] args) throws NumberFormatException,
			IOException {
		in = new BufferedReader(new InputStreamReader(System.in));
		st = new StringTokenizer("");
		out = new PrintWriter(new BufferedWriter(new OutputStreamWriter(
				System.out)));
		int n = nextInt();
		long k = nextLong();
//		if(n==1 && k==0){
//			System.out.println(0);
//			return;
//		}
		if (n == 1) {
			if (k == 0) {
				System.out.println(1);
			} else {
				System.out.println(-1);
			}
			return;
		}
		if (k==0 ||n /2 > k) {
			System.out.println(-1);
			return;
		}
		if (n / k == 2) {
			for (int i = 1; i <= n; i++) {
				out.print(i + " ");
			}
		} else {
			int x=(int)(k-(n-2)/2);
			System.out.print(x+" ");
			System.out.print( (int) (2e8 / x + 1 + 1e-6) * x+" ");
			for (int i = 3; i <=n; i++) {
				out.print((100000000+i)+" ");
			}
		}
		out.close();
	}

	static String next() throws IOException {
		while (!st.hasMoreTokens()) {
			st = new StringTokenizer(in.readLine());
		}
		return st.nextToken();
	}

	static int nextInt() throws NumberFormatException, IOException {
		return Integer.parseInt(next());
	}

	static long nextLong() throws NumberFormatException, IOException {
		return Long.parseLong(next());
	}

	static double nextDouble() throws NumberFormatException, IOException {
		return Double.parseDouble(next());
	}

}


/****************************************
 **     Solution by Bahrom Sultonov    ***
 ****************************************/

import java.io.BufferedReader;
import java.io.BufferedWriter;
import java.io.IOException;
import java.io.InputStreamReader;
import java.io.OutputStreamWriter;
import java.io.PrintWriter;
import java.util.ArrayList;
import java.util.Map;
import java.util.StringTokenizer;
import java.util.TreeMap;

public class C {
	private static BufferedReader in;
	private static StringTokenizer st;
	private static PrintWriter out;

	public static void main(String[] args) throws NumberFormatException,
			IOException {
		in = new BufferedReader(new InputStreamReader(System.in));
		st = new StringTokenizer("");
		out = new PrintWriter(new BufferedWriter(new OutputStreamWriter(
				System.out)));
		int n = nextInt();
		long k = nextLong();
		if(n==1 && k==0){
			System.out.println(0);
			return;
		}
		if (n == 1) {
			if (k == 0) {
				System.out.println(1);
			} else {
				System.out.println(-1);
			}
			return;
		}
		if (k==0 ||n / k > 2) {
			System.out.println(-1);
			return;
		}
		if (n / k == 2) {
			for (int i = 1; i <= n; i++) {
				out.print(i + " ");
			}
		} else {
			int x=(int)(k-(n-2)/2);
			System.out.print(x+" ");
			System.out.print( (int) (2e8 / x + 1 + 1e-6) * x+" ");
			for (int i = 3; i <=n; i++) {
				out.print((100000000+i)+" ");
			}
		}
		out.close();
	}

	static String next() throws IOException {
		while (!st.hasMoreTokens()) {
			st = new StringTokenizer(in.readLine());
		}
		return st.nextToken();
	}

	static int nextInt() throws NumberFormatException, IOException {
		return Integer.parseInt(next());
	}

	static long nextLong() throws NumberFormatException, IOException {
		return Long.parseLong(next());
	}

	static double nextDouble() throws NumberFormatException, IOException {
		return Double.parseDouble(next());
	}

}


/****************************************
 **     Solution by Bahrom Sultonov    ***
 ****************************************/

import java.io.BufferedReader;
import java.io.BufferedWriter;
import java.io.IOException;
import java.io.InputStreamReader;
import java.io.OutputStreamWriter;
import java.io.PrintWriter;
import java.util.ArrayList;
import java.util.Map;
import java.util.StringTokenizer;
import java.util.TreeMap;

public class C {
	private static BufferedReader in;
	private static StringTokenizer st;
	private static PrintWriter out;

	public static void main(String[] args) throws NumberFormatException,
			IOException {
		in = new BufferedReader(new InputStreamReader(System.in));
		st = new StringTokenizer("");
		out = new PrintWriter(new BufferedWriter(new OutputStreamWriter(
				System.out)));
		int n = nextInt();
		long k = nextLong();
		if (n == 1) {
			if (k == 0) {
				System.out.println(1);
			} else {
				System.out.println(-1);
			}
			return;
		}
		if (k==0 ||n / k > 2) {
			System.out.println(-1);
			return;
		}
		if (n / k == 2) {
			for (int i = 1; i <= n; i++) {
				out.print(i + " ");
			}
		} else {
			int x=(int)(k-(n-2)/2);
			System.out.print(x+" ");
			System.out.print( (int) (2e8+x)*x+" ");
			for (int i = 3; i <=n; i++) {
				out.print((100000000+i)+" ");
			}
		}
		out.close();
	}

	static String next() throws IOException {
		while (!st.hasMoreTokens()) {
			st = new StringTokenizer(in.readLine());
		}
		return st.nextToken();
	}

	static int nextInt() throws NumberFormatException, IOException {
		return Integer.parseInt(next());
	}

	static long nextLong() throws NumberFormatException, IOException {
		return Long.parseLong(next());
	}

	static double nextDouble() throws NumberFormatException, IOException {
		return Double.parseDouble(next());
	}

}


/****************************************
 **     Solution by Bahrom Sultonov    ***
 ****************************************/

import java.io.BufferedReader;
import java.io.BufferedWriter;
import java.io.IOException;
import java.io.InputStreamReader;
import java.io.OutputStreamWriter;
import java.io.PrintWriter;
import java.util.ArrayList;
import java.util.Map;
import java.util.StringTokenizer;
import java.util.TreeMap;

public class C {
	private static BufferedReader in;
	private static StringTokenizer st;
	private static PrintWriter out;

	public static void main(String[] args) throws NumberFormatException,
			IOException {
		in = new BufferedReader(new InputStreamReader(System.in));
		st = new StringTokenizer("");
		out = new PrintWriter(new BufferedWriter(new OutputStreamWriter(
				System.out)));
		int n = nextInt();
		long k = nextLong();
		if (n == 1) {
			if (k == 0) {
				System.out.println(1);
			} else {
				System.out.println(-1);
			}
			return;
		}
		if (k==0 ||n / k > 2) {
			System.out.println(-1);
			return;
		}
		if (n / k == 2) {
			for (int i = 1; i <= n; i++) {
				out.print(i + " ");
			}
		} else {
			long x = 2;
			for (int i = 1; i <= (k - n / 2) * 2; i++) {
				out.print(x+" ");
				x += 2;
			}
			long y =1;
			for (int i =1; i <=n-((k - n / 2) * 2); i++) {
				out.print(y+" ");
				y+=2;
			}
		}
		out.close();
	}

	static String next() throws IOException {
		while (!st.hasMoreTokens()) {
			st = new StringTokenizer(in.readLine());
		}
		return st.nextToken();
	}

	static int nextInt() throws NumberFormatException, IOException {
		return Integer.parseInt(next());
	}

	static long nextLong() throws NumberFormatException, IOException {
		return Long.parseLong(next());
	}

	static double nextDouble() throws NumberFormatException, IOException {
		return Double.parseDouble(next());
	}

}


/****************************************
 **     Solution by Bahrom Sultonov    ***
 ****************************************/

import java.io.BufferedReader;
import java.io.BufferedWriter;
import java.io.IOException;
import java.io.InputStreamReader;
import java.io.OutputStreamWriter;
import java.io.PrintWriter;
import java.util.ArrayList;
import java.util.Map;
import java.util.StringTokenizer;
import java.util.TreeMap;

public class C {
	private static BufferedReader in;
	private static StringTokenizer st;
	private static PrintWriter out;

	public static void main(String[] args) throws NumberFormatException,
			IOException {
		in = new BufferedReader(new InputStreamReader(System.in));
		st = new StringTokenizer("");
		out = new PrintWriter(new BufferedWriter(new OutputStreamWriter(
				System.out)));
		int n = nextInt();
		long k = nextLong();
		if (n == 1) {
			if (k == 0) {
				System.out.println(1);
			} else {
				System.out.println(-1);
			}
			return;
		}
		if (k==0 ||n / k > 2) {
			System.out.println(-1);
			return;
		}
		if (n / k == 2) {
			for (int i = 1; i <= n; i++) {
				out.print(i + " ");
			}
		} else {
			int x=(int)(k-(n-2)/2);
			System.out.print(x+" ");
			System.out.print( (int) (2e8+x)+" ");
			for (int i = 3; i <=n; i++) {
				out.print((100000000+i)+" ");
			}
		}
		out.close();
	}

	static String next() throws IOException {
		while (!st.hasMoreTokens()) {
			st = new StringTokenizer(in.readLine());
		}
		return st.nextToken();
	}

	static int nextInt() throws NumberFormatException, IOException {
		return Integer.parseInt(next());
	}

	static long nextLong() throws NumberFormatException, IOException {
		return Long.parseLong(next());
	}

	static double nextDouble() throws NumberFormatException, IOException {
		return Double.parseDouble(next());
	}

}


import java.io.BufferedReader;
import java.io.IOException;
import java.io.InputStreamReader;
import java.io.OutputStreamWriter;
import java.io.PrintWriter;
import java.util.StringTokenizer;

public class C {
	static BufferedReader in;
	static StringTokenizer st;
	static PrintWriter out;
	public static void main(String[] args) throws IOException {
		begin();
		solve();
		end();
	}
	private static void end() {
		out.close();
	}
	private static void solve() throws IOException {
		int n = nextInt();
		int k = nextInt();
		int begin = k-n/2+1;
		if (begin < 1 || n/2 == 0){
			write(-1);
			return;
		}
		write(begin+" ");
		for (int i = 2*begin; i < 2*begin+n-1; i++) {
			write(i+" ");
		}
	}
	private static long nextLong() throws  IOException {
		return Long.parseLong(next());
	}
	private static void writeln(Object t) {
		out.println(t);
	}
	private static void write(Object t) {
		out.print(t);
	}
	private static int nextInt() throws  IOException {
		return Integer.parseInt(next());
	}
	private static String next() throws IOException {
		while (!st.hasMoreElements())
			st = new StringTokenizer(in.readLine());

		return st.nextToken();
	}
	private static void begin() {
		out = new PrintWriter(new OutputStreamWriter(System.out));
		st = new StringTokenizer("");
		in = new BufferedReader(new InputStreamReader(System.in));
	}

}


import java.io.BufferedReader;
import java.io.IOException;
import java.io.InputStreamReader;
import java.io.OutputStreamWriter;
import java.io.PrintWriter;
import java.util.StringTokenizer;

public class C {
	static BufferedReader in;
	static StringTokenizer st;
	static PrintWriter out;
	public static void main(String[] args) throws IOException {
		begin();
		solve();
		end();
	}
	private static void end() {
		out.close();
	}
	private static void solve() throws IOException {
		int n = nextInt();
		int k = nextInt();
		int begin = k-n/2+1;
		if (n == 1 && k == 0){
			write(1);
			return;
		}
		if (begin < 1 || n/2 == 0){
			write(-1);
			return;
		}
		write(begin+" ");
		for (int i = 2*begin; i < 2*begin+n-1; i++) {
			write(i+" ");
		}
	}
	private static long nextLong() throws  IOException {
		return Long.parseLong(next());
	}
	private static void writeln(Object t) {
		out.println(t);
	}
	private static void write(Object t) {
		out.print(t);
	}
	private static int nextInt() throws  IOException {
		return Integer.parseInt(next());
	}
	private static String next() throws IOException {
		while (!st.hasMoreElements())
			st = new StringTokenizer(in.readLine());

		return st.nextToken();
	}
	private static void begin() {
		out = new PrintWriter(new OutputStreamWriter(System.out));
		st = new StringTokenizer("");
		in = new BufferedReader(new InputStreamReader(System.in));
	}

}


import java.io.BufferedReader;
import java.io.IOException;
import java.io.InputStreamReader;
import java.io.OutputStreamWriter;
import java.io.PrintWriter;
import java.util.StringTokenizer;

public class C {
	static BufferedReader in;
	static StringTokenizer st;
	static PrintWriter out;
	public static void main(String[] args) throws IOException {
		begin();
		solve();
		end();
	}
	private static void end() {
		out.close();
	}
	private static void solve() throws IOException {
		int n = nextInt();
		int k = nextInt();
		int begin = k-n/2+1;
		if (begin < 1){
			write(-1);
			return;
		}
		write(begin+" ");
		for (int i = 2*begin; i < 2*begin+n-1; i++) {
			write(i+" ");
		}

	}
	private static long nextLong() throws  IOException {
		return Long.parseLong(next());
	}
	private static void writeln(Object t) {
		out.println(t);
	}
	private static void write(Object t) {
		out.print(t);
	}
	private static int nextInt() throws  IOException {
		return Integer.parseInt(next());
	}
	private static String next() throws IOException {
		while (!st.hasMoreElements())
			st = new StringTokenizer(in.readLine());

		return st.nextToken();
	}
	private static void begin() {
		out = new PrintWriter(new OutputStreamWriter(System.out));
		st = new StringTokenizer("");
		in = new BufferedReader(new InputStreamReader(System.in));
	}

}


import java.io.*;
import java.util.*;

public class Task{
    public static void main(String[] args) throws IOException{
        new Task().run();
    }

    StreamTokenizer in;
    Scanner ins;
    PrintWriter out;

    int nextInt() throws IOException{
        in.nextToken();
        return (int)in.nval;
    }

    long nextLong() throws IOException{
        in.nextToken();
        return (long)in.nval;
    }

    double nextDouble() throws IOException{
        in.nextToken();
        return in.nval;
    }

    char nextChar() throws IOException{
        in.nextToken();
        return (char)in.ttype;
    }

    String nextString() throws IOException{
        in.nextToken();
        return in.sval;
    }

    private static final String INPUT = "g.in";

    void run() throws IOException{
        in = new StreamTokenizer(new BufferedReader(new InputStreamReader(System.in)));
        ins = new Scanner(System.in);
        out = new PrintWriter(System.out);

        try{
            if(System.getProperty("xDx") != null){
                in = new StreamTokenizer(new BufferedReader(new FileReader("input.txt")));
                ins = new Scanner(new FileReader("input.txt"));
                out = new PrintWriter(new FileWriter("output.txt"));
            }else{
//                in = new StreamTokenizer(new BufferedReader(new FileReader(INPUT)));
//                ins = new Scanner(new FileReader(INPUT));
//                out = new PrintWriter(System.out);
            }
        }catch(Exception e){
//            in = new StreamTokenizer(new BufferedReader(new FileReader(INPUT)));
//            ins = new Scanner(new FileReader(INPUT));
//            out = new PrintWriter(System.out);
        }

        Set<Integer> usedNumbers = new HashSet<>();
        int n = nextInt(), k = nextInt();
        int l = n/2;
        if(k < l || (l == 0 && k > 0)){
            out.print(-1);
        }else{
            int x = k - l + 1;
            usedNumbers.add(x);
            usedNumbers.add(2*x);
            out.printf("%d %d ", x, 2*x);
            int a = 1;
            for(int i = 2; i < n; i += 2){
                while(usedNumbers.contains(a) || usedNumbers.contains(a + 1)){
                    ++a;
                }
                if(i + 1 < n){
                    out.printf("%d %d ", a, a + 1);
                    a += 2;
                }else{
                    out.printf("%d", a);
                    ++a;
                }

            }
        }
        out.close();
    }

}


import java.io.*;
import java.util.*;

public class Task{
    public static void main(String[] args) throws IOException{
        new Task().run();
    }

    StreamTokenizer in;
    Scanner ins;
    PrintWriter out;

    int nextInt() throws IOException{
        in.nextToken();
        return (int)in.nval;
    }

    long nextLong() throws IOException{
        in.nextToken();
        return (long)in.nval;
    }

    double nextDouble() throws IOException{
        in.nextToken();
        return in.nval;
    }

    char nextChar() throws IOException{
        in.nextToken();
        return (char)in.ttype;
    }

    String nextString() throws IOException{
        in.nextToken();
        return in.sval;
    }

    private static final String INPUT = "g.in";

    void run() throws IOException{
        in = new StreamTokenizer(new BufferedReader(new InputStreamReader(System.in)));
        ins = new Scanner(System.in);
        out = new PrintWriter(System.out);

        try{
            if(System.getProperty("xDx") != null){
                in = new StreamTokenizer(new BufferedReader(new FileReader("input.txt")));
                ins = new Scanner(new FileReader("input.txt"));
                out = new PrintWriter(new FileWriter("output.txt"));
            }else{
//                in = new StreamTokenizer(new BufferedReader(new FileReader(INPUT)));
//                ins = new Scanner(new FileReader(INPUT));
//                out = new PrintWriter(System.out);
            }
        }catch(Exception e){
//            in = new StreamTokenizer(new BufferedReader(new FileReader(INPUT)));
//            ins = new Scanner(new FileReader(INPUT));
//            out = new PrintWriter(System.out);
        }

        Set<Integer> usedNumbers = new HashSet<>();
        int n = nextInt(), k = nextInt();
        int l = n/2;
        if(k < l || (l == 0 && k > 0)){
            out.print(-1);
        }else{
            int x = k - l + 1;
            usedNumbers.add(x);
            usedNumbers.add(2*x);
            if(n > 1){
                out.printf("%d %d ", x, 2*x);
            }else{
                out.print(1);
            }
            int a = 1;
            for(int i = 2; i < n; i += 2){
                while(usedNumbers.contains(a) || usedNumbers.contains(a + 1)){
                    ++a;
                }
                if(i + 1 < n){
                    out.printf("%d %d ", a, a + 1);
                    a += 2;
                }else{
                    out.printf("%d", a);
                    ++a;
                }

            }
        }
        out.close();
    }

}


import java.io.BufferedReader;
import java.io.IOException;
import java.io.InputStreamReader;

/*
 * To change this license header, choose License Headers in Project Properties.
 * To change this template file, choose Tools | Templates
 * and open the template in the editor.
 */

/**
 *
 * @author DELL
 */
public class main {
     public static void main(String args[]) throws IOException {
        BufferedReader x = new BufferedReader(new InputStreamReader(System.in));
        String p = x.readLine();
        String pr[] = p.split(" ");

        int n = Integer.parseInt(pr[0]);
        int k = Integer.parseInt(pr[1]);
        if((n/2)>k) {System.out.println("-1"); return;}
        int d=n/2;

        int a[]=new int[n];
        a[0]=k-(d-1);
        a[1]=2*a[0];
        for(int i=2;i<n;i++)
        {
        a[i]=a[i-1]+1;
        }
     for(int i=0;i<n;i++)
     {
         System.out.print(a[i]+" ");
     }
     }
}


import java.io.BufferedReader;
import java.io.IOException;
import java.io.InputStreamReader;

/*
 * To change this license header, choose License Headers in Project Properties.
 * To change this template file, choose Tools | Templates
 * and open the template in the editor.
 */

/**
 *
 * @author DELL
 */
public class main {
     public static void main(String args[]) throws IOException {
        BufferedReader x = new BufferedReader(new InputStreamReader(System.in));
        String p = x.readLine();
        String pr[] = p.split(" ");

        int n = Integer.parseInt(pr[0]);
        int k = Integer.parseInt(pr[1]);
        if((n/2)>k||n==1) {System.out.println("-1"); return;}
        int d=n/2;

        int a[]=new int[n];
        a[0]=k-(d-1);

        a[1]=2*a[0];
        for(int i=2;i<n;i++)
        {
        a[i]=a[i-1]+1;
        }
     for(int i=0;i<n;i++)
     {
         System.out.print(a[i]+" ");
     }
     }
}


import java.io.BufferedReader;
import java.io.IOException;
import java.io.InputStreamReader;

/*
 * To change this license header, choose License Headers in Project Properties.
 * To change this template file, choose Tools | Templates
 * and open the template in the editor.
 */
/**
 *
 * @author DELL
 */
public class Mashmokh_and_numbers {

    public static void main(String args[]) throws IOException {
        BufferedReader x = new BufferedReader(new InputStreamReader(System.in));
        String p = x.readLine();
        String pr[] = p.split(" ");

        int n = Integer.parseInt(pr[0]);
        int k = Integer.parseInt(pr[1]);
        if ((n / 2) > k || n==1 && k==1) {
            System.out.println("-1");
            return;
        }
        int d = n / 2;

        int a[] = new int[n];
        a[0] = k - (d - 1);
        if (n > 1) {
            a[1] = 2 * a[0];
        }
        for (int i = 2; i < n; i++) {
            a[i] = a[i - 1] + 1;
        }
        for (int i = 0; i < n; i++) {
            System.out.print(a[i] + " ");
        }
    }
}


import java.io.BufferedReader;
import java.io.IOException;
import java.io.InputStreamReader;

/*
 * To change this license header, choose License Headers in Project Properties.
 * To change this template file, choose Tools | Templates
 * and open the template in the editor.
 */

/**
 *
 * @author DELL
 */
public class main {
     public static void main(String args[]) throws IOException {
        BufferedReader x = new BufferedReader(new InputStreamReader(System.in));
        String p = x.readLine();
        String pr[] = p.split(" ");

        int n = Integer.parseInt(pr[0]);
        int k = Integer.parseInt(pr[1]);
        if((n/2)>k||n==1||k==0) {System.out.println("-1"); return;}
        int d=n/2;

        int a[]=new int[n];
        a[0]=k-(d-1);

        a[1]=2*a[0];
        for(int i=2;i<n;i++)
        {
        a[i]=a[i-1]+1;
        }
     for(int i=0;i<n;i++)
     {
         System.out.print(a[i]+" ");
     }
     }
}


import java.io.BufferedReader;
import java.io.IOException;
import java.io.InputStreamReader;

/*
 * To change this license header, choose License Headers in Project Properties.
 * To change this template file, choose Tools | Templates
 * and open the template in the editor.
 */
/**
 *
 * @author DELL
 */
public class main {

    public static void main(String args[]) throws IOException {
        BufferedReader x = new BufferedReader(new InputStreamReader(System.in));
        String p = x.readLine();
        String pr[] = p.split(" ");

        int n = Integer.parseInt(pr[0]);
        int k = Integer.parseInt(pr[1]);
        if ((n / 2) > k ) {
            System.out.println("-1");
            return;
        }
        int d = n / 2;

        int a[] = new int[n];
        a[0] = k - (d - 1);
        if (n > 1) {
            a[1] = 2 * a[0];

        }
        if(n==1 && k>0) {System.out.println("-1");return;}
        for (int i = 2; i < n; i++) {
            a[i] = a[i - 1] + 1;
        }
        for (int i = 0; i < n; i++) {
            System.out.print(a[i] + " ");
        }
    }
}


import java.util.*;
import java.io.*;
import java.math.*;
import static java.math.BigInteger.*;
import static java.util.Arrays.*;
import static java.lang.Math.*;
import static java.util.Collections.*;
import static java.lang.System.out;

public class Main {
	private static final int M = (int)(1e9 + 7);
	static boolean LOCAL = System.getSecurityManager() == null;
	Scanner in = new Scanner(System.in);

	void run() {
		while (in.hasNext())
			solve();
	}
	int[] getPrime(int n) {
		int[] ps = new int[n];
		boolean[] vis = new boolean[n];

		for (int i = 2, p = 0; i < n; i++) {
			if (!vis[i]) {
				ps[p++] = i;
				for (int j = i + i; j < n; j += i)
					vis[j] = true;
			}
		}
		return ps;
	}

	void solve() {
		int n = in.nextInt();
		int k = in.nextInt();
		if (n / 2 > k) {
			out.println(-1);
			return ;
		}
		if (k == 0) {
			if (n == 1) out.println(1);
			else out.println(-1);
			return ;
		}
		if (n == 1) {
			out.println(-1);
			return ;
		}
		int[] ps = getPrime(1000000);
		int[] qs = new int[n];
		qs[0] = 4;
		for (int i = 1; i < n; i++) {
			int crt = qs[i - 1] + 2;
			while (crt % ps[i] == 0) crt += 2;
			qs[i] = crt;
		}
		k = (k - n / 2 + 1);
		out.print(k + " " + (k * 2) + " ");
		for (int i = 1; i < n / 2; i++) {
			if (ps[i] == k || ps[i] == k * 2 || qs[i] == k || qs[i] == k * 2) {
				n += 2;
				continue;
			}
			out.print(ps[i] + " " + qs[i] + " ");
		}
		if (n % 2 == 1) out.print(707456753);
		out.println();
	}
	void solveB() {
		long n = in.nextLong();
		long a = in.nextLong();
		long b = in.nextLong();
		for (int i = 0; i < n; i++) {
			long k = in.nextLong();
			out.print((k * a % b + b) % b + " ");
		}
		out.println();
	}

	void solveD() {
		int n = in.nextInt(), k = in.nextInt();
		int[][] dp = new int[k + 1][n + 1];
		fill(dp[1], 1);
		dp[1][0] = 0;
		for (int i = 2; i <= k; i++) {
			for (int j = 1; j <= n; j++) {
				for (int u = j; u <= n; u++) {
					if (u % j == 0) dp[i][j] = (dp[i][j] + dp[i - 1][u]) % M;
				}
			}
		}
		int ans = 0;
		for (int i : dp[k]) ans = (ans + i) % M;
		out.println(ans);
	}
	void debug(Object... os) {
		System.err.println(deepToString(os));
	}

	public static void main(String[] args) {
		if (LOCAL) {
			try {
				System.setIn(new FileInputStream("./../in"));
			} catch (IOException e) {
				LOCAL = false;
			}
		}
		long start = System.nanoTime();
		new Main().run();
		if (LOCAL)
			System.err.printf("[Time %.6fs]%n",
					(System.nanoTime() - start) * 1e-9);
	}
}

class Scanner {
	BufferedReader br;
	StringTokenizer st;

	Scanner(InputStream in) {
		br = new BufferedReader(new InputStreamReader(in));
		eat("");
	}

	private void eat(String string) {
		st = new StringTokenizer(string);
	}

	String nextLine() {
		try {
			return br.readLine();
		} catch (IOException e) {
			return null;
		}
	}

	boolean hasNext() {
		while (!st.hasMoreTokens()) {
			String s = nextLine();
			if (s == null)
				return false;
			eat(s);
		}
		return true;
	}

	String next() {
		hasNext();
		return st.nextToken();
	}

	int nextInt() {
		return Integer.parseInt(next());
	}

	long nextLong() {
		return Long.parseLong(next());
	}

	double nextDouble() {
		return Double.parseDouble(next());
	}
}


import java.io.BufferedReader;
import java.io.IOException;
import java.io.InputStreamReader;
import java.util.StringTokenizer;

public class Meme {
    static class FastReader {
        BufferedReader br;
        StringTokenizer st;

        public FastReader() {
            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;
        }
    }

    public static void main(String[] args) {
        FastReader s = new FastReader();
        int t = s.nextInt();
        while (t > 0) {
            long a = s.nextLong();
            long b = s.nextLong();
            long count = 0;
            for (long j = 9; j <= b; j = (j * 10) + 9) {
                count = count + a;
            }
            System.out.println(count);
            t--;
        }
    }
}


import java.io.BufferedReader;
import java.io.IOException;
import java.io.InputStreamReader;
import java.util.StringTokenizer;

public class Meme {
    static class FastReader {
        BufferedReader br;
        StringTokenizer st;

        public FastReader() {
            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;
        }
    }

    public static void main(String[] args) {
        FastReader s = new FastReader();
        int t = s.nextInt();
        while(t>0){
            long a = s.nextLong();
            long b = s.nextLong();
            long count=0;
            long k=a;
            long pow=0;
                while(k>10){
                    k=k/10;
                    pow++;
                }
                for(long j=9;j<=b;j=(j*10)+9){
                        count=count+a;
                }
            System.out.println(count);
        }
    }
}


import java.io.BufferedReader;
import java.io.IOException;
import java.io.InputStreamReader;
import java.util.StringTokenizer;

public class Meme {
    static class FastReader {
        BufferedReader br;
        StringTokenizer st;

        public FastReader() {
            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;
        }
    }

    public static void main(String[] args) {
        FastReader s = new FastReader();
        int t = s.nextInt();
        while(t>0){
            long a = s.nextLong();
            long b = s.nextLong();
            long count=0;
            long k=a;
            long pow=0;
                while(k>10){
                    k=k/10;
                    pow++;
                }
                for(long j=9;j<=b;j=(j*10)+9){
                        count=count+a;
                }
            System.out.println(count);
        }
        t--;
    }
}


import java.io.*;
import java.util.*;
import java.math.*;
import java.lang.*;

 //@Manan Parmar

public class Solution2 implements Runnable {

    public void run() {

        InputReader sc = new InputReader(System.in);
        PrintWriter out = new PrintWriter(System.out);

        int t=sc.nextInt();
        while(t--!=0)
        {
            int a=sc.nextInt(),b=sc.nextInt();
            if(a<9&&b<9)
                out.println("0");
            else
            {
                int x=Math.max(a,b),y=0,sum=0;
                String s1=String.valueOf(x);
                for(int i=0;i<s1.length();i++)
                    if(s1.charAt(i)=='9')
                        sum++;
                if(sum!=s1.length())
                    y=s1.length()-1;
                else
                    y=s1.length();
                out.println(Math.min(a,b)*y);
            }
        }
        out.close();
    }

//========================================================================
    long binarySearch(long arr[], long x)
    {
        int l = 0, r = arr.length - 1,q=0;
        while (l<=r) {
            int m = l + (r - l) / 2;
            if (arr[l] >=x)
            {
                q=1;
                return l;
            }
            if (arr[m] < x)
                l=m+1;
            else
                r=m;
        }
        return -1;
    }

    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 Solution2(),"Main",1<<27).start();
    }
}


import java.io.*;
import java.util.*;
import java.math.*;
import java.lang.*;

 //@Manan Parmar

public class Solution2 implements Runnable {

    public void run() {

        InputReader sc = new InputReader(System.in);
        PrintWriter out = new PrintWriter(System.out);

        int t=sc.nextInt();
        while(t--!=0)
        {
            int a=sc.nextInt(),b=sc.nextInt();
            if(a<1&&b<9)
                out.println("0");
            else
            {
                int x=b,y=0,sum=0;
                String s1=String.valueOf(x);
                for(int i=0;i<s1.length();i++)
                    if(s1.charAt(i)=='9')
                        sum++;
                if(sum!=s1.length())
                    y=s1.length()-1;
                else
                    y=s1.length();
                out.println(a*y);
            }
        }
        out.close();
    }

//========================================================================
    long binarySearch(long arr[], long x)
    {
        int l = 0, r = arr.length - 1,q=0;
        while (l<=r) {
            int m = l + (r - l) / 2;
            if (arr[l] >=x)
            {
                q=1;
                return l;
            }
            if (arr[m] < x)
                l=m+1;
            else
                r=m;
        }
        return -1;
    }

    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 Solution2(),"Main",1<<27).start();
    }
}


import java.io.*;
import java.util.*;
import java.math.*;
import java.lang.*;

 //@Manan Parmar

public class Solution2 implements Runnable {

    public void run() {

        InputReader sc = new InputReader(System.in);
        PrintWriter out = new PrintWriter(System.out);

        int t=sc.nextInt();
        while(t--!=0)
        {
            int a=sc.nextInt(),b=sc.nextInt();
            if(a<9&&b<9)
                out.println("0");
            else
            {
                int x=Math.max(a,b),y=0;
                String s1=String.valueOf(x);
                char s=String.valueOf(x).charAt(0);
                if(s!='9')
                    y=s1.length()-1;
                else
                    y=s1.length();
                out.println(Math.min(a,b)*y);
            }
        }
        out.close();
    }

//========================================================================
    long binarySearch(long arr[], long x)
    {
        int l = 0, r = arr.length - 1,q=0;
        while (l<=r) {
            int m = l + (r - l) / 2;
            if (arr[l] >=x)
            {
                q=1;
                return l;
            }
            if (arr[m] < x)
                l=m+1;
            else
                r=m;
        }
        return -1;
    }

    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 Solution2(),"Main",1<<27).start();
    }
}


import java.io.*;
import java.util.*;
import java.math.*;
import java.lang.*;

 //@Manan Parmar

public class Solution2 implements Runnable {

    public void run() {

        InputReader sc = new InputReader(System.in);
        PrintWriter out = new PrintWriter(System.out);

        int t=sc.nextInt();
        while(t--!=0)
        {
            int a=sc.nextInt(),b=sc.nextInt();
            if(a<1&&b<9)
                out.println("0");
            else
            {
                long x=b,y=0,sum=0;
                String s1=String.valueOf(x);
                for(int i=0;i<s1.length();i++)
                    if(s1.charAt(i)=='9')
                        sum++;
                if(sum!=s1.length())
                    y=s1.length()-1;
                else
                    y=s1.length();
                out.println(a*y);
            }
        }
        out.close();
    }

//========================================================================
    long binarySearch(long arr[], long x)
    {
        int l = 0, r = arr.length - 1,q=0;
        while (l<=r) {
            int m = l + (r - l) / 2;
            if (arr[l] >=x)
            {
                q=1;
                return l;
            }
            if (arr[m] < x)
                l=m+1;
            else
                r=m;
        }
        return -1;
    }

    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 Solution2(),"Main",1<<27).start();
    }
}


import java.io.*;
import java.util.ArrayList;
import java.util.Arrays;
import java.util.List;
public class Solution{
	static boolean BS(int n,int d)
	{
		int l=0,h=n;
		while(l<h)
		{
			int m=(l+h)/2;
			int v=m+(d/(m+1));
			if(d%(m+1)!=0)
			{
				v++;
			}
			if(v>n)
			{
				l=m+1;
			}else
				h=m;
		}
		int a=h+d/(h+1);
		if(d%(h+1)!=0)
		{
			a++;
		}
	//	System.out.println(l+" "+h+" "+a);
		if(a<=n)
		{
			return true;
		}else
			return false;
	}

	public static void main(String...args) throws Exception {
		OutputStream outputStream =System.out;
		PrintWriter out =new PrintWriter(outputStream);
		Reader s=new Reader();
		int T = s.nextInt();
		while(T-->0)
		{
			int a=s.nextInt();
			int b=s.nextInt();
			int n=(int)Math.floor(Math.log10(b) + 1);
			if(n>0)
			{
				n--;
			}
			int ans=a*n;
			out.println(ans);
		}
		out.close();
	}
}

class Reader
{
	final private int BUFFER_SIZE = 1 << 16;
	private DataInputStream din;
	private byte[] buffer;
	private int bufferPointer, bytesRead;

	public Reader()
	{
		din = new DataInputStream(System.in);
		buffer = new byte[BUFFER_SIZE];
		bufferPointer = bytesRead = 0;
	}

	public Reader(String file_name) throws IOException
	{
		din = new DataInputStream(new FileInputStream(file_name));
		buffer = new byte[BUFFER_SIZE];
		bufferPointer = bytesRead = 0;
	}

	public String readLine() throws IOException
	{
		byte[] buf = new byte[64]; // line length
		int cnt = 0, c;
		while ((c = read()) != -1)
		{
			if (c == '\n')
				break;
			buf[cnt++] = (byte) c;
		}
		return new String(buf, 0, cnt);
	}

	public int nextInt() throws IOException
	{
		int ret = 0;
		byte c = read();
		while (c <= ' ')
			c = read();
		boolean neg = (c == '-');
		if (neg)
			c = read();
		do
		{
			ret = ret * 10 + c - '0';
		}  while ((c = read()) >= '0' && c <= '9');

		if (neg)
			return -ret;
		return ret;
	}

	public long nextLong() throws IOException
	{
		long ret = 0;
		byte c = read();
		while (c <= ' ')
			c = read();
		boolean neg = (c == '-');
		if (neg)
			c = read();
		do {
			ret = ret * 10 + c - '0';
		}
		while ((c = read()) >= '0' && c <= '9');
		if (neg)
			return -ret;
		return ret;
	}

	public double nextDouble() throws IOException
	{
		double ret = 0, div = 1;
		byte c = read();
		while (c <= ' ')
			c = read();
		boolean neg = (c == '-');
		if (neg)
			c = read();

		do {
			ret = ret * 10 + c - '0';
		}
		while ((c = read()) >= '0' && c <= '9');

		if (c == '.')
		{
			while ((c = read()) >= '0' && c <= '9')
			{
				ret += (c - '0') / (div *= 10);
			}
		}

		if (neg)
			return -ret;
		return ret;
	}

	private void fillBuffer() throws IOException
	{
		bytesRead = din.read(buffer, bufferPointer = 0, BUFFER_SIZE);
		if (bytesRead == -1)
			buffer[0] = -1;
	}

	private byte read() throws IOException
	{
		if (bufferPointer == bytesRead)
			fillBuffer();
		return buffer[bufferPointer++];
	}

	public void close() throws IOException
	{
		if (din == null)
			return;
		din.close();
	}
}


import java.io.*;
import java.util.ArrayList;
import java.util.Arrays;
import java.util.List;
public class Solution{
	static boolean BS(int n,int d)
	{
		int l=0,h=n;
		while(l<h)
		{
			int m=(l+h)/2;
			int v=m+(d/(m+1));
			if(d%(m+1)!=0)
			{
				v++;
			}
			if(v>n)
			{
				l=m+1;
			}else
				h=m;
		}
		int a=h+d/(h+1);
		if(d%(h+1)!=0)
		{
			a++;
		}
	//	System.out.println(l+" "+h+" "+a);
		if(a<=n)
		{
			return true;
		}else
			return false;
	}

	public static void main(String...args) throws Exception {
		OutputStream outputStream =System.out;
		PrintWriter out =new PrintWriter(outputStream);
		Reader s=new Reader();
		int T = s.nextInt();
		while(T-->0)
		{
			int a=s.nextInt();
			int b=s.nextInt();
			int n=(int)Math.ceil(Math.log10(b));
			if(n>0)
			{
				n--;
			}
			int ans=a*n;
			out.println(ans);
		}
		out.close();
	}
}

class Reader
{
	final private int BUFFER_SIZE = 1 << 16;
	private DataInputStream din;
	private byte[] buffer;
	private int bufferPointer, bytesRead;

	public Reader()
	{
		din = new DataInputStream(System.in);
		buffer = new byte[BUFFER_SIZE];
		bufferPointer = bytesRead = 0;
	}

	public Reader(String file_name) throws IOException
	{
		din = new DataInputStream(new FileInputStream(file_name));
		buffer = new byte[BUFFER_SIZE];
		bufferPointer = bytesRead = 0;
	}

	public String readLine() throws IOException
	{
		byte[] buf = new byte[64]; // line length
		int cnt = 0, c;
		while ((c = read()) != -1)
		{
			if (c == '\n')
				break;
			buf[cnt++] = (byte) c;
		}
		return new String(buf, 0, cnt);
	}

	public int nextInt() throws IOException
	{
		int ret = 0;
		byte c = read();
		while (c <= ' ')
			c = read();
		boolean neg = (c == '-');
		if (neg)
			c = read();
		do
		{
			ret = ret * 10 + c - '0';
		}  while ((c = read()) >= '0' && c <= '9');

		if (neg)
			return -ret;
		return ret;
	}

	public long nextLong() throws IOException
	{
		long ret = 0;
		byte c = read();
		while (c <= ' ')
			c = read();
		boolean neg = (c == '-');
		if (neg)
			c = read();
		do {
			ret = ret * 10 + c - '0';
		}
		while ((c = read()) >= '0' && c <= '9');
		if (neg)
			return -ret;
		return ret;
	}

	public double nextDouble() throws IOException
	{
		double ret = 0, div = 1;
		byte c = read();
		while (c <= ' ')
			c = read();
		boolean neg = (c == '-');
		if (neg)
			c = read();

		do {
			ret = ret * 10 + c - '0';
		}
		while ((c = read()) >= '0' && c <= '9');

		if (c == '.')
		{
			while ((c = read()) >= '0' && c <= '9')
			{
				ret += (c - '0') / (div *= 10);
			}
		}

		if (neg)
			return -ret;
		return ret;
	}

	private void fillBuffer() throws IOException
	{
		bytesRead = din.read(buffer, bufferPointer = 0, BUFFER_SIZE);
		if (bytesRead == -1)
			buffer[0] = -1;
	}

	private byte read() throws IOException
	{
		if (bufferPointer == bytesRead)
			fillBuffer();
		return buffer[bufferPointer++];
	}

	public void close() throws IOException
	{
		if (din == null)
			return;
		din.close();
	}
}


import java.io.*;
import java.util.ArrayList;
import java.util.Arrays;
import java.util.List;
public class Solution{
	static boolean BS(int n,int d)
	{
		int l=0,h=n;
		while(l<h)
		{
			int m=(l+h)/2;
			int v=m+(d/(m+1));
			if(d%(m+1)!=0)
			{
				v++;
			}
			if(v>n)
			{
				l=m+1;
			}else
				h=m;
		}
		int a=h+d/(h+1);
		if(d%(h+1)!=0)
		{
			a++;
		}
	//	System.out.println(l+" "+h+" "+a);
		if(a<=n)
		{
			return true;
		}else
			return false;
	}

	public static void main(String...args) throws Exception {
		OutputStream outputStream =System.out;
		PrintWriter out =new PrintWriter(outputStream);
		Reader s=new Reader();
		int T = s.nextInt();
		while(T-->0)
		{
			long a=s.nextLong();
			long b=s.nextLong();
			long c=0,c9=0;
			while(b>0)
			{
				if(b%10==9)
				{
					c9++;
				}
				b/=10;
				c++;
			}
			long ans=0;
			if(c==c9)
			{
				ans=c*a;
			}else
				ans=(c-1)*a;
			out.println(ans);
		}
		out.close();
	}
}

class Reader
{
	final private int BUFFER_SIZE = 1 << 16;
	private DataInputStream din;
	private byte[] buffer;
	private int bufferPointer, bytesRead;

	public Reader()
	{
		din = new DataInputStream(System.in);
		buffer = new byte[BUFFER_SIZE];
		bufferPointer = bytesRead = 0;
	}

	public Reader(String file_name) throws IOException
	{
		din = new DataInputStream(new FileInputStream(file_name));
		buffer = new byte[BUFFER_SIZE];
		bufferPointer = bytesRead = 0;
	}

	public String readLine() throws IOException
	{
		byte[] buf = new byte[64]; // line length
		int cnt = 0, c;
		while ((c = read()) != -1)
		{
			if (c == '\n')
				break;
			buf[cnt++] = (byte) c;
		}
		return new String(buf, 0, cnt);
	}

	public int nextInt() throws IOException
	{
		int ret = 0;
		byte c = read();
		while (c <= ' ')
			c = read();
		boolean neg = (c == '-');
		if (neg)
			c = read();
		do
		{
			ret = ret * 10 + c - '0';
		}  while ((c = read()) >= '0' && c <= '9');

		if (neg)
			return -ret;
		return ret;
	}

	public long nextLong() throws IOException
	{
		long ret = 0;
		byte c = read();
		while (c <= ' ')
			c = read();
		boolean neg = (c == '-');
		if (neg)
			c = read();
		do {
			ret = ret * 10 + c - '0';
		}
		while ((c = read()) >= '0' && c <= '9');
		if (neg)
			return -ret;
		return ret;
	}

	public double nextDouble() throws IOException
	{
		double ret = 0, div = 1;
		byte c = read();
		while (c <= ' ')
			c = read();
		boolean neg = (c == '-');
		if (neg)
			c = read();

		do {
			ret = ret * 10 + c - '0';
		}
		while ((c = read()) >= '0' && c <= '9');

		if (c == '.')
		{
			while ((c = read()) >= '0' && c <= '9')
			{
				ret += (c - '0') / (div *= 10);
			}
		}

		if (neg)
			return -ret;
		return ret;
	}

	private void fillBuffer() throws IOException
	{
		bytesRead = din.read(buffer, bufferPointer = 0, BUFFER_SIZE);
		if (bytesRead == -1)
			buffer[0] = -1;
	}

	private byte read() throws IOException
	{
		if (bufferPointer == bytesRead)
			fillBuffer();
		return buffer[bufferPointer++];
	}

	public void close() throws IOException
	{
		if (din == null)
			return;
		din.close();
	}
}


import java.io.*;
import java.util.ArrayList;
import java.util.Arrays;
import java.util.List;
public class Solution{
	static boolean BS(int n,int d)
	{
		int l=0,h=n;
		while(l<h)
		{
			int m=(l+h)/2;
			int v=m+(d/(m+1));
			if(d%(m+1)!=0)
			{
				v++;
			}
			if(v>n)
			{
				l=m+1;
			}else
				h=m;
		}
		int a=h+d/(h+1);
		if(d%(h+1)!=0)
		{
			a++;
		}
	//	System.out.println(l+" "+h+" "+a);
		if(a<=n)
		{
			return true;
		}else
			return false;
	}

	public static void main(String...args) throws Exception {
		OutputStream outputStream =System.out;
		PrintWriter out =new PrintWriter(outputStream);
		Reader s=new Reader();
		int T = s.nextInt();
		while(T-->0)
		{
			int a=s.nextInt();
			int b=s.nextInt();
			int n=(int)Math.ceil(Math.log10(b));
			int ans=a*(n-1);
			out.println(ans);
		}
		out.close();
	}
}

class Reader
{
	final private int BUFFER_SIZE = 1 << 16;
	private DataInputStream din;
	private byte[] buffer;
	private int bufferPointer, bytesRead;

	public Reader()
	{
		din = new DataInputStream(System.in);
		buffer = new byte[BUFFER_SIZE];
		bufferPointer = bytesRead = 0;
	}

	public Reader(String file_name) throws IOException
	{
		din = new DataInputStream(new FileInputStream(file_name));
		buffer = new byte[BUFFER_SIZE];
		bufferPointer = bytesRead = 0;
	}

	public String readLine() throws IOException
	{
		byte[] buf = new byte[64]; // line length
		int cnt = 0, c;
		while ((c = read()) != -1)
		{
			if (c == '\n')
				break;
			buf[cnt++] = (byte) c;
		}
		return new String(buf, 0, cnt);
	}

	public int nextInt() throws IOException
	{
		int ret = 0;
		byte c = read();
		while (c <= ' ')
			c = read();
		boolean neg = (c == '-');
		if (neg)
			c = read();
		do
		{
			ret = ret * 10 + c - '0';
		}  while ((c = read()) >= '0' && c <= '9');

		if (neg)
			return -ret;
		return ret;
	}

	public long nextLong() throws IOException
	{
		long ret = 0;
		byte c = read();
		while (c <= ' ')
			c = read();
		boolean neg = (c == '-');
		if (neg)
			c = read();
		do {
			ret = ret * 10 + c - '0';
		}
		while ((c = read()) >= '0' && c <= '9');
		if (neg)
			return -ret;
		return ret;
	}

	public double nextDouble() throws IOException
	{
		double ret = 0, div = 1;
		byte c = read();
		while (c <= ' ')
			c = read();
		boolean neg = (c == '-');
		if (neg)
			c = read();

		do {
			ret = ret * 10 + c - '0';
		}
		while ((c = read()) >= '0' && c <= '9');

		if (c == '.')
		{
			while ((c = read()) >= '0' && c <= '9')
			{
				ret += (c - '0') / (div *= 10);
			}
		}

		if (neg)
			return -ret;
		return ret;
	}

	private void fillBuffer() throws IOException
	{
		bytesRead = din.read(buffer, bufferPointer = 0, BUFFER_SIZE);
		if (bytesRead == -1)
			buffer[0] = -1;
	}

	private byte read() throws IOException
	{
		if (bufferPointer == bytesRead)
			fillBuffer();
		return buffer[bufferPointer++];
	}

	public void close() throws IOException
	{
		if (din == null)
			return;
		din.close();
	}
}


import java.io.BufferedReader;
import java.io.FileReader;
import java.io.IOException;
import java.io.InputStream;
import java.io.InputStreamReader;
import java.util.Arrays;
import java.util.HashMap;
import java.util.Set;
import java.util.StringTokenizer;
import java.util.TreeSet;

public class Mains1Util {

    static class Scanner
    {
        StringTokenizer st;
        BufferedReader br;

        public Scanner(final InputStream s){    br = new BufferedReader(new InputStreamReader(s));}

        public Scanner(final FileReader r){    br = new BufferedReader(r);}

        public String next() throws IOException
        {
            while (st == null || !st.hasMoreTokens())
                st = new StringTokenizer(br.readLine());
            return st.nextToken();
        }

        public int nextInt() throws IOException {return Integer.parseInt(next());}

        public long nextLong() throws IOException {return Long.parseLong(next());}

        public String nextLine() throws IOException {return br.readLine();}

        public double nextDouble() throws IOException
        {
            final String x = next();
            StringBuilder sb = new StringBuilder("0");
            double res = 0, f = 1;
            boolean dec = false, neg = false;
            int start = 0;
            if(x.charAt(0) == '-')
            {
                neg = true;
                start++;
            }
            for(int i = start; i < x.length(); i++)
                if(x.charAt(i) == '.')
                {
                    res = Long.parseLong(sb.toString());
                    sb = new StringBuilder("0");
                    dec = true;
                }
                else
                {
                    sb.append(x.charAt(i));
                    if(dec)
                        f *= 10;
                }
            res += Long.parseLong(sb.toString()) / f;
            return res * (neg?-1:1);
        }

        public boolean ready() throws IOException {return br.ready();}

    }

    public static void main(final String[] args) throws IOException {

//        final TreeSet<Double> set = new TreeSet<>();
//        for(double i=1;i<=Integer.MAX_VALUE;i=i*3) {
//            set.add(i);
//        }
        final Scanner s = new Scanner(System.in);
//        function3(s);
        final int n = s.nextInt();
        for (int i = 0; i < n; i++) {
            function2temp(s);
        }
    }

    private static void function(final Scanner s) throws IOException {
        final long n = s.nextLong();
        final long d = s.nextLong();
        if(d<=n) {
            System.out.println("YES");
            return;
        }
        if(Math.pow(n-1, 2) >= (4*(d-n))) {
            System.out.println("YES");
            return;
        }

        System.out.println("NO");

    }

    private static void function2(final Scanner s) throws IOException {
        final long a = s.nextLong();
        final long b = s.nextLong();
        long count =0;
        for(long i=1;i<=a;i++) {
            for(long j=1;j<=b;j++) {
                final long temp1 = (i+1)*j + i;
//                final int x = Long.toString(j).length();
//                final int x = (int)Math.floor(Math.log10(j)+1);
//                final int y = Long.toString(j).length();
//                final int y = (int)Math.floor(Math.log10(i)+1);
                final long temp = i + j + (i*j);
                if(temp == Long.parseLong(i + Long.toString(j)))  {
                    System.out.print( temp + " ");
                    count++;
                }
            }
        }

        System.out.println(count);

    }

    private static void function2temp(final Scanner s) throws IOException {
        final long a = s.nextLong();
        final long b = s.nextLong();
        long count = 0;
        long t = 0, temp=0;

        for(int j=1;j<=Long.toString(b).length();j++) {
            if(temp==0) {
                temp=9;

            } else {
                temp = Long.parseLong(Long.toString(temp) + 9);

            }

            if(temp<=b) {
                t++;
            } else {
                break;
            }
        }

        count = t*a;

        System.out.println(count);
    }
}