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.util.*;
import java.lang.*;
import java.io.*;

public class D {
	private static FastReader fr;
	private static OutputStream out;
	private static int mod = (int)(1e9+7);
	
	private void solve() {
		long x = fr.nextLong();
		long y = fr.nextLong();
		if(x == y) {
			if(x==0) {
				println(0);
			}else {
				println(1);
				println(x);
			}
			return;
		}
		
		if(x > y) {
			println(-1);
			return;
		}
		int arr[][] = new int[3][64];
		arr[0] = to_binary(x);
		if((y-x) % 2 == 1) {
			println(-1);
			return;
		}
		
		long diff = (y-x) / 2;
		if(diff == 0) {
			println(x + " " + y);
			return;
		}
		
		arr[1] = to_binary(diff);
		for(int i=0;i<64;i++) {
			
			if(arr[1][i] == 1) {
				if(arr[0][i] == 1) {
					arr[2][i] = 1;
				}else {
					arr[0][i] = 1;
				}
			}
		}
		
		long a = to_long(arr[0]);
		long b = to_long(arr[1]);
		long c = to_long(arr[2]);
		
		long sum = a + b + c;
		long xor = a ^ b ^ c;
		if(c == 0) {
			println(2);
			println(a + " " + b);
			
		}else {
			println(3);
			println(a + " " + b + " " + c);
		}
//		printArray(to_binary(x));
//		printArray(to_binary(y));
//		println(to_long(to_binary(y)));
//		printArray(sum(arr[0], arr[1]));
//		printArray(arr[0]);
//		printArray(arr[1]);
////		printArray(arr[2]);
//		check(to_binary(x), xor(arr[0], arr[1]));
//		check(to_binary(y), sum(arr[0], arr[1]));
//		
//		println(xor + " " + sum);
	}
	
	private void check(int a[], int b[]) {
		for(int i=0;i<a.length;i++) {
			if(a[i] != b[i]) {
				println(i);
			}
		}
		println("==========");
	}
	private int[] xor(int a[], int b[]) {
		int ans[] = new int[a.length];
		for(int i=0;i<a.length;i++) {
			if(a[i] != b[i]) {
				ans[i] = 1;
			}
		}
		return ans;
	}
	
	private int[] sum(int a[], int b[]) {
		int ans[] = new int[a.length];
		int carry = 1;
		for(int i=0;i<a.length;i++) {
			ans[i] = (a[i] + b[i] + carry) % 2;
			carry = (a[i] + b[i] + carry) / 2;
		}
		if(carry == 1) {
			println("carry left");
		}
		return ans;
	}
	
	private void printArray(int a[]) {
		for(int val: a) {
			print(val + " ");
		}
		println();
	}
	
	public long to_long(int arr[]) {
		long num = 0;
		
		for(int i=0;i<64;i++) {
			if(arr[i] == 1) {
				num += (long)Math.pow(2,i);
			}
		}
		return num;
	}

	public int[] to_binary(long num) {
		int b[] = new int[64];
		
		int i=0;
		while(num > 0) {
			int rem = (int)(num % 2);
			b[i] = rem;
			num /= 2;
			i++;
		}
		
		return b;
	}
	
	public static void main(String args[]) throws IOException{
		new D().run();
	}
	
	private ArrayList<Integer> factors(int n, boolean include){
		ArrayList<Integer> factors = new ArrayList<>();
		if(n < 0)
			return factors;
		
		if(include) {
			factors.add(1);
			if(n > 1)
				factors.add(n);
		}
		
		int i = 2;
		for(;i*i<n;i++) {
			if(n % i == 0) {
				factors.add(i);
				factors.add(n / i);
			}
		}
		
		if(i * i == n) {
			factors.add(i);
		}
		
		return factors;
	}
	
	private ArrayList<Integer> PrimeFactors(int n) {
	    ArrayList<Integer> primes = new ArrayList<>();
	 
	    int i = 2;
	    while (i * i <= n) {
	      if (n % i == 0) {
	        primes.add(i);
	 
	        while (n % i == 0) {
	          n /= i;
	        }
	      }
	 
	      i++;
	    }
	 
	    if (n > 1) {
	      primes.add(n);
	    }
	 
	    return primes;
	  }
	
