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 PYTHON3):

Solution:

import math as m
def f1():
	Testcases=int(input())
	for i in range(0,Testcases):
		x=int(input())
		print(str(x-1)+str(" ")+str(1))

def f2():
	Testcases=int(input())
	for i in range(0,Testcases):
		n=int(input())
		array=[int(j) for j in input().split(" ")]
		answer=len(array)
		dict1=dict()
		for k in array:
			if(k in dict1):
				answer=answer-1
			else:
				dict1[k]=1
		print(answer)


def f4():
	array=[int(i) for i in input().split(" ")]
	u=array[0]
	v=array[1]
	if(u==v and v==0):
		print(0)
		return
	if(u==v):
		print(1)
		print(u)
		return
	if(u>v):
		print(-1)
		return
	if(u%2==0 and v%2!=0):
		print(-1)
		return 
	if(u%2!=0 and v%2==0):
		print(-1)
		return 
	x=(array[1]-array[0])//2
	if(u&x!=0):
		print(3)
		print(u,x,x)
	else:
		print(2)
		print(u+x,x)


def f3():
	Node=int(input())
	dict1=dict()
	edgeset=list()
	#lis1=list()
	for i in range(0,Node):
		edgeset.append(list())
		#list1.append(list())
	#print(edgeset)
	for i in range(0,Node-1):
		edge=input().split(" ")
		u=int(edge[0])
		v=int(edge[1])
		if(u<v):
			dict1[(u-1,v-1)]=0
		else:
			dict1[(v-1,u-1)]=0
		edgeset[u-1].append(v-1)
		edgeset[v-1].append(u-1)
	#	print(edgeset)

	#print(dict1)
	#print(edgeset)
	for i in range(0,len(edgeset)):
		for j in range(0,len(edgeset)):
			visited=[False]*len(edgeset)
			DFS(edgeset,i,j,dict1,visited)
			#print(i,j)
			#print(dict1)
	#print("----------------------------")
	
	list2=list()
	for x in dict1.items():
		list2.append((x[0][0],x[0][1],x[1]))
	#print(list2)
	list2.sort(key = lambda x: x[2])
	d=Node-2
	list1=list()
	for i in range(0,len(list2)):
		list1.append((list2[i][0],list2[i][1],d))
		d=d-1
	list1.sort(key= lambda x:x[0])
	for i in range(0,len(list1)):
		print(list1[i][2])

def DFS(edgeset,i,j,dict1,visited):
	visited[i]=True
	if(i==j):
		return True
	for vert in edgeset[i]:
		if(visited[vert]==False):
			X=DFS(edgeset,vert,j,dict1,visited)
			if(X==True):
				a,b=i,vert
				if(i>vert):
					b=i
					a=vert
				dict1[(a,b)]=dict1[(a,b)]+1
				return True
	return False

def BFS(edgeset,vert,j,dict1):
	Q=list()
	Q.append(vert)
	visited=[False]*len(edgeset)
	visited[vert]=True
	while(len(Q)!=0):
		v=Q.pop()
		#print("hiki!")
		if(v==j):
			return dict1
		for vertex in edgeset[v]:
				if(visited[vertex]==False):
					visited[vertex]=True
					a,b=0,0
					if(v<vertex):
						a=v
						b=vertex
					else:
						a=vertex
						b=v

					dict1[(a,b)]=dict1[(a,b)]+1
					Q.append(vertex)

	return dict1



if __name__ == '__main__':
	f4()