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

public class D {
	
	public static boolean DEBUG = true;
	
    public static void main(String[] args) throws IOException {
    	FastScanner scan;
    	PrintWriter out;
    	if (DEBUG) {
    		scan = new FastScanner();
        	out = new PrintWriter(System.out);
    	}
    	else {
        	scan = new FastScanner("test.in");
        	out = new PrintWriter(new BufferedWriter(new FileWriter("test.out")));
    	}
        
        long u = scan.nextLong();
        long v = scan.nextLong();

        if(u > v || (v-u)%2 == 1) System.out.println(-1);
        else {
            ArrayList<Long> al = new ArrayList<Long>();

            al.add(u);

            String binString = Long.toBinaryString(v-u);
            for(int i=0; i<binString.length(); i++) {
                if(binString.charAt(i) == '0') continue;
                long l = (long)Math.pow(2,binString.length()-i-2);

                boolean found = false;
                for(int j=0; j<al.size(); j++) {
                    if((al.get(j) & l) == 0) {
                        al.set(j, al.get(j) + l);
                        found = true;
                    
                        break;
                    }
                }

                if(!found) {
                    al.add(l);
                }

                found = false;
                for(int j=0; j<al.size(); j++) {
                    if((al.get(j) & l) == 0) {
                        al.set(j, al.get(j) + l);
                        found = true;
                    
                        break;
                    }
                }

                if(!found) {
                    al.add(l);
                }
            }

            if(al.size() == 1 && al.get(0) == 0) System.out.println(0);
            else {
                boolean printed = false;

                System.out.println(al.size());
                for(long i : al) {
                    if(printed) System.out.print(" " + i);
                    else System.out.print(i);

                    printed = true;
                }
            }


        }

        
        out.close();
    }

    public static long log2(long n) {
        return (long)(Math.log(n)/Math.log(2));
    }

    public static String turnBase2(long n) {
        String ret = "";
        while(n != 0) {
            ret = (n%2) + ret;
            n /= 2;
        }

        return ret;
    }

    public static class FastScanner {
        BufferedReader br;
        StringTokenizer st;

        public FastScanner(String s) {
            try {
                br = new BufferedReader(new FileReader(s));
            } catch (FileNotFoundException e) {
                e.printStackTrace();
            }
        }

        public FastScanner() {
            br = new BufferedReader(new InputStreamReader(System.in));
        }

        String nextToken() {
            while (st == null || !st.hasMoreElements()) {
                try {
                    st = new StringTokenizer(br.readLine());
                } catch (IOException e) {
                    e.printStackTrace();
                }
            }
            return st.nextToken();
        }

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

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

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

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