Problem: Given 2 integers u and v, find the shortest array such that [bitwise-xor](https://en.wikipedia.org/wiki/Bitwise_operation#XOR) of its elements is u, and the sum of its elements is v.

Input

The only line contains 2 integers u and v (0 ≤ u,v ≤ 10^{18}).

Output

If there's no array that satisfies the condition, print "-1". Otherwise:

The first line should contain one integer, n, representing the length of the desired array. The next line should contain n positive integers, the array itself. If there are multiple possible answers, print any.

Examples

Input


2 4


Output


2
3 1

Input


1 3


Output


3
1 1 1

Input


8 5


Output


-1

Input


0 0


Output


0

Note

In the first sample, 3⊕ 1 = 2 and 3 + 1 = 4. There is no valid array of smaller length.

Notice that in the fourth sample the array is empty.

Solution (in JAVA):

Solution:
import java.io.BufferedReader;
import java.io.InputStreamReader;
import java.io.PrintWriter;
import java.util.Arrays;
import java.util.StringTokenizer;

public class D {
	static PrintWriter out = new PrintWriter(System.out);

	//do a dp. Max K numbers
	static final int numBits = 63;
	static int maxCarry;
	static int curLen;
	static int dp[][];
	
	static long sumTo, xorTo;
	static long vs[];
	public static void main(String[] args) {
		FS in = new FS();
		xorTo = in.nextLong();
		sumTo = in.nextLong();
		if(xorTo > sumTo) {
			out.println(-1);
		}
		else if(xorTo == sumTo) {
			if(xorTo == 0) {
				out.println(0);
			}
			else {
				out.println(1);
				out.println(xorTo);
			}
		}
		else {
			for(int len = 2;len < 300;len++) {
				curLen = len;
				maxCarry = 10*len;
				dp = new int[maxCarry+1][numBits];
				for(int a[] : dp)
					Arrays.fill(a, -1);
				
				int res = go(0, 0);
				if(res == 1) {
					out.println(len);
					vs = new long[len];
					bb(0, 0);
					for(long ll : vs) out.print(ll+" ");
					out.println();
					out.close();
					return;
				}
			}
			out.println(-1);
		}
	
	
		out.close();
	}
	
	static int go(int carry, int bit) {
		if(bit >= numBits) return carry == 0 ? 1 : 0;
		if(carry >= maxCarry) return 0;
		if(dp[carry][bit] != -1) return dp[carry][bit];
		
		// now add bits
		int res = 0;
		for(int bitsHere = 0; bitsHere <= curLen; bitsHere++) {
			int xorBit = (bitsHere&1);
			int sumBit = (bitsHere+carry)&1;
			int newCarry = (bitsHere+carry)/2;
			
			int gx = (xorTo&(1L<<bit)) > 0 ? 1 : 0;
			int gs = (sumTo&(1L<<bit)) > 0 ? 1 : 0;
			if(xorBit != gx || sumBit != gs) continue;
			res = max(res, go(newCarry, bit+1));
		}
		return dp[carry][bit] = res;
	}
	
	static void bb(int carry, int bit) {
		if(bit >= numBits) return;
		if(carry >= maxCarry) return;
		
		// now add bits
		int res = 0;
		for(int bitsHere = 0; bitsHere <= curLen; bitsHere++) {
			int xorBit = (bitsHere&1);
			int sumBit = (bitsHere+carry)&1;
			int newCarry = (bitsHere+carry)/2;
			
			int gx = (xorTo&(1L<<bit)) > 0 ? 1 : 0;
			int gs = (sumTo&(1L<<bit)) > 0 ? 1 : 0;
			if(xorBit != gx || sumBit != gs) continue;
			res = max(res, go(newCarry, bit+1));
			if(res == 1) {
				for(int i = 0; i < bitsHere; i++) {
					vs[i] |= (1L<<bit);
				}
				bb(newCarry, bit+1);
				break;
			}
		}
	}
	
	static int min(int a, int b) { return a < b ? a : b;}
	static int max(int a, int b) { return a > b ? a : b;}
	
	static class FS{
		BufferedReader br;
		StringTokenizer st;
		public FS() {
			br = new BufferedReader(new InputStreamReader(System.in));
		}
		String next() {
			while(st == null || !st.hasMoreElements()) {
				try {st = new StringTokenizer(br.readLine());}
				catch(Exception e) { throw null;}
			}
			return st.nextToken();
		}
		int nextInt() { return Integer.parseInt(next());}
		double nextDouble() { return Double.parseDouble(next());}
		long nextLong() { return Long.parseLong(next());}
		int[] NIA(int n) {
			int r[] = new int[n];
			for(int i = 0; i < n; i++) r[i] = nextInt();
			return r;
		}
		long[] NLA(int n) {
			long r[] = new long[n];
			for(int i = 0; i < n; i++) r[i] = nextLong();
			return r;
		}
		char[][] grid(int r, int c){
			char res[][] = new char[r][c];
			for(int i = 0; i < r; i++) {
				char l[] = next().toCharArray();
				for(int j = 0; j < c; j++) {
					res[i][j] = l[j];
				}
			}
			return res;
		}
	}
	
}