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 Code1603 {

    public static void main(String args[]){
         Reader s = new Reader();
         long  u = s.nextLong();
         long  v = s.nextLong();

         if(u>v){
             System.out.println(-1);
             return;
         }


//        System.out.println(394957491645964024L +  101615898083182216L +  105025864704L);
//        System.out.println(394957491645964024L ^ 101615898083182216L ^ 105025864704L);


         int binu[] = new int[64];
         int binv[] = new int[64];
         long pow[]=  new long[64];
         pow[0] = 1;
        for (int i = 1; i < pow.length ; i++) {
            pow[i] = 2*pow[i-1];
        }
         int index = 0;

         while(u>0){
            binu[index++] = (int) (u%2);
            u = u/2;
         }
         index = 0;
        while(v>0){
            binv[index++] = (int) (v%2);
            v = v/2;
        }
//
//        for (int i = index-1; i >=0 ; i--) {
//            System.out.print(binu[i]+" ");
//        }
//        System.out.println();
//
//        for (int i = index-1; i >=0 ; i--) {
//            System.out.print(binv[i]+" ");
//        }
//        System.out.println();



        for (int i = index-1; i >0 ; i--) {
            if(binu[i]%2 == binv[i]%2){
                continue;
            }

            if(binu[i]%2 == 0){

                 binv[i] -= 1;
                 binv[i-1] += 2;

            }
            else {
                if(binv[i] == 0){

                    int pindex = i+1;
                    while (pindex<binv.length &&  binv[pindex] < 2){
                       // System.out.println(pindex + " " + binv[pindex]);
                        pindex++;
                    }
                    if(pindex == binv.length){
                        System.out.println(-1);
                        return;
                    }

                    binv[pindex] -= 2;
                    pindex--;
                    for (int j = pindex; j > i ; j--) {
                        binv[j] += 2;
                    }

                    binv[i] += 4;



                }

                binv[i] -= 1;
                binv[i-1] += 2;



            }
        }


        if(binu[0]%2 != binv[0]%2){
            System.out.println(-1);
            return;
        }

        int count = 0;
        StringBuilder sb = new StringBuilder();


        while (true) {
            long ans = 0;
            for (int i = index - 1; i >= 0; i--) {
                  if(binv[i] == 0){
                      continue;
                  }
                  binv[i] -= 1;
                  ans = ans + pow[i];
            }

            //System.out.println("ans " + ans);

            if(ans == 0){
              //  System.out.println("Break " +count );
                break;
            }
           sb.append(ans).append(" ");
            count++;
        }


        System.out.println(count);
        System.out.println(sb);


    }
    static class Reader {

        private InputStream mIs;
        private byte[] buf = new byte[1024];
        private int curChar;
        private int numChars;

        public Reader() {
            this(System.in);
        }

        public Reader(InputStream is) {
            mIs = is;
        }

        public int read() {
            if (numChars == -1) {
                throw new InputMismatchException();

            }
            if (curChar >= numChars) {
                curChar = 0;
                try {
                    numChars = mIs.read(buf);
                } catch (IOException e) {
                    throw new InputMismatchException();
                }
                if (numChars <= 0) {
                    return -1;
                }
            }
            return buf[curChar++];
        }

        public String nextLine() {
            int c = read();
            while (isSpaceChar(c)) {
                c = read();
            }
            StringBuilder res = new StringBuilder();
            do {
                res.appendCodePoint(c);
                c = read();
            } while (!isEndOfLine(c));
            return res.toString();
        }

        public String next() {
            int c = read();
            while (isSpaceChar(c)) {
                c = read();
            }
            StringBuilder res = new StringBuilder();
            do {
                res.appendCodePoint(c);
                c = read();
            } while (!isSpaceChar(c));
            return res.toString();
        }

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

        public long nextLong() {
            int c = read();
            while (isSpaceChar(c)) {
                c = read();
            }
            int sgn = 1;
            if (c == '-') {
                sgn = -1;
                c = read();
            }
            long res = 0;
            do {
                if (c < '0' || c > '9') {
                    throw new InputMismatchException();
                }
                res *= 10;
                res += c - '0';
                c = read();
            } while (!isSpaceChar(c));
            return res * sgn;
        }

        public int nextInt() {
            int c = read();
            while (isSpaceChar(c)) {
                c = read();
            }
            int sgn = 1;
            if (c == '-') {
                sgn = -1;
                c = read();
            }
            int res = 0;
            do {
                if (c < '0' || c > '9') {
                    throw new InputMismatchException();
                }
                res *= 10;
                res += c - '0';
                c = read();
            } while (!isSpaceChar(c));
            return res * sgn;
        }

        public boolean isSpaceChar(int c) {
            return c == ' ' || c == '\n' || c == '\r' || c == '\t' || c == -1;
        }

        public boolean isEndOfLine(int c) {
            return c == '\n' || c == '\r' || c == -1;
        }

    }

}