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.IOException;
import java.io.InputStream;
import java.io.InputStreamReader;
import java.io.PrintWriter;
import java.util.ArrayDeque;
import java.util.ArrayList;
import java.util.Arrays;
import java.util.HashMap;
import java.util.HashSet;
import java.util.PriorityQueue;
import java.util.StringTokenizer;
import java.util.TreeSet;

/*
 * To change this license header, choose License Headers in Project Properties.
 * To change this template file, choose Tools | Templates
 * and open the template in the editor.
 */
/**
 *
 * @author Andy Phan
 */
public class d {
    public static void main(String[] args) {
        FS in = new FS(System.in);
        PrintWriter out = new PrintWriter(System.out);
        
        long u = in.nextLong();
        long v = in.nextLong();
        if(u > v || (v-u)%2 == 1) {
            System.out.println(-1);
            return;
        }
        
        long[] arr = new long[3];
        arr[0] = u;
        long diff = v-u;
        while(diff != 0) {
            long curr = Long.lowestOneBit(diff);
            diff -= curr;
            curr >>= 1;
            if((arr[0]&curr) == 0) {
                arr[0] += curr;
                arr[1] += curr;
            } else {
                arr[1] += curr;
                arr[2] += curr;
            }
        }
        if(arr[0] == 0) {
            System.out.println(0);
        } else if(arr[1] == 0) {
            System.out.println(1);
            System.out.println(arr[0]);
        } else if(arr[2] == 0) {
            System.out.println(2);
            System.out.println(arr[0] + " " + arr[1]);
        } else {
            System.out.println(3);
            System.out.println(arr[0] + " " + arr[1] + " " + arr[2]);
        }
        out.close();
    }

    static class FS {

        BufferedReader in;
        StringTokenizer token;

        public FS(InputStream str) {
            in = new BufferedReader(new InputStreamReader(str));
        }

        public String next() {
            if (token == null || !token.hasMoreElements()) {
                try {
                    token = new StringTokenizer(in.readLine());
                } catch (IOException ex) {
                }
                return next();
            }
            return token.nextToken();
        }

        public int nextInt() {
            return Integer.parseInt(next());
        }
        
        public long nextLong() {
            return Long.parseLong(next());
        }
    }
}