	private boolean isPrime(int n) {
		if(n == 0 || n == 1) {
			return false;
		}
		
		if(n % 2 == 0) {
			return false;
		}
		
		for(int i=3;i*i<=n;i+=2) {
			if(n % i == 0) {
				return false;
			}
		}
		
		return true;
	}

	private ArrayList<Integer> Sieve(int n){
		boolean bool[] = new boolean[n+1];
		Arrays.fill(bool, true);
		bool[0] = bool[1] = false;
		
		for(int i=2;i*i<=n;i++) {
			if(bool[i]) {
				int j = 2;
				while(i*j <= n) {
					bool[i*j] = false;
					j++;
				}
			}
		}
		
		ArrayList<Integer> primes = new ArrayList<>();
		for(int i=2;i<=n;i++) {
			if(bool[i])
				primes.add(i);
		}
		
		return primes;
	}
	
	private HashMap<Integer, Integer> addToHashMap(HashMap<Integer, Integer> map, int arr[]){
		for(int val: arr) {
			if(!map.containsKey(val)) {
				map.put(val, 1);
			}else {
				map.put(val, map.get(val) + 1);
			}
		}
		return map;
	}
	
	private int factorial(int n) {
		long fac = 1;
		for(int i=2;i<=n;i++) {
			fac *= i;
			fac %= mod;
		}
		return (int)(fac % mod);
	}

	private static int pow(int base,int exp){
		if(exp == 0){
			return 1;
		}else if(exp == 1){
			return base;
		}
		int a = pow(base,exp/2);
		a = ((a % mod) * (a % mod)) % mod;
		if(exp % 2 == 1) {
			a = ((a % mod) * (base % mod));
		}
		return a;
	}

	private static int gcd(int a,int b){
		if(a == 0){
			return b;
		}
		
		return gcd(b%a,a);
	}
	
	private static int lcm(int a,int b){
		return (a * b)/gcd(a,b);
	}
	
	private void run() throws IOException{
		fr = new FastReader();
		out = new BufferedOutputStream(System.out);
		solve();
		out.flush();
		out.close();
	}
	
	private static class FastReader{
		private static BufferedReader br; 
		private static StringTokenizer st;
		
		public FastReader() {
			br = new BufferedReader(new InputStreamReader(System.in));
			out = new BufferedOutputStream(System.out);
		}
		
		public String next() {
			while (st == null || !st.hasMoreElements()) 
			{ 
				try
				{ 
					st = new StringTokenizer(br.readLine()); 
				} 
				catch (IOException e) 
				{ 
					e.printStackTrace(); 
				} 
			} 
			return st.nextToken();
		}
		
		public String nextLine() { 
			String str = ""; 
			try
			{ 
				str = br.readLine(); 
			} 
			catch (IOException e) 
			{ 
				e.printStackTrace(); 
			} 
			return str; 
		}
		
		public int nextInt() {
			return Integer.parseInt(next());
		}
		
		public long nextLong() {
			return Long.parseLong(next());
		}
		
		public double nextDouble() {
			return Double.parseDouble(next());
		}
		 
		public char[] nextCharArray() {
			return next().toCharArray();
		}
		
		public int[] nextIntArray(int n) {
			int arr[] = new int[n];
			for(int i=0;i<n;i++) {
				arr[i] = nextInt();
			}
			return arr;
		}
		
		public long[] nextLongArray(int n) {
			long arr[] = new long[n];
			for(int i=0;i<n;i++) {
				arr[i] = nextLong();
			}
			return arr;
		}
		
		public String[] nextStringArray(int n) {
			String arr[] = new String[n];
			for(int i=0;i<n;i++) {
				arr[i] = next();
			}
			return arr;
		}
		
	}

	public static void print(Object str) {
        try {
            out.write(str.toString().getBytes());
        } catch (IOException e) {
            e.printStackTrace();
        }
    }
	
	public static void println(Object str) {
        try {
            out.write((str.toString() + "\n").getBytes());
        } catch (IOException e) {
            e.printStackTrace();
        }
    }
	
	public static void println() {
		println("");
	}
	
	public static void printArray(Object str[]){
		for(Object s : str) {
			try {
	            out.write(str.toString().getBytes());
	        } catch (IOException e) {
	            e.printStackTrace();
	        }
		}
	}
}