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.*;

public class Solution {
    public void solve() {
        long xor = reader.nextLong();
        long sum = reader.nextLong();

        long[] a = find(xor, sum);
        if (a == null) {
            writer.println(-1);
            return;
        }

        writer.println(a.length);
        for (int i = 0; i < a.length; i++) {
            writer.print(a[i] + " ");
        }
    }

    private long[] find(long xor, long sum) {
        if (xor > sum || xor % 2 != sum % 2) return null;
        if (xor == sum) {
            return xor == 0 ? new long[]{} : new long[]{xor};
        }

        // sum = xor + 2 * and
        long and = (sum - xor) / 2;
        long a = 0, b = 0;

        for (int i = 0; i < 64; i++) {
            long bitXor = (xor >> i) & 1;
            long bitAnd = (and >> i) & 1;

            if (bitXor == 1 && bitAnd == 0) {
                a |= 1L << i;
                continue;
            }

            if (bitXor == 0 && bitAnd == 1) {
                a |= 1L << i;
                b |= 1L << i;
                continue;
            }

            if (bitXor == 1 && bitAnd == 1) {
                return new long[]{xor, and, and};
            }
        }

        return new long[]{a, b};
    }

    private InputReader reader;
    private PrintWriter writer;

    public Solution(InputReader reader, PrintWriter writer) {
        this.reader = reader;
        this.writer = writer;
    }

    public static void main(String[] args) {
        InputReader reader = new InputReader(System.in);
        PrintWriter writer = new PrintWriter(System.out);

        Solution solution = new Solution(reader, writer);
        solution.solve();

        writer.flush();
    }

    static class InputReader {
        private static final int BUFFER_SIZE = 1 << 20;

        private BufferedReader reader;
        private StringTokenizer tokenizer;

        public InputReader(InputStream stream) {
            reader = new BufferedReader(new InputStreamReader(stream), BUFFER_SIZE);
            tokenizer = null;
        }

        public String nextToken() {
            while (tokenizer == null || !tokenizer.hasMoreTokens()) {
                try {
                    tokenizer = new StringTokenizer(reader.readLine());
                } catch (IOException e) {
                    throw new RuntimeException();
                }
            }
            return tokenizer.nextToken();
        }

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

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