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

import javax.swing.text.html.MinimalHTMLWriter;

public class tr1 {
	static PrintWriter out;
	static StringBuilder sb;
	static int n, m, k, ones, zeros;
	static long mod = 998244353;
	static Boolean[][] memo;
	static String s;
	static ArrayList<Integer>[] ad;
	static long inf = Long.MAX_VALUE;
	static int N = 1 << 20 + 1;
	static int[] color;
	static ArrayList<Integer> o, z;
	static int[] ans, head;

	public static void main(String[] args) throws Exception {
		Scanner sc = new Scanner(System.in);
		out = new PrintWriter(System.out);
		int t = sc.nextInt();
		while (t-- > 0) {
			long x1 = sc.nextInt();
			long y1 = sc.nextInt();
			long x2 = sc.nextInt();
			long y2 = sc.nextInt();
			long st1 = (x1 + 1) * x1 / 2;
			long st2 = (x2 + 1) * x2 / 2;
			long pos1 = ((y1 + x1 - 2) * (y1 + x1 - 1) / 2) - ((x1 - 1) * x1 / 2) + st1;
			long pos2 = ((y2 + x2 - 2) * (y2 + x2 - 1) / 2) - ((x2 - 1) * x2 / 2) + st2;
			long max = pos1 + (x2 + y1 - 1) * (x2 + y1) / 2 - (x1 + y1 - 1) * (x1 + y1) / 2 + (x2 + y2 - 1);
			long min = 0;
			long lev = x2 - x1;
			long leh = y2 - y1;
			long inc = (Math.min(lev, leh)*(Math.min(lev, leh)+1)/2)+Math.min(lev, leh)*(Math.max(lev, leh)-1);
			if (x1 == x2 || y2 == y1) {
				out.println(1);
				continue;
			}
			System.out.println(inc + 1);
		}
		out.flush();
	}

	static class Scanner {
		StringTokenizer st;
		BufferedReader br;

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

		public Scanner(String file) throws Exception {
			br = new BufferedReader(new FileReader(file));
		}

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

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

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

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

		public char nextChar() throws IOException {
			return next().charAt(0);
		}

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

		public int[] nextArrInt(int n) throws IOException {
			int[] a = new int[n];
			for (int i = 0; i < n; i++)
				a[i] = nextInt();
			return a;
		}

		public long[] nextArrLong(int n) throws IOException {
			long[] a = new long[n];
			for (int i = 0; i < n; i++)
				a[i] = nextLong();
			return a;
		}

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

		public void waitForInput() throws InterruptedException {
			Thread.sleep(3000);
		}
	}
}


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

import javax.swing.text.html.MinimalHTMLWriter;

public class tr1 {
	static PrintWriter out;
	static StringBuilder sb;
	static int n, m, k, ones, zeros;
	static long mod = 998244353;
	static Boolean[][] memo;
	static String s;
	static ArrayList<Integer>[] ad;
	static long inf = Long.MAX_VALUE;
	static int N = 1 << 20 + 1;
	static int[] color;
	static ArrayList<Integer> o, z;
	static int[] ans, head;

	public static void main(String[] args) throws Exception {
		Scanner sc = new Scanner(System.in);
		out = new PrintWriter(System.out);
		int t = sc.nextInt();
		while (t-- > 0) {
			long x1 = sc.nextInt();
			long y1 = sc.nextInt();
			long x2 = sc.nextInt();
			long y2 = sc.nextInt();
			long st1 = (x1 + 1) * x1 / 2;
			long st2 = (x2 + 1) * x2 / 2;
//			long pos1 = ((y1 + x1 - 2) * (y1 + x1 - 1) / 2) - ((x1 - 1) * x1 / 2) + st1;
//			long pos2 = ((y2 + x2 - 2) * (y2 + x2 - 1) / 2) - ((x2 - 1) * x2 / 2) + st2;
//			long max = pos1 + (x2 + y1 - 1) * (x2 + y1) / 2 - (x1 + y1 - 1) * (x1 + y1) / 2 + (x2 + y2 - 1);
//			long min = 0;
			long lev = x2 - x1;
			long leh = y2 - y1;
			long inc = (Math.min(lev, leh) * (Math.min(lev, leh) + 1) / 2)
					+ Math.min(lev, leh) * (Math.max(lev, leh) - 1);
			if (x1 == x2 || y2 == y1) {
				out.println(1);
				continue;
			}
			out.println(inc + 1);
		}
		out.flush();
	}

	static class Scanner {
		StringTokenizer st;
		BufferedReader br;

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

		public Scanner(String file) throws Exception {
			br = new BufferedReader(new FileReader(file));
		}

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

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

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

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

		public char nextChar() throws IOException {
			return next().charAt(0);
		}

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

		public int[] nextArrInt(int n) throws IOException {
			int[] a = new int[n];
			for (int i = 0; i < n; i++)
				a[i] = nextInt();
			return a;
		}

		public long[] nextArrLong(int n) throws IOException {
			long[] a = new long[n];
			for (int i = 0; i < n; i++)
				a[i] = nextLong();
			return a;
		}

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

		public void waitForInput() throws InterruptedException {
			Thread.sleep(3000);
		}
	}
}


import java.util.Arrays;
import java.util.Scanner;

/**
 * @创建人 YDL
 * @创建时间 2020/5/9 22:34
 * @描述
 */
public class Main {
    public static void main(String[] args) {
        Scanner sc = new Scanner(System.in);
        int n = sc.nextInt();
        for(int i=0;i<n;i++){
            int x0 = sc.nextInt();
            int y0 = sc.nextInt();
            int x1 = sc.nextInt();
            int y1 = sc.nextInt();
            long ans = (long)(x1-x0)*(y1-y0)+1;
            System.out.println(ans);
        }
    }
}


import java.util.Arrays;
import java.util.Scanner;

/**
 * @创建人 YDL
 * @创建时间 2020/5/9 22:34
 * @描述
 */
public class Main {
    public static void main(String[] args) {
        Scanner sc = new Scanner(System.in);
        int n = sc.nextInt();
        for(int i=0;i<n;i++){
            int x0 = sc.nextInt();
            int y0 = sc.nextInt();
            int x1 = sc.nextInt();
            int y1 = sc.nextInt();
            x1 -= x0-1;
            y1 -= y0-1;
            x0=0;
            y0=0;
            int[] dp = new int[y1];
            Arrays.fill(dp,1);

            for(int x=1;x<x1;x++){
                for(int y=1;y<y1;y++){
                   dp[y] += dp[y-1];
                }
            }
            System.out.println(dp[y1-1]);
        }
    }
}


import java.util.Arrays;
import java.util.Scanner;

/**
 * @创建人 YDL
 * @创建时间 2020/5/9 22:34
 * @描述
 */
public class Main {
    public static void main(String[] args) {
        Scanner sc = new Scanner(System.in);
        int n = sc.nextInt();
        for(int i=0;i<n;i++){
            int x0 = sc.nextInt();
            int y0 = sc.nextInt();
            int x1 = sc.nextInt();
            int y1 = sc.nextInt();
            long ans = (x1-x0)*(y1-y0)+1;
            System.out.println(ans);
        }
    }
}


import java.util.Arrays;
import java.util.Scanner;

/**
 * @创建人 YDL
 * @创建时间 2020/5/9 22:34
 * @描述
 */
public class Main {
    public static void main(String[] args) {
        Scanner sc = new Scanner(System.in);
        int n = sc.nextInt();
        for(int i=0;i<n;i++){
            int x0 = sc.nextInt();
            int y0 = sc.nextInt();
            int x1 = sc.nextInt();
            int y1 = sc.nextInt();
            int ans = (x1-x0)*(y1-y0)+1;
            System.out.println(ans);
        }
    }
}


import java.io.BufferedReader;
import java.io.BufferedWriter;
import java.io.IOException;
import java.io.InputStreamReader;
import java.io.OutputStreamWriter;
import java.util.Arrays;
import java.util.HashSet;
import java.util.Scanner;
import java.util.Set;
import java.util.StringTokenizer;
import java.util.TreeSet;
import javafx.scene.shape.TriangleMesh;

/**
 *
 * @author USER
 */
public class Cf {
    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;
        }
    }

    static class BufPrint
    {
        final BufferedWriter bw;
        public BufPrint()
        {
            this.bw=new BufferedWriter(new OutputStreamWriter(System.out));
        }
        public void print(Object object)throws IOException
        {
            bw.append(""+object);
        }
        public void println(Object object)throws IOException
        {
            print(object);
            bw.append("\n");
        }
        public void close()throws IOException
        {
            bw.close();
        }
    }

        public static int GCD(int l,int r) {
        int gcd=1;
        for(int i = 1; i <= l && i <= r; ++i)
        {
            // Checks if i is factor of both integers
            if(l % i==0 && r % i==0)
                gcd = i;
        }
    return gcd;
}

    /**
     * @param args the command line arguments
     */
    public static void main(String[] args) throws IOException{
        // TODO code application logic here

            FastReader sc=new FastReader();
            BufPrint bp=new BufPrint();

               int t=sc.nextInt();

               for(int k=0;k<t;k++)
               {

                   int n=sc.nextInt();
                   int m=sc.nextInt();
                   int x=sc.nextInt();
                   int y=sc.nextInt();

                   int row=x-n;
                   int col=y-m;

                   if((row==0 || col==0))
                   {
                       bp.println(1);
                   }
                   else if(row==1 && col==1){
                       bp.println(2);
                   }
                   else
                   {
                       bp.println((row*col)+1);
                   }
               }

                bp.close();

    }
}


import java.io.BufferedReader;
import java.io.BufferedWriter;
import java.io.IOException;
import java.io.InputStreamReader;
import java.io.OutputStreamWriter;
import java.util.Arrays;
import java.util.HashSet;
import java.util.Scanner;
import java.util.Set;
import java.util.StringTokenizer;
import java.util.TreeSet;
import javafx.scene.shape.TriangleMesh;

/**
 *
 * @author USER
 */
public class Cf {
    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;
        }
    }

    static class BufPrint
    {
        final BufferedWriter bw;
        public BufPrint()
        {
            this.bw=new BufferedWriter(new OutputStreamWriter(System.out));
        }
        public void print(Object object)throws IOException
        {
            bw.append(""+object);
        }
        public void println(Object object)throws IOException
        {
            print(object);
            bw.append("\n");
        }
        public void close()throws IOException
        {
            bw.close();
        }
    }

        public static int GCD(int l,int r) {
        int gcd=1;
        for(int i = 1; i <= l && i <= r; ++i)
        {
            // Checks if i is factor of both integers
            if(l % i==0 && r % i==0)
                gcd = i;
        }
    return gcd;
}

    /**
     * @param args the command line arguments
     */
    public static void main(String[] args) throws IOException{
        // TODO code application logic here

            FastReader sc=new FastReader();
            BufPrint bp=new BufPrint();

               int t=sc.nextInt();

               for(int k=0;k<t;k++)
               {

                   int n=sc.nextInt();
                   int m=sc.nextInt();
                   int x=sc.nextInt();
                   int y=sc.nextInt();

                   int row=n-x;
                   int col=m-y;

                   if((row==0 || col==0))
                   {
                       bp.println(1);
                   }
                   else if(row==1 && col==1){
                       bp.println(2);
                   }
                   else
                   {
                       if(row==1 || col==1)
                       {
                           long ans=row*col;
                           bp.println(ans-1);
                       }
                       else
                       {
                           long ans=row*col;
                           bp.println(ans-col);
                       }
                   }
               }

                bp.close();

    }
}


