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

public class DIV2D_Ehab_the_Xorcist {

    private static final Scanner SIN = new Scanner(new BufferedInputStream(System.in));
    private static final StreamTokenizer IN = new StreamTokenizer(new BufferedReader(new InputStreamReader(System.in)));
    private static final PrintWriter OUT = new PrintWriter(new OutputStreamWriter(System.out));

    long u, v;

    private void input() {
        u = SIN.nextLong();
        v = SIN.nextLong();
    }

    private void process() {
        Long delta = v - u;

        if (delta < 0) {
            OUT.println(-1);
        } else if (delta == 0 && u == 0) {
            OUT.println(0);
        } else {
            if (delta % 2 != 0) {
                OUT.println(-1);
            } else {
                StringBuilder out = new StringBuilder(1024);
                long number = 1;
                long collector = 0, remaing = 0;
                delta >>= 1;

                while (delta > 0) {
                    if ((delta & 1) == 1) {
                        if ((u & number) == 0) {
                            u |= number;
                            collector |= number;
                        } else {
                            collector |= number;
                            remaing |= number;
                        }
                    }

                    delta >>= 1;
                    number <<= 1;
                }

                out.append(u);

                if (collector > 0) {
                    out.append(" " + collector);
                }

                if (remaing > 0) {
                    out.append(" " + remaing);
                }

                OUT.println(out.toString().split(" ").length);
                OUT.println(out);
            }
        }
    }

    private void output() {
        OUT.flush();
    }

    private static int nextInt() {
        try {
            if (IN.nextToken() != StreamTokenizer.TT_EOF) {
                return (int) IN.nval;
            } else {
                throw new EOFException();
            }
        } catch (IOException e) {
            throw new RuntimeException(e);
        }
    }

    private static String nextStr() {
        try {
            if (IN.nextToken() != StreamTokenizer.TT_EOF) {
                return IN.sval;
            } else {
                throw new EOFException();
            }
        } catch (IOException e) {
            throw new RuntimeException(e);
        }
    }

    public static void main(String[] args) throws IOException {
        DIV2D_Ehab_the_Xorcist main = new DIV2D_Ehab_the_Xorcist();
        main.input();
        main.process();
        main.output();
    }
}