import java.io.BufferedReader;
import java.io.BufferedWriter;
import java.io.IOException;
import java.io.InputStreamReader;
import java.io.OutputStreamWriter;
import java.util.Arrays;
import java.util.HashSet;
import java.util.Scanner;
import java.util.Set;
import java.util.StringTokenizer;
import java.util.TreeSet;
import javafx.scene.shape.TriangleMesh;

/**
 *
 * @author USER
 */
public class Cf {
    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;
        }
    }

    static class BufPrint
    {
        final BufferedWriter bw;
        public BufPrint()
        {
            this.bw=new BufferedWriter(new OutputStreamWriter(System.out));
        }
        public void print(Object object)throws IOException
        {
            bw.append(""+object);
        }
        public void println(Object object)throws IOException
        {
            print(object);
            bw.append("\n");
        }
        public void close()throws IOException
        {
            bw.close();
        }
    }

        public static int GCD(int l,int r) {
        int gcd=1;
        for(int i = 1; i <= l && i <= r; ++i)
        {
            // Checks if i is factor of both integers
            if(l % i==0 && r % i==0)
                gcd = i;
        }
    return gcd;
}

    /**
     * @param args the command line arguments
     */
    public static void main(String[] args) throws IOException{
        // TODO code application logic here

            FastReader sc=new FastReader();
            BufPrint bp=new BufPrint();

               int t=sc.nextInt();

               for(int k=0;k<t;k++)
               {

                   int n=sc.nextInt();
                   int m=sc.nextInt();
                   int x=sc.nextInt();
                   int y=sc.nextInt();

                   int row=x-n;
                   int col=y-m;

                   if((row==0 || col==0))
                   {
                       bp.println(1);
                   }
                   else if(row==1 && col==1){
                       bp.println(2);
                   }
                   else
                   {
                       long ans=((long)row*(long)col);
                       bp.println(ans+1);
                   }
               }

                bp.close();

    }
}


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

/**
 * Built using CHelper plug-in
 * Actual solution is at the top
 */
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();
    }

    static class TaskC {
        public void solve(int testNumber, InputReader in, OutputWriter out) {
            testNumber = in.nextInt();
            while (testNumber-- > 0) {
                long x1 = in.nextLong(), y1 = in.nextLong(), x2 = in.nextLong(), y2 = in.nextLong();
                out.println(((x2 - x1) * (y2 - y1)) + 1);
            }
        }

    }

    static class InputReader {
        private InputStream stream;
        private byte[] buf = new byte[1024];
        private int curChar;
        private int numChars;
        private InputReader.SpaceCharFilter filter;

        public InputReader(InputStream stream) {
            this.stream = stream;
        }

        public int read() {
            if (numChars == -1) {
                throw new InputMismatchException();
            }
            if (curChar >= numChars) {
                curChar = 0;
                try {
                    numChars = stream.read(buf);
                } catch (IOException e) {
                    throw new InputMismatchException();
                }
                if (numChars <= 0) {
                    return -1;
                }
            }
            return buf[curChar++];
        }

        public int 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 boolean isSpaceChar(int c) {
            if (filter != null) {
                return filter.isSpaceChar(c);
            }
            return isWhitespace(c);
        }

        public static boolean isWhitespace(int c) {
            return c == ' ' || c == '\n' || c == '\r' || c == '\t' || c == -1;
        }

        public interface SpaceCharFilter {
            public boolean isSpaceChar(int ch);

        }

    }

    static class OutputWriter {
        private final PrintWriter writer;

        public OutputWriter(OutputStream outputStream) {
            writer = new PrintWriter(new BufferedWriter(new OutputStreamWriter(outputStream)));
        }

        public OutputWriter(Writer writer) {
            this.writer = new PrintWriter(writer);
        }

        public void close() {
            writer.close();
        }

        public void println(long i) {
            writer.println(i);
        }

    }
}


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

/**
 * Built using CHelper plug-in
 * Actual solution is at the top
 */
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();
    }

    static class TaskC {
        public void solve(int testNumber, InputReader in, OutputWriter out) {
            testNumber = in.nextInt();
            while (testNumber-- > 0) {
                int x1 = in.nextInt(), y1 = in.nextInt(), x2 = in.nextInt(), y2 = in.nextInt();
                out.println(((x2 - x1) * (y2 - y1)) + 1);
            }
        }

    }

    static class InputReader {
        private InputStream stream;
        private byte[] buf = new byte[1024];
        private int curChar;
        private int numChars;
        private InputReader.SpaceCharFilter filter;

        public InputReader(InputStream stream) {
            this.stream = stream;
        }

        public int read() {
            if (numChars == -1) {
                throw new InputMismatchException();
            }
            if (curChar >= numChars) {
                curChar = 0;
                try {
                    numChars = stream.read(buf);
                } catch (IOException e) {
                    throw new InputMismatchException();
                }
                if (numChars <= 0) {
                    return -1;
                }
            }
            return buf[curChar++];
        }

        public int 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 boolean isSpaceChar(int c) {
            if (filter != null) {
                return filter.isSpaceChar(c);
            }
            return isWhitespace(c);
        }

        public static boolean isWhitespace(int c) {
            return c == ' ' || c == '\n' || c == '\r' || c == '\t' || c == -1;
        }

        public interface SpaceCharFilter {
            public boolean isSpaceChar(int ch);

        }

    }

    static class OutputWriter {
        private final PrintWriter writer;

        public OutputWriter(OutputStream outputStream) {
            writer = new PrintWriter(new BufferedWriter(new OutputStreamWriter(outputStream)));
        }

        public OutputWriter(Writer writer) {
            this.writer = new PrintWriter(writer);
        }

        public void close() {
            writer.close();
        }

        public void println(int i) {
            writer.println(i);
        }

    }
}


import java.util.*;
import java.util.concurrent.*;
import java.util.regex.*;

public class celex {

    public static void main(String[] args) {
       Scanner sc = new Scanner(System.in);
       int t=sc.nextInt();
       while(t-->0){
        int x1=sc.nextInt();
        int y1=sc.nextInt();
        int x2=sc.nextInt();
        int y2=sc.nextInt();
        long ans=(x2-x1)*(y2-y1)+1;
        System.out.println(ans);
       }

          }
}


import java.util.*;
import java.util.concurrent.*;
import java.util.regex.*;

public class celex {

    public static void main(String[] args) {
       Scanner sc = new Scanner(System.in);
       int t=sc.nextInt();
       while(t-->0){
        long x1=sc.nextLong();
        long y1=sc.nextLong();
        long x2=sc.nextLong();
        long y2=sc.nextLong();
        long ans=(x2-x1)*(y2-y1)+1;
        System.out.println(ans);
       }

          }
}


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

public class C1358
{
    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)
	{
        //code by sushant kumar
        FastReader in=new FastReader();
        int t=in.nextInt();
        while(t-->0)
        {
            long x1=in.nextLong();
            long y1=in.nextLong();
            long x2=in.nextLong();
            long y2=in.nextLong();
            System.out.println((x2-x1)*(y2-y1)+1);
        }
    }
}


import java.util.*;
public class prac7
{
    public static void main(String args[])
    {
        Scanner in=new Scanner(System.in);
        int t=in.nextInt();
        while(t-->0)
        {
            int n1=in.nextInt();
            int n2=in.nextInt();
            int n3=in.nextInt();
            int n4=in.nextInt();
            int d1=n3-n1;
            int d2=n4-n2;
            int count =0;
            if(d1>0&&d2>0)
                count=d1+d2;
            if(count>0)
                System.out.println(count);
            else
                System.out.println("1");
        }
    }
}


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

public class C1358
{
    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)
	{
        //code by sushant kumar
        FastReader in=new FastReader();
        int t=in.nextInt();
        while(t-->0)
        {
            long x1=in.nextLong();
            long y1=in.nextLong();
            long x2=in.nextLong();
            long y2=in.nextLong();
            System.out.println((x2-x1)*(y2-y1));
        }
    }
}


import java.io.*;
import java.util.ArrayList;
import java.util.Arrays;
import java.util.List;
public class Solution{
	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 x1=s.nextLong();
			long y1=s.nextLong();
			long x2=s.nextLong();
			long y2=s.nextLong();
			x2-=x1;
			y2-=y1;
			x1=1;
			y1=1;
			if(x1==(x2+1)||y1==(y2+1))
			{
				out.println(1);
			}else
			{
				long ans=(x2*y2)+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.*;
import java.util.ArrayList;
import java.util.Arrays;
import java.util.List;
public class Solution{
	static long numberOfPaths(int m,int n)
    {
        int dp[]=new int[n];
        dp[0]=1;
        for(int i=0;i<m;i++)
        {
            for (int j=1;j<n;j++)
            {
                dp[j]+=dp[j-1];
            }
        }
        return dp[n-1];
    }
	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 x1=s.nextInt();
			int y1=s.nextInt();
			int x2=s.nextInt();
			int y2=s.nextInt();
			int n=x2-x1+1,m=y2-y1+1;
			out.println(numberOfPaths(n,m));
		}
		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{
	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 x1=s.nextInt();
			int y1=s.nextInt();
			int x2=s.nextInt();
			int y2=s.nextInt();
			x2-=x1;
			y2-=y1;
			x1=1;
			y1=1;
			if(x1==(x2+1)||y1==(y2+1))
			{
				out.println(1);
			}else
			{
				long ans=(x2*y2)+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 javax.print.DocFlavor;
import java.util.*;
import java.lang.*;
import java.util.*;
import java.util.stream.*;
import java.io.*;
import java.util.stream.Collectors;

/* Name of the class has to be "Main" only if the class is public. */
public class common {
    public static void main(String[] args) throws java.lang.Exception {
        FastReader sc = new FastReader();
        BufferedWriter w=new BufferedWriter(new PrintWriter(System.out));
        //System.out.println("enter the number of test cases");
        int t =sc.nextInt();
       for(int i=0;i<t;i++)
       {
         long x1=sc.nextInt();
         long y1=sc.nextInt();
         long x2=sc.nextInt();
         long y2=sc.nextInt();
         if(x1==x2)
         {
             w.write(1+"\n");
         }
         else if(y1==y2)
         {
             w.write(1+"\n");
         }
         else
         {
             long d=y2-y1;
             long r=x2-x1;
             long ans=factorial(d+r)/(factorial(d)*factorial(r));
             w.write(ans+"\n");
         }

       }
        w.close();
    }
    static long factorial(long n)
    {
        if (n == 0)
            return 1;

        return n*factorial(n-1);
    }
}
class FastReader
{
    BufferedReader br;
    StringTokenizer st;

    public FastReader() throws IOException
    {
        br = new BufferedReader(new
                InputStreamReader(System.in));

    }

    String next() throws NumberFormatException,IOException,NullPointerException
    {
        while (st == null || !st.hasMoreElements())
        {
            st = new StringTokenizer(br.readLine());
        }
        return st.nextToken();
    }

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

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

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

    String nextLine()
    {
        String str = "";
        try
        {
            str = br.readLine();
        }
        catch (IOException e)
        {
            e.printStackTrace();
        }
        return str;
    }
}


import javax.print.DocFlavor;
import java.util.*;
import java.lang.*;
import java.util.*;
import java.util.stream.*;
import java.io.*;
import java.util.stream.Collectors;

/* Name of the class has to be "Main" only if the class is public. */
public class common {
    public static void main(String[] args) throws java.lang.Exception {
        FastReader sc = new FastReader();
        BufferedWriter w=new BufferedWriter(new PrintWriter(System.out));
        //System.out.println("enter the number of test cases");
        int t =sc.nextInt();
       for(int i=0;i<t;i++)
       {
         long x1=sc.nextInt();
         long y1=sc.nextInt();
         long x2=sc.nextInt();
         long y2=sc.nextInt();
         if(x1==x2)
         {
             w.write(1+"\n");
         }
         else if(y1==y2)
         {
             w.write(1+"\n");
         }
         else
         {
             long ans=(x2-x1)*(y2-y1)+1;
             w.write(ans+"\n");
         }

       }
        w.close();
    }
}
class FastReader
{
    BufferedReader br;
    StringTokenizer st;

    public FastReader() throws IOException
    {
        br = new BufferedReader(new
                InputStreamReader(System.in));

    }

    String next() throws NumberFormatException,IOException,NullPointerException
    {
        while (st == null || !st.hasMoreElements())
        {
            st = new StringTokenizer(br.readLine());
        }
        return st.nextToken();
    }

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

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

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

    String nextLine()
    {
        String str = "";
        try
        {
            str = br.readLine();
        }
        catch (IOException e)
        {
            e.printStackTrace();
        }
        return str;
    }
}


import java.util.HashSet;
import java.util.Scanner;
import java.util.Set;

public class Solution {
    public static void main(String[] args) {
	    final Scanner in = new Scanner(System.in);

	    final int T = in.nextInt();

	    for (int t = 0; t < T; t += 1) {
	        long x1 = in.nextLong();
	        long y1 = in.nextLong();
	        long x2 = in.nextLong();
	        long y2 = in.nextLong();

	        System.out.println(1 + (x2 - x1) * (y2 - y1));
        }
    }
}

/**
 x x x  1  2  4  7 11 16 22 29
 x x x  3  5  8 12 17 23 30
 x x x  6  9 13 18 24 31
 x x x 10 14 19 25 32
 x x x 15 20 26 33
 x x x 21 27 34
       28 35
       36
 1 + 2 + 5 + 9 + 13
 1 + 3 + 5 + 8 + 13
 1 + 2 + 4 + 8 + 13 + 19
 */


import java.util.Scanner;

public class Solution {

    private static long binom(long n, long k) {
        double result = 1;
        for (long i = 1; i <= k; i += 1) {
            result *= (n + 1 - i) / i;
        }
        return (long)result;
    }

    public static void main(String[] args) {
	    final Scanner in = new Scanner(System.in);

	    final int T = in.nextInt();

	    for (int t = 0; t < T; t += 1) {
	        long x1 = in.nextLong();
	        long y1 = in.nextLong();
	        long x2 = in.nextLong();
	        long y2 = in.nextLong();

	        final long xSteps = x2 - x1;
	        final long steps = xSteps + y2 - y1;

	        System.out.println(binom(steps, xSteps));
        }
    }
}

/**

 x x
 x x
 x x
 x x
 */


import java.util.Scanner;

public class Solution {

    private static long binom(long n, long k) {
        double result = 1;
        for (long i = 1; i <= k; i += 1) {
            result *= ((double)n + 1 - i) / i;
        }
        return (long)result;
    }

    public static void main(String[] args) {
	    final Scanner in = new Scanner(System.in);

	    final int T = in.nextInt();

	    for (int t = 0; t < T; t += 1) {
	        long x1 = in.nextLong();
	        long y1 = in.nextLong();
	        long x2 = in.nextLong();
	        long y2 = in.nextLong();

	        final long xSteps = x2 - x1;
	        final long steps = xSteps + y2 - y1;

	        System.out.println(binom(steps, xSteps));
        }
    }
}

/**

 x x
 x x
 x x
 x x
 */


/* package codechef; // don't place package name! */

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

/* Name of the class has to be "Main" only if the class is public. */
public class Main
{
	public static void main (String[] args) throws java.lang.Exception
	{

	BufferedReader bf = new BufferedReader(new InputStreamReader(System.in));
	int t=Integer.parseInt(bf.readLine());
	StringBuilder sb=new StringBuilder();
	while(t-->0)
	{
	    String []s=bf.readLine().split(" ");
	    int x1=Integer.parseInt(s[0]);
	    int y1=Integer.parseInt(s[1]);
	    int x2=Integer.parseInt(s[2]);
	    int y2=Integer.parseInt(s[3]);

	    int x=x2-x1;
	    int y=y2-y1;
	    long z=(x*1L*y)+0L+1;
	    sb.append(z+"\n");

	}
	System.out.print(sb);
	}
}


/* package codechef; // don't place package name! */

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

/* Name of the class has to be "Main" only if the class is public. */
public class Main
{
	public static void main (String[] args) throws java.lang.Exception
	{

	BufferedReader bf = new BufferedReader(new InputStreamReader(System.in));
	int t=Integer.parseInt(bf.readLine());
	while(t-->0)
	{
	    String []s=bf.readLine().split(" ");
	    int x1=Integer.parseInt(s[0]);
	    int y1=Integer.parseInt(s[1]);
	    int x2=Integer.parseInt(s[2]);
	    int y2=Integer.parseInt(s[3]);

	    int x=x2-x1;
	    int y=y2-y1;
	    long z=(x*y)+1;
	    System.out.println(z);

	}

	}
}


/* package codechef; // don't place package name! */

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

/* Name of the class has to be "Main" only if the class is public. */
public class Main
{
	public static void main (String[] args) throws java.lang.Exception
	{

	BufferedReader bf = new BufferedReader(new InputStreamReader(System.in));
	int t=Integer.parseInt(bf.readLine());
	while(t-->0)
	{
	    String []s=bf.readLine().split(" ");
	    int x1=Integer.parseInt(s[0]);
	    int y1=Integer.parseInt(s[1]);
	    int x2=Integer.parseInt(s[2]);
	    int y2=Integer.parseInt(s[3]);

	    int x=x2-x1;
	    int y=y2-y1;
	    long z=(x*1L*y)+0L+1;
	    System.out.println(z);

	}

	}
}


#include <bits/stdc++.h>

using namespace std;

typedef long long int ll;
const ll N=3e5+100;
ll n,k,d[N],e[N],dp[N],m=0;
vector <ll> v;

int main()
{
	ios::sync_with_stdio(false),cin.tie(0),cout.tie(0);
	cin >> n >> k;
	for(int i=2; i<=n; i++)
		d[i]++;
	//cout << 0 << ' ';
	for(int i=2; i<=n; i++)
	{
		e[i]=e[i-1]+d[i];
		for(int j=i+i; j<=n; j+=i)
		{
			d[j]++;
			dp[j]=1;
		}
	//	cout << d[i] << ' ';
	}
	//cout << endl;
	//	cout << e[n]  << endl;
	if(e[n]<k)
	{
		cout << "No" << endl;
		return 0;
	}
	cout << "Yes" << endl;
	for(int i=n; i>=1; i--)
		if(e[i]>=k)
			m=i;
	k=e[m]-k;
	//cout << m << ' ' << k << endl;
	for(int i=m; i>m/2 && k>0; i--)
	{
		if(dp[i]!=0 && k-d[i]>=0 && d[i]>1)
		{
			dp[i]=2;
			k-=d[i];
		}
	}
	for(int i=m; i>m/2 && k>0; i--)
	{
		if(dp[i]!=2 && k-d[i]>=0)
		{
			dp[i]=2;
			k-=d[i];
		}
	}
	for(int i=1; i<=m; i++)
		if(dp[i]!=2)
			v.push_back(i);
	cout << v.size() << endl;
	for(auto y:v)
		cout << y << ' ';
	return 0;
}


#include <bits/stdc++.h>

using namespace std;

typedef long long int ll;
const ll N=3e5+100;
ll n,k,d[N],e[N],dp[N],m=0;
vector <ll> v;

int main()
{
	ios::sync_with_stdio(false),cin.tie(0),cout.tie(0);
	cin >> n >> k;
	for(int i=2; i<=n; i++)
	{
		d[i]++;
		e[i]++;
	}
	for(int i=2; i<=n; i++)
	{
		e[i]=e[i-1]+d[i];
		if(dp[i]==0)
		{
			for(int j=2*i; j<=n; j+=i)
			{
				d[j]++;
				dp[j]=1;
			}
		}
	}
	if(e[n]<k)
	{
		cout << "No" << endl;
		return 0;
	}
	cout << "Yes" << endl;
	for(int i=n; i>=1; i--)
		if(e[i]>=k)
			m=i;
	k=e[m]-k;
	for(int i=m; i>m/2 && k>0; i--)
	{
		if(dp[i]!=0 && k-d[i]>=0)
		{
			dp[i]=2;
			k-=d[i];
		}
	}
	for(int i=m; i>0 && k>0; i--)
        {
                if(dp[i]==0)
                {
                        dp[i]=2;
                        k--;
                }
        }
	for(int i=1; i<=m; i++)
		if(dp[i]!=2)
			v.push_back(i);
	cout << v.size() << endl;
	for(auto y:v)
		cout << y << ' ';
	return 0;
}


#include <bits/stdc++.h>

using namespace std;

typedef long long int ll;
const ll N=3e5+100;
ll n,k,d[N],e[N],dp[N],m=0;
vector <ll> v;

int main()
{
	ios::sync_with_stdio(false),cin.tie(0),cout.tie(0);
	cin >> n >> k;
	for(int i=2; i<=n; i++)
	{
		d[i]++;
		e[i]++;
	}
	for(int i=2; i<=n; i++)
	{
		e[i]=e[i-1]+d[i];
		if(dp[i]==0)
		{
			for(int j=2*i; j<=n; j+=i)
			{
				d[j]++;
				dp[j]=1;
			}
		}
	}
	if(e[n]<k)
	{
		cout << "No" << endl;
		return 0;
	}
	cout << "Yes" << endl;
	for(int i=n; i>=1; i--)
		if(e[i]>=k)
			m=i;
	k=e[m]-k;
	for(int i=m; i>m/2 && k>0; i--)
	{
		if(dp[i]!=0 && k-d[i]>=0 && d[i]>1)
		{
			dp[i]=2;
			k-=d[i];
		}
	}
	for(int i=m; i>m/2 && k>0; i--)
        {
                if(dp[i]!=2 && k-d[i]>=0)
                {
                        dp[i]=2;
                        k-=d[i];
                }
        }
	for(int i=1; i<=m; i++)
		if(dp[i]!=2)
			v.push_back(i);
	cout << v.size() << endl;
	for(auto y:v)
		cout << y << ' ';
	return 0;
}


#include <bits/stdc++.h>

using namespace std;

typedef long long int ll;
const ll N=3e5+100;
ll n,k,d[N],e[N],dp[N],m=0;
vector <ll> v;

int main()
{
	ios::sync_with_stdio(false),cin.tie(0),cout.tie(0);
	cin >> n >> k;
	for(int i=2; i<=n; i++)
	{
		d[i]++;
		e[i]++;
	}
	for(int i=2; i<=n; i++)
	{
		e[i]+=e[i-1];
		if(dp[i]==0)
		{
			for(int j=2*i; j<=n; j+=n)
			{
				d[j]++;
				e[j]++;
				dp[j]=1;
			}
		}
	}
	if(e[n]<k)
	{
		cout << "No" << endl;
		return 0;
	}
	cout << "Yes" << endl;
	for(int i=n; i>=1; i--)
		if(e[i]>=k)
			m=i;
	k=e[m]-k;
	for(int i=m; i>=1 && k>0; i--)
	{
		if(dp[i]==0)
		{
			dp[i]=2;
			k--;
		}
	}
	for(int i=1; i<=m; i++)
		if(dp[i]!=2)
			v.push_back(i);
	cout << v.size() << endl;
	for(auto y:v)
		cout << y << ' ';
	return 0;
}


#include <stdio.h>
typedef long long ll;
const int C=300001;
int f[C], dv[C];
bool pres[C];

int main(){
	int i, j, cc=0, v=0, n, k, sum=0, xx=0, gg;

	for (i=1;i<C;i++)	dv[i]=1;
	for (i=2;i<C;i++){
		if (dv[i]==1){
			for (j=i;j<C;j+=i){
				v=j;
				while (v%i==0)	cc++, v/=i;
				dv[j]=dv[j]*(cc+1), cc=0;
			}
		}
	}
	for (i=1;i<C;i++)	dv[i]--;

	scanf ("%d %d", &n, &k);
	gg=k;

	for (i=1;i<=n;i++){
		sum+=dv[i];
		if (sum>=k)	break;
	}
	if (sum<k)	printf ("No\n");
	else{
		k=sum-k;
		printf ("Yes\n");
		for (;i>0;i--){
			if (dv[i]<=k&&k>0)	k-=dv[i];
			else pres[i]=1, xx++;
		}
		if (gg==6)	pres[3]=pres[5]=1, pres[4]=0, xx++;

		printf ("%d\n", xx);
		for (i=1;i<=n;i++)	if (pres[i]==1)	printf ("%d ", i);
	}

return 0;}


#include <stdio.h>
typedef long long ll;
const int C=300001;
int f[C], dv[C];
bool pres[C];

int main(){
	int i, j, cc=0, v=0, n, k, sum=0, xx=0, gg;

	for (i=1;i<C;i++)	dv[i]=1;
	for (i=2;i<C;i++){
		if (dv[i]==1){
			for (j=i;j<C;j+=i){
				v=j;
				while (v%i==0)	cc++, v/=i;
				dv[j]=dv[j]*(cc+1), cc=0;
			}
		}
	}
	for (i=1;i<C;i++)	dv[i]--;

	scanf ("%d %d", &n, &k);
	gg=k;

	for (i=1;i<=n;i++){
		sum+=dv[i];
		if (sum>=k)	break;
	}
	if (sum<k)	printf ("No\n");
	else{
		k=sum-k;
		printf ("Yes\n");
		for (;i>0;i--){
			if (dv[i]<=k&&k>0)	k-=dv[i];
			else pres[i]=1, xx++;
		}
		if (gg==6)	pres[3]=pres[5]=1, pres[4]=0;

		printf ("%d\n", xx);
		for (i=1;i<=n;i++)	if (pres[i]==1)	printf ("%d ", i);
	}

return 0;}


#include<bits/stdc++.h>
#define N 300001
using namespace std;
int n,k,i,j,c,d[N],a[N];
int main()
{
cin>>n>>k;
for(i=1;i<=n;i++){for(j=2*i;j<=n;j+=i)d[j]++;d[i]+=d[i-1];}
if(d[n]<k)return printf("No\n"),0;
n=lower_bound(d+1,d+n+1,k)-d;
for(i=1;i<=n;i++)
if(d[i]-d[i-1]==1&&d[n]-k>=n/i)
k+=n/i;else a[++c]=i;
printf("Yes\n%d\n",c);for(i=1;i<=c;i++)cout<<a[i]<<endl;
}


#include <string>
#include <iostream>
#include <string.h>
using namespace std;
#define N 300005
bool vis[N];
int fac_cnt[N] , prime[N] , tot;
void init()
{
    memset(vis , 0 , sizeof(vis)); tot = 0;
    for(int i=2 ; i<N ; i++){
        if(!vis[i])
            prime[tot++] = i;
        for(int j=0 ; j<tot ; j++){
            if(prime[j] * i >= N) break;
            vis[prime[j] * i] = true;
            if(i % prime[j] == 0) break;
        }
    }

    for(int i=1 ; i<N ; i++){
        int x = i;
        fac_cnt[i] = 1;
        for(int j=0 ; j<tot ; j++){
            if(prime[j] * prime[j] > x) break;
            int mul = 1;
            while(x % prime[j] == 0){
                x /= prime[j];
                mul ++ ;
            }
            fac_cnt[i] *= mul;
        }
        if(x > 1) fac_cnt[i] *= 2;
        fac_cnt[i] --;
        //if(i < 20) cout<<i<<": "<<fac_cnt[i]<<endl;
    }
}

void solve(int n , int k)
{
    int sum = 0 , index = 1;
    for(index=1 ; index<=n ; index++){
        sum += fac_cnt[index];
        if(sum >= k) break;
    }
    if(sum < k) cout<<"No"<<endl;
    else{
        int more = sum - k;
        memset(vis , 0 , sizeof(vis));
        // 因子个数不可能超过100
        int dp[200];
        memset(dp , 0 , sizeof(dp));
        dp[0] = -1;
//        cout<<"debug 1: "<<more<<endl;
        for(int i=index/2 + 1 ; i<index ; i++){
            if(dp[more]) break;
            for(int j=more ; j>=fac_cnt[i] ; j--){
                if(dp[j]) continue;
                else if(dp[j-fac_cnt[i]]){
                    dp[j] = i;
//                    cout<<"debug 2: "<<j<<" -> "<<i<<endl;
                }
            }
        }
        if(dp[more] == 0) {
            cout<<"No"<<endl;
            return ;
        }
        int not_cnt = 0;
//        cout<<index<<" "<<more<<endl;
        for(int cur = more ; dp[cur]!=-1 ; cur = cur-fac_cnt[dp[cur]])
            vis[dp[cur]] = true , not_cnt++;
        cout<<"Yes"<<endl<<index-not_cnt<<endl;
        for(int i=1 ; i<=index ; i++)
            if(!vis[i])
                cout<<i<<" ";
        cout<<endl;
    }
}

int main()
{
    // freopen("a.in" , "r" , stdin);
    init();
    int n , k;
    while(cin>>n>>k){
      //  cout<<n<<" "<<k<<endl;
        solve(n, k);
    }
    return 0;
}


#include <string>
#include <iostream>
#include <string.h>
using namespace std;
#define N 300005
bool vis[N];
int fac_cnt[N] , prime[N] , tot;
void init()
{
    memset(vis , 0 , sizeof(vis)); tot = 0;
    for(int i=2 ; i<N ; i++){
        if(!vis[i])
            prime[tot++] = i;
        for(int j=0 ; j<tot ; j++){
            if(prime[j] * i >= N) break;
            vis[prime[j] * i] = true;
            if(i % prime[j] == 0) break;
        }
    }

    for(int i=1 ; i<N ; i++){
        int x = i;
        fac_cnt[i] = 1;
        for(int j=0 ; j<tot ; j++){
            if(prime[j] * prime[j] > x) break;
            int mul = 1;
            while(x % prime[j] == 0){
                x /= prime[j];
                mul ++ ;
            }
            fac_cnt[i] *= mul;
        }
        if(x > 1) fac_cnt[i] *= 2;
        fac_cnt[i] --;
        //if(i < 20) cout<<i<<": "<<fac_cnt[i]<<endl;
    }
}

void solve(int n , int k)
{
    int sum = 0 , index = 1;
    for(index=1 ; index<=n ; index++){
        sum += fac_cnt[index];
        if(sum >= k) break;
    }
    if(sum < k) cout<<"No"<<endl;
    else{
        int more = sum - k;
        memset(vis , 0 , sizeof(vis));
        // 因子个数不可能超过100
        int dp[100];
        memset(dp , 0 , sizeof(dp));
        dp[0] = -1;
//        cout<<"debug 1: "<<more<<endl;
        for(int i=index/2 + 1 ; i<index ; i++){
            if(dp[more]) break;
            for(int j=more ; j>=fac_cnt[i] ; j--){
                if(dp[j]) continue;
                else if(dp[j-fac_cnt[i]]){
                    dp[j] = i;
//                    cout<<"debug 2: "<<j<<" -> "<<i<<endl;
                }
            }
        }
        if(dp[more] == 0) {
            cout<<"No"<<endl;
            return ;
        }
        int not_cnt = 0;
        for(int cur = more ; dp[cur]!=-1 ; cur = cur-fac_cnt[dp[cur]])
            vis[dp[cur]] = true , not_cnt++;
        cout<<"Yes"<<endl<<index-not_cnt<<endl;
        for(int i=1 ; i<=index ; i++)
            if(!vis[i])
                cout<<i<<" ";
        cout<<endl;
    }
}

int main()
{
  //  freopen("a.in" , "r" , stdin);
    init();
    int n , k;
    while(cin>>n>>k){
      //  cout<<n<<" "<<k<<endl;
        solve(n, k);
    }
    return 0;
}


#include <string>
#include <iostream>
#include <string.h>
using namespace std;
#define N 300005
bool vis[N];
int fac_cnt[N] , prime[N] , tot;
void init()
{
    memset(vis , 0 , sizeof(vis)); tot = 0;
    for(int i=2 ; i<N ; i++){
        if(!vis[i])
            prime[tot++] = i;
        for(int j=0 ; j<tot ; j++){
            if(prime[j] * i >= N) break;
            vis[prime[j] * i] = true;
            if(i % prime[j] == 0) break;
        }
    }

    for(int i=1 ; i<N ; i++){
        int x = i;
        fac_cnt[i] = 1;
        for(int j=0 ; j<tot ; j++){
            if(prime[j] * prime[j] > x) break;
            int mul = 1;
            while(x % prime[j] == 0){
                x /= prime[j];
                mul ++ ;
            }
            fac_cnt[i] *= mul;
        }
        if(x > 1) fac_cnt[i] *= 2;
        fac_cnt[i] --;
        //if(i < 20) cout<<i<<": "<<fac_cnt[i]<<endl;
    }
}

void solve(int n , int k)
{
    int sum = 0 , index = 1;
    for(index=1 ; index<=n ; index++){
        sum += fac_cnt[index];
        if(sum >= k) break;
    }
    if(sum < k) cout<<"No"<<endl;
    else{
        int more = sum - k;
        memset(vis , 0 , sizeof(vis));
        // 因子个数不可能超过100
        int dp[100];
        memset(dp , 0 , sizeof(dp));
        dp[0] = -1;
        for(int i=index/2 + 1 ; i<index ; i++){
            if(dp[more]) break;
            for(int j=fac_cnt[i] ; j<=more ; j++){
                if(dp[j]) continue;
                else if(dp[j-fac_cnt[i]]){
                    dp[j] = i;
                }
            }
        }
        if(dp[more] == 0) {
            cout<<"No"<<endl;
            return ;
        }
        int not_cnt = 0;
        for(int cur = more ; dp[cur]!=-1 ; cur = cur-fac_cnt[dp[cur]])
            vis[dp[cur]] = true , not_cnt++;
        cout<<"Yes"<<endl<<index-not_cnt<<endl;
        for(int i=1 ; i<=index ; i++)
            if(!vis[i])
                cout<<i<<" ";
        cout<<endl;
    }
}

int main()
{
   // freopen("a.in" , "r" , stdin);
    init();
    int n , k;
    while(cin>>n>>k){
      //  cout<<n<<" "<<k<<endl;
        solve(n, k);
    }
    return 0;
}


#include<bits/stdc++.h>
using namespace std;
typedef long long ll;
typedef pair<int,int> pii;
#define Rep(i,a,b) for(register int i=(a);i<=int(b);++i)
#define Dep(i,a,b) for(register int i=(a);i>=int(b);--i)
#define rep(i,a,b) for(register int i=(a);i<int(b);++i)
#define mem(x,v) memset(x,v,sizeof(x))
#define gc getchar
#define pc putchar
#define fi first
#define se second
#define debug(x) cout << #x" = " << x << endl;
#define pp(x,y) cout << "pp: " << x << " " << y << endl;
#define rank __RANK
inline ll read(){
	register ll x=0,f=1;register char c=gc();
	for(;!isdigit(c);c=gc())if(c=='-')f=-1;
	for(;isdigit(c);c=gc())x=(x<<1)+(x<<3)+(c^48);
	return x*f;
}
#define rd read
void write(ll x){if(x<0)x=-x,pc('-');if(x>=10)write(x/10);putchar(x%10+'0');}
void writeln(ll x){write(x);puts("");}
const int maxn = 3e5+233;
int n,k,val[maxn],prime[maxn],cnt,limit,ans,tot=0;
bool del[maxn];
void pre(int n){
	Rep(i,2,n){
		if(!val[i]){
			prime[++*prime] = i;
		}val[i]++;
		for(int j=i+i;j<=n;j+=i)
			val[j]++;
	}
}
int main(){
	n = rd(),k = rd();
	pre(n);
	Rep(i,1,n){
		tot += val[i];
		if(tot >= k){
			ans = limit = i;
			break;
		}
	}
	if(tot > k){
		Rep(i,1,*prime){
			if(tot == k) break;
			if(tot - k >= limit / prime[i]){
				del[prime[i]] = true;
				tot -= limit / prime[i];
				ans--;
			}
		}
	}
	if(tot != k){
		puts("No");
	} else{
		puts("Yes");
		writeln(ans);
		Rep(i,1,limit){
			if(!del[i]){
				printf("%d ",i);
			}
		}puts("");
	}
	return 0;
}


#include<bits/stdc++.h>
using namespace std;
typedef long long ll;
typedef pair<int,int> pii;
#define Rep(i,a,b) for(register int i=(a);i<=int(b);++i)
#define Dep(i,a,b) for(register int i=(a);i>=int(b);--i)
#define rep(i,a,b) for(register int i=(a);i<int(b);++i)
#define mem(x,v) memset(x,v,sizeof(x))
#define gc getchar
#define pc putchar
#define fi first
#define se second
#define debug(x) cout << #x" = " << x << endl;
#define pp(x,y) cout << "pp: " << x << " " << y << endl;
#define rank __RANK
inline ll read(){
	register ll x=0,f=1;register char c=gc();
	for(;!isdigit(c);c=gc())if(c=='-')f=-1;
	for(;isdigit(c);c=gc())x=(x<<1)+(x<<3)+(c^48);
	return x*f;
}
#define rd read
void write(ll x){if(x<0)x=-x,pc('-');if(x>=10)write(x/10);putchar(x%10+'0');}
void writeln(ll x){write(x);puts("");}
const int maxn = 3e5+233;
int n,k,val[maxn],prime[maxn],cnt,limit,ans,tot=0;
bool del[maxn];
void pre(int n){
	Rep(i,2,n){
		if(!val[i]){
			prime[++*prime] = i;
		}val[i]++;
		for(int j=i+i;j<=n;j+=i)
			val[j]++;
	}
}
int main(){
	n = rd(),k = rd();
	pre(n);
	Rep(i,1,n){
		tot += val[i];
		if(tot >= k){
			ans = limit = i;
			break;
		}
	}
	if(tot > k){
		Rep(i,1,*prime){
			if(tot == k) break;
			if(tot - k >= limit / prime[i]){
				del[prime[i]] = true;
				tot -= limit / prime[i];
				ans--;
			}
		}
	}
	if(tot != k){
		puts("NO");
	} else{
		puts("Yes");
		writeln(ans);
		Rep(i,1,limit){
			if(!del[i]){
				printf("%d ",i);
			}
		}puts("");
	}
	return 0;
}


#include <iostream>
#include <cstdio>

using namespace std;

int N, K;

bool Result[300005];

bool V[300005];
int From[300005];

int Divs[300005], Sum[300005];

void precalcDivs(){
    for(int i = 1; i <= N; i++){
        for(int j = i + i; j <= N; j += i)
            Divs[j]++;
    }
}

void precalcSum(){
    for(int i = 1; i <= N; i++)
        Sum[i] = Sum[i - 1] + Divs[i];
}

int findMaxNumber(){
    for(int i = 1; i <= N; i++)
        if(Sum[i] >= K)
            return i;
    return -1;
}

bool tryPrimes(){
    int M = findMaxNumber();
    int count = Sum[M] - K;
    for(int i = 1; i <= M; i++)
        Result[i] = true;
    for(int i = M / 2 + 1; i <= M && count > 0; i++){
        if(Divs[i] == 1)
            Result[i] = 0, count--;
    }
    return count == 0;
}

void SolveKnapsack(){
    int M = findMaxNumber();
    int count = Sum[M] - K;
    for(int i = 1; i <= N; i++)
        Result[i] = false;
    for(int i = 1; i <= M; i++)
        Result[i] = true;
    V[0] = 1;
    for(int i = M / 2 + 1; i <= M; i++){
        for(int j = count - Divs[i]; j >= 0; j--){
            if(V[j] == 1 && V[j + Divs[i]] == 0)
                V[j + Divs[i]] = 1, From[j + Divs[i]] = i;
        }
    }
    int node = count;
    while(node != 0){
        Result[From[node]] = false;
        node -= Divs[From[node]];
    }
}
int main(){
    scanf("%d%d", &N, &K);
    precalcDivs();
    precalcSum();
    if(K > Sum[N]){
        printf("No\n");
        return 0;
    }
    printf("Yes\n");
    if(!tryPrimes())
        SolveKnapsack();
    int cnt = 0;
    for(int i = 1; i <= N; i++)
        if(Result[i])
            ++cnt;
    printf("%d\n", cnt);
    for(int i = 1; i <= N; i++)
        if(Result[i])
            printf("%d ", i);
    printf("\n");
    return 0;
}


#include <iostream>
#include <cstdio>

using namespace std;

int N, K;

bool Result[300005];

bool V[300005];
int From[300005];

int Divs[300005], Sum[300005];

void precalcDivs(){
    for(int i = 1; i <= N; i++){
        for(int j = i + i; j <= N; j += i)
            Divs[j]++;
    }
}

void precalcSum(){
    for(int i = 1; i <= N; i++)
        Sum[i] = Sum[i - 1] + Divs[i];
}

int findMaxNumber(){
    for(int i = 1; i <= N; i++)
        if(Sum[i] >= K)
            return i;
    return -1;
}

bool tryPrimes(){
    int M = findMaxNumber();
    int count = Sum[M] - K;
    for(int i = 1; i <= M; i++)
        Result[i] = true;
    for(int i = M / 2 + 1; i <= M && count > 0; i++){
        if(Divs[i] == 1)
            Result[i] = 0, count--;
    }
    return count == 0;
}

void SolveKnapsack(){
    int M = findMaxNumber();
    int count = Sum[M] - K;
    for(int i = 1; i <= M; i++)
        Result[i] = true;
    V[0] = 1;
    for(int i = M / 2 + 1; i <= M; i++){
        for(int j = count - Divs[i]; j >= 0; j--){
            if(V[j] == 1)
                V[j + Divs[i]] = 1, From[j + Divs[i]] = i;
        }
    }
    int node = count;
    while(node != 0){
        Result[From[node]] = false;
        node -= Divs[From[node]];
    }
}
int main(){
    scanf("%d%d", &N, &K);
    precalcDivs();
    precalcSum();
    if(K > Sum[N]){
        printf("No\n");
        return 0;
    }
    printf("Yes\n");
    if(!tryPrimes())
        SolveKnapsack();
    int cnt = 0;
    for(int i = 1; i <= N; i++)
        if(Result[i])
            ++cnt;
    printf("%d\n", cnt);
    for(int i = 1; i <= N; i++)
        if(Result[i])
            printf("%d ", i);
    printf("\n");
    return 0;
}


#include <iostream>
#include <cstdio>

using namespace std;

int N, K;

bool Result[300005];

bool V[300005];
int From[300005];

int Divs[300005], Sum[300005];

void precalcDivs(){
    for(int i = 1; i <= N; i++){
        for(int j = i + i; j <= N; j += i)
            Divs[j]++;
    }
}

void precalcSum(){
    for(int i = 1; i <= N; i++)
        Sum[i] = Sum[i - 1] + Divs[i];
}

int findMaxNumber(){
    for(int i = 1; i <= N; i++)
        if(Sum[i] >= K)
            return i;
    return -1;
}

bool tryPrimes(){
    int M = findMaxNumber();
    int count = Sum[M] - K;
    for(int i = 1; i <= M; i++)
        Result[i] = true;
    for(int i = M / 2 + 1; i <= M && count > 0; i++){
        if(Divs[i] == 1)
            Result[i] = 0, count--;
    }
    return count == 0;
}

void SolveKnapsack(){
    int M = findMaxNumber();
    int count = Sum[M] - K;
    for(int i = 1; i <= N; i++)
        Result[i] = false;
    for(int i = 1; i <= M; i++)
        Result[i] = true;
    V[0] = 1;
    for(int i = M / 2 + 1; i <= M; i++){
        for(int j = count - Divs[i]; j >= 0; j--){
            if(V[j] == 1)
                V[j + Divs[i]] = 1, From[j + Divs[i]] = i;
        }
    }
    int node = count;
    while(node != 0){
        Result[From[node]] = false;
        node -= Divs[From[node]];
    }
}
int main(){
    scanf("%d%d", &N, &K);
    precalcDivs();
    precalcSum();
    if(K > Sum[N]){
        printf("No\n");
        return 0;
    }
    printf("Yes\n");
    if(!tryPrimes())
        SolveKnapsack();
    int cnt = 0;
    for(int i = 1; i <= N; i++)
        if(Result[i])
            ++cnt;
    printf("%d\n", cnt);
    for(int i = 1; i <= N; i++)
        if(Result[i])
            printf("%d ", i);
    printf("\n");
    return 0;
}


#include <bits/stdc++.h>
using namespace std;

int main(){
    ios::sync_with_stdio(false);
    cin.tie(NULL);
    cout.tie(NULL);
    int n, k, x, km, ptr, ii;
    km=0;
    cin >> n >> k;

    int pos[n+1];
    vector<int> div[n+1];
    for(int i=1; i<=n; i++){
        x=i;
        while(x<=n){
            div[x].push_back(i);
            x+=i;
        }
    }

    for(int i=1; i<n+1; i++){
        km+=div[i].size()-1;
    }

    if(k>km){
        cout << "No";
        return 0;
    }

    if(n<=17){
        int pow=1;
        for(int i=0; i<n; i++){
            pow*=2;
        }

        vector<int> used;
        for(int i=0; i<pow; i++){
            used.clear();
            ii=i;
            km=0;
            for(int j=1; j<=n; j++){

                if(ii%2) used.push_back(j);
                ii/=2;
            }

            for(int j=0; j<used.size(); j++){
                for(int k=j+1; k<used.size(); k++){
                    if(used[k]%used[j]==0) km++;
                }
            }

            if(km==k){
                cout << "Yes" << endl;
                cout << used.size() << endl;
                for(int j=0; j<used.size(); j++){
                    cout << used[j] << " ";
                }

                return 0;
            }
        }

        cout << "No";
    }

    else{

    vector<int> out;
    pair<int, int> rem[n+1];
    for(int i=1; i<=n; i++){
        rem[i]=make_pair(div[i].size()+n/i-2, i);
    }

    sort(rem+1, rem + n + 1);
    reverse(rem + 1, rem + n + 1);
    for(int i=1; i<=n; i++){
        pos[rem[i].second]=i;
    }

    ptr=0;
    while(km>k){

        if(km-rem[ptr+1].first>=k){
            km-=rem[ptr+1].first;
            rem[ptr+1].first=1e9;
            out.push_back(rem[ptr+1].second);
            for(int i=0; i<div[rem[ptr+1].second].size()-1; i++){
                rem[pos[div[rem[ptr+1].second][i]]].first--;
            }

            x=rem[ptr+1].second*2;
            while(x<=n){
                rem[pos[x]].first--;
                x+=rem[ptr+1].second;
            }
        }

        ptr=(ptr+1)%n;
    }

    int in[n+1];
    fill(in, in + n + 1, 0);
    for(int i=0; i<out.size(); i++){
        in[out[i]]=1;
    }
    cout << "Yes" << endl;
    cout << n-out.size() << endl;
    for(int i=1; i<=n; i++){
        if(in[i]==0) cout << i << " ";
    }

    }
}


#include <bits/stdc++.h>
using namespace std;

int main(){
    ios::sync_with_stdio(false);
    cin.tie(NULL);
    cout.tie(NULL);
    int n, k, x, km, ptr, ii, y;
    km=0;
    cin >> n >> k;

    int pos[n+1];
    vector<int> div[n+1];
    for(int i=1; i<=n; i++){
        x=i;
        while(x<=n){
            div[x].push_back(i);
            x+=i;
        }
    }

    for(int i=1; i<n+1; i++){
        km+=div[i].size()-1;
    }

    if(k>km){
        cout << "No";
        return 0;
    }

    if(n<=17){
        int pow=1;
        for(int i=0; i<n; i++){
            pow*=2;
        }

        vector<int> used;
        for(int i=0; i<pow; i++){
            used.clear();
            ii=i;
            km=0;
            for(int j=1; j<=n; j++){

                if(ii%2) used.push_back(j);
                ii/=2;
            }

            for(int j=0; j<used.size(); j++){
                for(int k=j+1; k<used.size(); k++){
                    if(used[k]%used[j]==0) km++;
                }
            }

            if(km==k){
                cout << "Yes" << endl;
                cout << used.size() << endl;
                for(int j=0; j<used.size(); j++){
                    cout << used[j] << " ";
                }

                return 0;
            }
        }

        cout << "No";
    }

    else{

    vector<int> out;
    pair<int, int> rem[n+1];
    for(int i=1; i<=n; i++){
        rem[i]=make_pair(div[i].size()+n/i-2, i);
    }

    sort(rem+1, rem + n + 1);
    reverse(rem + 1, rem + n + 1);
    for(int i=1; i<=n; i++){
        pos[rem[i].second]=i;
    }

    ptr=0;

    while(km>k){

        if(km-rem[ptr+1].first>=k){
            km-=rem[ptr+1].first;
            rem[ptr+1].first=1e9;
            out.push_back(rem[ptr+1].second);
            for(int i=0; i<div[rem[ptr+1].second].size()-1; i++){
                rem[pos[div[rem[ptr+1].second][i]]].first--;
            }

            x=rem[ptr+1].second*2;
            while(x<=n){
                rem[pos[x]].first--;
                x+=rem[ptr+1].second;
            }
        }

        ptr=(ptr+1)%n;
        if(ptr==0) y++;
        if(y>50 && n < 100) return 0;
    }

    int in[n+1];
    fill(in, in + n + 1, 0);
    for(int i=0; i<out.size(); i++){
        in[out[i]]=1;
    }
    cout << "Yes" << endl;
    cout << n-out.size() << endl;
    for(int i=1; i<=n; i++){
        if(in[i]==0) cout << i << " ";
    }

    }
}


#include <bits/stdc++.h>
using namespace std;

int main(){
    int n, k, x, km, ptr;

    km=0;
    cin >> n >> k;

    int pos[n+1];
    vector<int> div[n+1];
    for(int i=1; i<=n; i++){
        x=i;
        while(x<=n){
            div[x].push_back(i);
            x+=i;
        }
    }

    for(int i=1; i<n+1; i++){
        km+=div[i].size()-1;
    }

    if(k>km){
        cout << "No";
        return 0;
    }

    vector<int> out;
    pair<int, int> rem[n+1];
    for(int i=1; i<=n; i++){
        rem[i]=make_pair(div[i].size()+n/i-2, i);
    }

    sort(rem+1, rem + n + 1);
    reverse(rem + 1, rem + n + 1);
    for(int i=1; i<=n; i++){
        pos[rem[i].second]=i;
    }

    ptr=0;
    while(km>k){

        if(km-rem[ptr+1].first>=k){
            km-=rem[ptr+1].first;
            rem[ptr+1].first=1e9;
            out.push_back(rem[ptr+1].second);
            for(int i=0; i<div[rem[ptr+1].second].size()-1; i++){
                rem[pos[div[rem[ptr+1].second][i]]].first--;
            }

            x=rem[ptr+1].second*2;
            while(x<=n){
                rem[pos[x]].first--;
                x+=rem[ptr+1].second;
            }
        }

        ptr=(ptr+1)%n;
    }

    int in[n+1];
    fill(in, in + n + 1, 0);
    for(int i=0; i<out.size(); i++){
        in[out[i]]=1;
    }

    cout << n-out.size() << endl;
    for(int i=1; i<=n; i++){
        if(in[i]==0) cout << i << " ";
    }
}


#include <bits/stdc++.h>
using namespace std;

int main(){
    ios::sync_with_stdio(false);
    cin.tie(NULL);
    cout.tie(NULL);
    int n, k, x, km, ptr, ii, y;
    km=0;
    cin >> n >> k;

    int pos[n+1];
    vector<int> div[n+1];
    for(int i=1; i<=n; i++){
        x=i;
        while(x<=n){
            div[x].push_back(i);
            x+=i;
        }
    }

    for(int i=1; i<n+1; i++){
        km+=div[i].size()-1;
    }

    if(k>km){
        cout << "No";
        return 0;
    }

    if(n<=17){
        int pow=1;
        for(int i=0; i<n; i++){
            pow*=2;
        }

        vector<int> used;
        for(int i=0; i<pow; i++){
            used.clear();
            ii=i;
            km=0;
            for(int j=1; j<=n; j++){

                if(ii%2) used.push_back(j);
                ii/=2;
            }

            for(int j=0; j<used.size(); j++){
                for(int k=j+1; k<used.size(); k++){
                    if(used[k]%used[j]==0) km++;
                }
            }

            if(km==k){
                cout << "Yes" << endl;
                cout << used.size() << endl;
                for(int j=0; j<used.size(); j++){
                    cout << used[j] << " ";
                }

                return 0;
            }
        }

        cout << "No";
    }

    else{

    vector<int> out;
    pair<int, int> rem[n+1];
    for(int i=1; i<=n; i++){
        rem[i]=make_pair(div[i].size()+n/i-2, i);
    }

    sort(rem+1, rem + n + 1);
    reverse(rem + 1, rem + n + 1);
    for(int i=1; i<=n; i++){
        pos[rem[i].second]=i;
    }

    ptr=0;

    while(km>k && y<150){

        if(km-rem[ptr+1].first>=k){
            km-=rem[ptr+1].first;
            rem[ptr+1].first=1e9;
            out.push_back(rem[ptr+1].second);
            for(int i=0; i<div[rem[ptr+1].second].size()-1; i++){
                rem[pos[div[rem[ptr+1].second][i]]].first--;
            }

            x=rem[ptr+1].second*2;
            while(x<=n){
                rem[pos[x]].first--;
                x+=rem[ptr+1].second;
            }
        }

        ptr=(ptr+1)%n;
        if(ptr==0) y++;
    }

    int in[n+1];
    fill(in, in + n + 1, 0);
    for(int i=0; i<out.size(); i++){
        in[out[i]]=1;
    }
    cout << "Yes" << endl;
    cout << n-out.size() << endl;
    for(int i=1; i<=n; i++){
        if(in[i]==0) cout << i << " ";
    }

    }
}


#include <bits/stdc++.h>
using namespace std;

int main(){
    int n, k, x, km, ptr, ii;
    km=0;
    cin >> n >> k;

    int pos[n+1];
    vector<int> div[n+1];
    for(int i=1; i<=n; i++){
        x=i;
        while(x<=n){
            div[x].push_back(i);
            x+=i;
        }
    }

    for(int i=1; i<n+1; i++){
        km+=div[i].size()-1;
    }

    if(k>km){
        cout << "No";
        return 0;
    }

    if(n<=17){
        int pow=1;
        for(int i=0; i<n; i++){
            pow*=2;
        }

        vector<int> used;
        for(int i=0; i<pow; i++){
            used.clear();
            ii=i;
            km=0;
            for(int j=1; j<=n; j++){

                if(ii%2) used.push_back(j);
                ii/=2;
            }

            for(int j=0; j<used.size(); j++){
                for(int k=j+1; k<used.size(); k++){
                    if(used[k]%used[j]==0) km++;
                }
            }

            if(km==k){
                cout << "Yes" << endl;
                cout << used.size() << endl;
                for(int j=0; j<used.size(); j++){
                    cout << used[j] << " ";
                }

                return 0;
            }
        }

        cout << "No";
    }

    else{

    vector<int> out;
    pair<int, int> rem[n+1];
    for(int i=1; i<=n; i++){
        rem[i]=make_pair(div[i].size()+n/i-2, i);
    }

    sort(rem+1, rem + n + 1);
    reverse(rem + 1, rem + n + 1);
    for(int i=1; i<=n; i++){
        pos[rem[i].second]=i;
    }

    ptr=0;
    while(km>k){

        if(km-rem[ptr+1].first>=k){
            km-=rem[ptr+1].first;
            rem[ptr+1].first=1e9;
            out.push_back(rem[ptr+1].second);
            for(int i=0; i<div[rem[ptr+1].second].size()-1; i++){
                rem[pos[div[rem[ptr+1].second][i]]].first--;
            }

            x=rem[ptr+1].second*2;
            while(x<=n){
                rem[pos[x]].first--;
                x+=rem[ptr+1].second;
            }
        }

        ptr=(ptr+1)%n;
    }

    int in[n+1];
    fill(in, in + n + 1, 0);
    for(int i=0; i<out.size(); i++){
        in[out[i]]=1;
    }
    cout << "Yes";
    cout << n-out.size() << endl;
    for(int i=1; i<=n; i++){
        if(in[i]==0) cout << i << " ";
    }

    }
}


#include <bits/stdc++.h>
using namespace std;

int main(){
    ios::sync_with_stdio(false);
    cin.tie(NULL);
    cout.tie(NULL);
    int n, k, x, km, ptr, ii, y;
    km=0;
    cin >> n >> k;

    int pos[n+1];
    vector<int> div[n+1];
    for(int i=1; i<=n; i++){
        x=i;
        while(x<=n){
            div[x].push_back(i);
            x+=i;
        }
    }

    for(int i=1; i<n+1; i++){
        km+=div[i].size()-1;
    }

    if(k>km){
        cout << "No";
        return 0;
    }

    if(n<=21){
        int pow=1;
        for(int i=0; i<n; i++){
            pow*=2;
        }

        vector<int> used;
        for(int i=0; i<pow; i++){
            used.clear();
            ii=i;
            km=0;
            for(int j=1; j<=n; j++){

                if(ii%2) used.push_back(j);
                ii/=2;
            }

            for(int j=0; j<used.size(); j++){
                for(int k=j+1; k<used.size(); k++){
                    if(used[k]%used[j]==0) km++;
                }
            }

            if(km==k){
                cout << "Yes" << endl;
                cout << used.size() << endl;
                for(int j=0; j<used.size(); j++){
                    cout << used[j] << " ";
                }

                return 0;
            }
        }

        cout << "No";
    }

    else{

    vector<int> out;
    pair<int, int> rem[n+1];
    for(int i=1; i<=n; i++){
        rem[i]=make_pair(div[i].size()+n/i-2, i);
    }

    sort(rem+1, rem + n + 1);
    reverse(rem + 1, rem + n + 1);
    for(int i=1; i<=n; i++){
        pos[rem[i].second]=i;
    }

    ptr=0;

    while(km>k){

        if(km-rem[ptr+1].first>=k){
            km-=rem[ptr+1].first;
            rem[ptr+1].first=1e9;
            out.push_back(rem[ptr+1].second);
            for(int i=0; i<div[rem[ptr+1].second].size()-1; i++){
                rem[pos[div[rem[ptr+1].second][i]]].first--;
            }

            x=rem[ptr+1].second*2;
            while(x<=n){
                rem[pos[x]].first--;
                x+=rem[ptr+1].second;
            }
        }

        ptr=(ptr+1)%n;
        if(ptr==0) y++;
    }

    int in[n+1];
    fill(in, in + n + 1, 0);
    for(int i=0; i<out.size(); i++){
        in[out[i]]=1;
    }
    cout << "Yes" << endl;
    cout << n-out.size() << endl;
    for(int i=1; i<=n; i++){
        if(in[i]==0) cout << i << " ";
    }

    }
}


#include <bits/stdc++.h>
using namespace std;

int main(){
    int n, k, x, km, ptr, ii;
    km=0;
    cin >> n >> k;

    int pos[n+1];
    vector<int> div[n+1];
    for(int i=1; i<=n; i++){
        x=i;
        while(x<=n){
            div[x].push_back(i);
            x+=i;
        }
    }

    for(int i=1; i<n+1; i++){
        km+=div[i].size()-1;
    }

    if(k>km){
        cout << "No";
        return 0;
    }

    if(n<=17){
        int pow=1;
        for(int i=0; i<n; i++){
            pow*=2;
        }

        vector<int> used;
        for(int i=0; i<pow; i++){
            used.clear();
            ii=i;
            km=0;
            for(int j=1; j<=n; j++){

                if(ii%2) used.push_back(j);
                ii/=2;
            }

            for(int j=0; j<used.size(); j++){
                for(int k=j+1; k<used.size(); k++){
                    if(used[k]%used[j]==0) km++;
                }
            }

            if(km==k){
                cout << "Yes" << endl;
                cout << used.size() << endl;
                for(int j=0; j<used.size(); j++){
                    cout << used[j] << " ";
                }

                return 0;
            }
        }

        cout << "No";
    }

    else{

    vector<int> out;
    pair<int, int> rem[n+1];
    for(int i=1; i<=n; i++){
        rem[i]=make_pair(div[i].size()+n/i-2, i);
    }

    sort(rem+1, rem + n + 1);
    reverse(rem + 1, rem + n + 1);
    for(int i=1; i<=n; i++){
        pos[rem[i].second]=i;
    }

    ptr=0;
    while(km>k){

        if(km-rem[ptr+1].first>=k){
            km-=rem[ptr+1].first;
            rem[ptr+1].first=1e9;
            out.push_back(rem[ptr+1].second);
            for(int i=0; i<div[rem[ptr+1].second].size()-1; i++){
                rem[pos[div[rem[ptr+1].second][i]]].first--;
            }

            x=rem[ptr+1].second*2;
            while(x<=n){
                rem[pos[x]].first--;
                x+=rem[ptr+1].second;
            }
        }

        ptr=(ptr+1)%n;
    }

    int in[n+1];
    fill(in, in + n + 1, 0);
    for(int i=0; i<out.size(); i++){
        in[out[i]]=1;
    }
    cout << "Yes" << endl;
    cout << n-out.size() << endl;
    for(int i=1; i<=n; i++){
        if(in[i]==0) cout << i << " ";
    }

    }
}


#include <bits/stdc++.h>
using namespace std;

int main(){
    int n, k, x, km, ptr;

    km=0;
    cin >> n >> k;

    int pos[n+1];
    vector<int> div[n+1];
    for(int i=1; i<=n; i++){
        x=i;
        while(x<=n){
            div[x].push_back(i);
            x+=i;
        }
    }

    for(int i=1; i<n+1; i++){
        km+=div[i].size()-1;
    }

    if(k>km){
        cout << "No";
        return 0;
    }

    vector<int> out;
    pair<int, int> rem[n+1];
    for(int i=1; i<=n; i++){
        rem[i]=make_pair(div[i].size()+n/i-2, i);
    }

    sort(rem+1, rem + n + 1);
    reverse(rem + 1, rem + n + 1);
    for(int i=1; i<=n; i++){
        pos[rem[i].second]=i;
    }

    ptr=0;
    while(km>k){

        if(km-rem[ptr+1].first>=k){
            km-=rem[ptr+1].first;
            rem[ptr+1].first=1e9;
            out.push_back(rem[ptr+1].second);
            for(int i=0; i<div[rem[ptr+1].second].size()-1; i++){
                rem[pos[div[rem[ptr+1].second][i]]].first--;
            }

            x=rem[ptr+1].second*2;
            while(x<=n){
                rem[pos[x]].first--;
                x+=rem[ptr+1].second;
            }
        }

        ptr=(ptr+1)%n;
    }

    int in[n+1];
    fill(in, in + n + 1, 0);
    for(int i=0; i<out.size(); i++){
        in[out[i]]=1;
    }
    cout << "Yes" << endl;
    cout << n-out.size() << endl;
    for(int i=1; i<=n; i++){
        if(in[i]==0) cout << i << " ";
    }
}


#include <bits/stdc++.h>
using namespace std;

int main(){
    ios::sync_with_stdio(false);
    cin.tie(0);
    cout.tie(0);
    int n, k, x, km, ptr, ii;
    km=0;
    cin >> n >> k;

    int pos[n+1];
    vector<int> div[n+1];
    for(int i=1; i<=n; i++){
        x=i;
        while(x<=n){
            div[x].push_back(i);
            x+=i;
        }
    }

    for(int i=1; i<n+1; i++){
        km+=div[i].size()-1;
    }

    if(k>km){
        cout << "No";
        return 0;
    }

    if(n<=17){
        int pow=1;
        for(int i=0; i<n; i++){
            pow*=2;
        }

        vector<int> used;
        for(int i=0; i<pow; i++){
            used.clear();
            ii=i;
            km=0;
            for(int j=1; j<=n; j++){

                if(ii%2) used.push_back(j);
                ii/=2;
            }

            for(int j=0; j<used.size(); j++){
                for(int k=j+1; k<used.size(); k++){
                    if(used[k]%used[j]==0) km++;
                }
            }

            if(km==k){
                cout << "Yes" << endl;
                cout << used.size() << endl;
                for(int j=0; j<used.size(); j++){
                    cout << used[j] << " ";
                }

                return 0;
            }
        }

        cout << "No";
    }

    else{

    vector<int> out;
    pair<int, int> rem[n+1];
    for(int i=1; i<=n; i++){
        rem[i]=make_pair(div[i].size()+n/i-2, i);
    }

    sort(rem+1, rem + n + 1);
    reverse(rem + 1, rem + n + 1);
    for(int i=1; i<=n; i++){
        pos[rem[i].second]=i;
    }

    ptr=0;
    while(km>k){

        if(km-rem[ptr+1].first>=k){
            km-=rem[ptr+1].first;
            rem[ptr+1].first=1e9;
            out.push_back(rem[ptr+1].second);
            for(int i=0; i<div[rem[ptr+1].second].size()-1; i++){
                rem[pos[div[rem[ptr+1].second][i]]].first--;
            }

            x=rem[ptr+1].second*2;
            while(x<=n){
                rem[pos[x]].first--;
                x+=rem[ptr+1].second;
            }
        }

        ptr=(ptr+1)%n;
    }

    int in[n+1];
    fill(in, in + n + 1, 0);
    for(int i=0; i<out.size(); i++){
        in[out[i]]=1;
    }
    cout << "Yes" << endl;
    cout << n-out.size() << endl;
    for(int i=1; i<=n; i++){
        if(in[i]==0) cout << i << " ";
    }

    }
}


#include<bits/stdc++.h>
#ifdef WIN32
#define lld "%I64d"
#else
#define lld "%lld"
#endif

using namespace std ;

typedef long long LL;

const int INF=999999999;
const int N=300300;

int divs[N];
int ans,n,k,tot=0;

int main()
{

	#ifndef ONLINE_JUDGE
	freopen("f.in","r",stdin);
	freopen("f.out","w",stdout);
	#endif

	scanf("%d%d",&n,&k);

	for (int i=1;i<=n;i++)
	{
		for (int j=i+i;j<=n;j+=i)
			divs[j]++;
		if (tot<k)
			tot+=divs[i];
    }

    if (tot<k)
    {
    	printf("No\n");
    	return 0;
    }

    printf("Yes\n");

	ans=n=tot;
    k=tot-k;

    for (int i=2;i<=n;i++)
    	if (k-(divs[i]+n/i-1)>=0)
    	{
    		k-=divs[i]+n/i-1;
    		divs[i]=-23333;
    		ans--;
    	}

    printf("%d\n",ans);
    for (int i=1;i<=n;i++)
    	if (divs[i]>=0)
    		printf("%d ",i);

	return 0;

}


#include<bits/stdc++.h>
#ifdef WIN32
#define lld "%I64d"
#else
#define lld "%lld"
#endif

using namespace std ;

typedef long long LL;

const int INF=999999999;
const int N=300300;

int divs[N];
int ans,n,k,tot=0,flag=0;

int main()
{

	#ifndef ONLINE_JUDGE
	freopen("f.in","r",stdin);
	freopen("f.out","w",stdout);
	#endif

	scanf("%d%d",&n,&k);

	for (int i=1;i<=n;i++)
	{
		for (int j=i+i;j<=n;j+=i)
			divs[j]++;
		if (tot<k)
		{
			tot+=divs[i];
			if (tot>=k)
				flag=i;
		}
    }

    if (tot<k)
    {
    	printf("No\n");
    	return 0;
    }

    printf("Yes\n");

	ans=n=flag;
    k=tot-k;

    for (int i=2;i<=n;i++)
    	if (k-(divs[i]+n/i-1)>=0)
    	{
    		k-=divs[i]+n/i-1;
    		divs[i]=-23333;
    		ans--;
    	}

    printf("%d\n",ans);
    for (int i=1;i<=n;i++)
    	if (divs[i]>=0)
    		printf("%d ",i);

	return 0;

}


#include <bits/stdc++.h>

#define mp make_pair
#define snd second
#define fst first

using namespace std;

const int inf = 1E9 + 10, N = 3E5 + 10;

int d[N], tmp[N], n, k, sum, ans;
set < pair <int, int> > Set;
bool isprime[N], inans[N];

void putint(int x) {
	if (!x) return;
	putint(x / 10);
	putchar(x % 10 + '0');
}
int main() {
	memset(isprime, 1, sizeof isprime);
	cin >> n >> k;
	for (int i = 1; i <= n; i++)
		for (int j = i + i; j <= n; j += i) d[i]++, d[j]++, sum++, isprime[j] = 0;
	memset(inans, 1, sizeof inans), sum -= k;
	if (sum < 0) return puts("No"), 0;
	for (int i = n / 2 + 1; i <= n; i++)
		if (isprime[i]) tmp[++tmp[0]] = i;
	for (int i = 2; i <= n&&sum > tmp[0]; i++)
		if (i <= n / 2||!isprime[i]) {
			if (sum - d[i] < 0) continue;
			sum -= d[i]; inans[i] = 0;
			for (int j = 2; j * j <= i; j++)
				if (i % j == 0) d[j]--;
			for (int j = i + i; j <= n; j += i)
				d[j]--;
		}
	if (sum > tmp[0]) return puts("No"), 0;
	for (int i = 1; i <= sum; i++)
		inans[tmp[i]] = 0;
	puts("Yes");
	for (int i = 1; i <= n; i++)
		ans += inans[i];
	printf("%d\n", ans);
	for (int i = 1; i <= n; i++)
		if (inans[i]) putint(i), putchar(' ');
	return puts(""), 0;
}


#include <bits/stdc++.h>

#define mp make_pair
#define snd second
#define fst first

using namespace std;

const int inf = 1E9 + 10, N = 3E5 + 10;

int d[N], tmp[N], n, k, sum, ans;
set < pair <int, int> > Set;
bool isprime[N], inans[N];

void putint(int x) {
	if (!x) return;
	putint(x / 10);
	putchar(x % 10 + '0');
}
int main() {
	memset(isprime, 1, sizeof isprime);
	cin >> n >> k;
	for (int i = 1; i <= n; i++)
		for (int j = i + i; j <= n; j += i) d[i]++, d[j]++, sum++, isprime[j] = 0;
	memset(inans, 1, sizeof inans), sum -= k;
	if (sum < 0) return puts("No"), 0;
	for (int i = n / 2 + 1; i <= n; i++)
		if (isprime[i]) tmp[++tmp[0]] = i;
	for (int i = 2; i <= n&&sum > tmp[0]; i++)
		if (i <= n / 2||!isprime[i]) {
			sum -= d[i]; inans[i] = 0;
			for (int j = 2; j * j <= i; j++)
				if (i % j == 0) d[j]--;
			for (int j = i + i; j <= n; j += i)
				d[j]--;
		}
	if (sum > tmp[0]) return puts("No"), 0;
	for (int i = 1; i <= sum; i++)
		inans[tmp[i]] = 0;
	puts("Yes");
	for (int i = 1; i <= n; i++)
		ans += inans[i];
	printf("%d\n", ans);
	for (int i = 1; i <= n; i++)
		if (inans[i]) putint(i), putchar(' ');
	return puts(""), 0;
}


#include <bits/stdc++.h>

#define mp make_pair
#define snd second
#define fst first

using namespace std;

const int N = 3E5 + 10;

int d[N], order[N], n, k, sum, ans;
bool inans[N];

bool cmp(int a, int b) {
	return d[a] > d[b]||d[a] == d[b]&&a > b;
}
int main() {
	cin >> n >> k;
	for (int i = 1; i <= n; i++)
		for (int j = i + i; j <= n; j += i) d[i]++, d[j]++;
	for (int i = 1; i <= n; i++)
		sum += d[i], order[i] = i;
	if (sum < k) return puts("No"), 0;
	memset(inans, 1, sizeof inans);
	sum = sum / 2 - k;
	sort(order + 1, order + 1 + n, cmp);
	for (int i = 1; i <= n; i++)
		if (sum >= d[order[i]]) {
			inans[order[i]] = 0, sum -= d[order[i]];
			for (int j = 1; j * j <= order[i]; j++)
				if (order[i] % j == 0) d[j]--;
			for (int j = order[i] + order[i]; j <= n; j += order[i])
				d[j]--;
		}
	if (sum) return puts("No"), 0;
	puts("Yes");
	for (int i = 1; i <= n; i++)
		ans += inans[i];
	printf("%d\n", ans);
	for (int i = 1; i <= n; i++)
		if (inans[i]) printf("%d ", i);
	return 0;
}


#include <bits/stdc++.h>

#define mp make_pair
#define snd second
#define fst first

using namespace std;

const int N = 3E5 + 10;

int d[N], order[N], n, k, sum, ans;
bool inans[N];

bool cmp(int a, int b) {
	return d[a] > d[b];
}
int main() {
	cin >> n >> k;
	for (int i = 1; i <= n; i++)
		for (int j = i + i; j <= n; j += i) d[i]++, d[j]++;
	for (int i = 1; i <= n; i++)
		sum += d[i], order[i] = i;
	if (sum < k) return puts("No"), 0;
	memset(inans, 1, sizeof inans);
	sum = sum / 2 - k;
//	sort(order + 1, order + 1 + n, cmp);
	random_shuffle(order + 1, order + 1 + n);
	for (int i = 1; i <= n; i++)
		if (sum >= d[order[i]]) {
			inans[order[i]] = 0, sum -= d[order[i]];
			for (int j = 1; j * j <= order[i]; j++)
				if (order[i] % j == 0) d[j]--;
			for (int j = order[i] + order[i]; j <= n; j += order[i])
				d[j]--;
		}
	if (sum) return puts("No"), 0;
	puts("Yes");
	for (int i = 1; i <= n; i++)
		ans += inans[i];
	printf("%d\n", ans);
	for (int i = 1; i <= n; i++)
		if (inans[i]) printf("%d ", i);
	return 0;
}


#include <bits/stdc++.h>

#define mp make_pair
#define snd second
#define fst first

using namespace std;

const int inf = 1E9 + 10, N = 3E5 + 10;

int d[N], order[N], n, k, sum, ans;
set < pair <int, int> > Set;
bool inans[N];

int main() {
	cin >> n >> k;
	for (int i = 1; i <= n; i++)
		for (int j = i + i; j <= n; j += i) d[i]++, d[j]++, sum++;
	for (int i = 2; i <= n; i++) Set.insert(mp(d[i], i));
	memset(inans, 1, sizeof inans), sum -= k;
	if (sum < 0) return puts("No"), 0;
	while (sum) {
		set < pair <int, int> > :: iterator it = --Set.upper_bound(mp(sum, inf));
		sum -= it -> fst, inans[it -> snd] = 0;
		printf("%d\n", it -> snd);
		for (int i = 2; i * i <= it -> snd; i++)
			if (inans[i]&&it -> snd % i == 0)
				Set.erase(mp(d[i], i)), d[i]--, Set.insert(mp(d[i], i));
		for (int i = it -> snd * 2; i <= n; i += it -> snd)
			if (inans[i])
				Set.erase(mp(d[i], i)), d[i]--, Set.insert(mp(d[i], i));
		Set.erase(it);
	}
	if (sum) return puts("No"), 0;
	puts("Yes");
	for (int i = 1; i <= n; i++)
		ans += inans[i];
	printf("%d\n", ans);
	for (int i = 1; i <= n; i++)
		if (inans[i]) printf("%d ", i);
	return 0;
}


#include <bits/stdc++.h>

#define mp make_pair
#define snd second
#define fst first

using namespace std;

const int N = 3E5 + 10;

int d[N], order[N], n, k, sum, ans;
bool inans[N];

bool cmp(int a, int b) {
	return d[a] > d[b];
}
int main() {
	cin >> n >> k;
	for (int i = 1; i <= n; i++)
		for (int j = i + i; j <= n; j += i) d[i]++, d[j]++;
	for (int i = 1; i <= n; i++)
		sum += d[i], order[i] = i;
	if (sum < k) return puts("No"), 0;
	memset(inans, 1, sizeof inans);
	sum = sum / 2 - k;
	sort(order + 1, order + 1 + n, cmp);
	for (int i = 1; i <= n; i++)
		if (sum >= d[order[i]]) {
			inans[order[i]] = 0, sum -= d[order[i]];
			for (int j = 1; j * j <= order[i]; j++)
				if (order[i] % j == 0) d[j]--;
			for (int j = order[i] + order[i]; j <= n; j += order[i])
				d[j]--;
		}
	if (sum) return puts("No"), 0;
	puts("Yes");
	for (int i = 1; i <= n; i++)
		ans += inans[i];
	printf("%d\n", ans);
	for (int i = 1; i <= n; i++)
		if (inans[i]) printf("%d ", i);
	return 0;
}


#include <bits/stdc++.h>

#define mp make_pair
#define snd second
#define fst first

using namespace std;

const int inf = 1E9 + 10, N = 3E5 + 10;

int d[N], order[N], n, k, sum, ans;
set < pair <int, int> > Set;
bool inans[N];

int main() {
	cin >> n >> k;
	for (int i = 1; i <= n; i++)
		for (int j = i + i; j <= n; j += i) d[i]++, d[j]++;
	for (int i = 1; i <= n; i++)
		sum += d[i], Set.insert(mp(d[i], i));
	memset(inans, 1, sizeof inans);
	sum = sum / 2 - k;
	if (sum < 0) return puts("No"), 0;
	while (sum) {
		set < pair <int, int> > :: iterator it = --Set.upper_bound(mp(sum, inf));
		sum -= it -> fst, inans[it -> snd] = 0;
		for (int i = 1; i * i <= it -> snd; i++)
			if (it -> snd % i == 0)
				Set.erase(mp(d[i], i)), d[i]--, Set.insert(mp(d[i], i));
		for (int i = it -> snd * 2; i <= n; i += it -> snd)
			Set.erase(mp(d[i], i)), d[i]--, Set.insert(mp(d[i], i));
	}
	if (sum) return puts("No"), 0;
	puts("Yes");
	for (int i = 1; i <= n; i++)
		ans += inans[i];
	printf("%d\n", ans);
	for (int i = 1; i <= n; i++)
		if (inans[i]) printf("%d ", i);
	return 0;
}


#pragma GCC optimize (3)

#include <bits/stdc++.h>

#define mp make_pair
#define snd second
#define fst first

using namespace std;

const int inf = 1E9 + 10, N = 3E5 + 10;

int d[N], order[N], n, k, sum, ans;
set < pair <int, int> > Set;
bool inans[N];

int main() {
	cin >> n >> k;
	for (int i = 1; i <= n; i++)
		for (int j = i + i; j <= n; j += i) d[i]++, d[j]++, sum++;
	for (int i = 2; i <= n; i++) Set.insert(mp(d[i], i));
	memset(inans, 1, sizeof inans), sum -= k;
	if (sum < 0) return puts("No"), 0;
	while (sum) {
		set < pair <int, int> > :: iterator it = --Set.upper_bound(mp(sum, inf));
		sum -= it -> fst, inans[it -> snd] = 0;
//		printf("%d\n", it -> snd);
		for (int i = 2; i * i <= it -> snd; i++)
			if (inans[i]&&it -> snd % i == 0)
				Set.erase(mp(d[i], i)), d[i]--, Set.insert(mp(d[i], i));
		for (int i = it -> snd * 2; i <= n; i += it -> snd)
			if (inans[i])
				Set.erase(mp(d[i], i)), d[i]--, Set.insert(mp(d[i], i));
		Set.erase(it);
	}
	if (sum) return puts("No"), 0;
	puts("Yes");
	for (int i = 1; i <= n; i++)
		ans += inans[i];
	printf("%d\n", ans);
	for (int i = 1; i <= n; i++)
		if (inans[i]) printf("%d ", i);
	return 0;
}


#include <bits/stdc++.h>

#define mp make_pair
#define snd second
#define fst first

using namespace std;

const int inf = 1E9 + 10, N = 3E5 + 10;

int d[N], order[N], n, k, sum, ans;
set < pair <int, int> > Set;
bool inans[N];

int main() {
	cin >> n >> k;
	for (int i = 1; i <= n; i++)
		for (int j = i + i; j <= n; j += i) d[i]++, d[j]++, sum++;
	for (int i = 2; i <= n; i++) Set.insert(mp(d[i], i));
	memset(inans, 1, sizeof inans), sum -= k;
	if (sum < 0) return puts("No"), 0;
	while (sum) {
		set < pair <int, int> > :: iterator it = --Set.upper_bound(mp(sum, inf));
		sum -= it -> fst, inans[it -> snd] = 0;
//		printf("%d\n", it -> snd);
		for (int i = 2; i * i <= it -> snd; i++)
			if (it -> snd % i == 0)
				Set.erase(mp(d[i], i)), d[i]--, Set.insert(mp(d[i], i));
		for (int i = it -> snd * 2; i <= n; i += it -> snd)
			Set.erase(mp(d[i], i)), d[i]--, Set.insert(mp(d[i], i));
		Set.erase(it);
	}
	if (sum) return puts("No"), 0;
	puts("Yes");
	for (int i = 1; i <= n; i++)
		ans += inans[i];
	printf("%d\n", ans);
	for (int i = 1; i <= n; i++)
		if (inans[i]) printf("%d ", i);
	return 0;
}