Iahub is very proud of his recent discovery, propagating trees. Right now, he invented a new tree, called xor-tree. After this new revolutionary discovery, he invented a game for kids which uses xor-trees.

The game is played on a tree having *n* nodes, numbered from 1 to *n*. Each node *i* has an initial value *init*<sub class="lower-index">*i*</sub>, which is either 0 or 1. The root of the tree is node 1.

One can perform several (possibly, zero) operations on the tree during the game. The only available type of operation is to pick a node *x*. Right after someone has picked node *x*, the value of node *x* flips, the values of sons of *x* remain the same, the values of sons of sons of *x* flips, the values of sons of sons of sons of *x* remain the same and so on.

The goal of the game is to get each node *i* to have value *goal*<sub class="lower-index">*i*</sub>, which can also be only 0 or 1. You need to reach the goal of the game by using minimum number of operations.
The first line contains an integer *n* (1 ≤ *n* ≤ 10<sup class="upper-index">5</sup>). Each of the next *n* - 1 lines contains two integers *u*<sub class="lower-index">*i*</sub> and *v*<sub class="lower-index">*i*</sub> (1 ≤ *u*<sub class="lower-index">*i*</sub>, *v*<sub class="lower-index">*i*</sub> ≤ *n*; *u*<sub class="lower-index">*i*</sub> ≠ *v*<sub class="lower-index">*i*</sub>) meaning there is an edge between nodes *u*<sub class="lower-index">*i*</sub> and *v*<sub class="lower-index">*i*</sub>. 

The next line contains *n* integer numbers, the *i*-th of them corresponds to *init*<sub class="lower-index">*i*</sub> (*init*<sub class="lower-index">*i*</sub> is either 0 or 1). The following line also contains *n* integer numbers, the *i*-th number corresponds to *goal*<sub class="lower-index">*i*</sub> (*goal*<sub class="lower-index">*i*</sub> is either 0 or 1).
import java.util.ArrayList;
import java.util.HashSet;
import java.util.Scanner;
import java.util.Stack;


public class Main {

	public static void main(String[] args) {
		// TODO Auto-generated method stub
		Scanner console = new Scanner(System.in);
		
		int n = console.nextInt();
		
		class XorNode {
			public int value;
			public int targetValue;
			public int idx;
			public int flipped;
			public ArrayList<XorNode> children;
			public ArrayList<XorNode> realChildren;
			
			public XorNode(int idx){
				this.idx = idx;
				this.children = new ArrayList<XorNode>();
				this.realChildren = new ArrayList<XorNode>();
			}
		}
		
		XorNode[] treeNodeList = new XorNode[n];
		
		for (int i=0; i<n; i++){
			treeNodeList[i] = new XorNode(i);
		}
		
		console.nextLine();
		int[] startNodes = new int[n-1];
		int[] endNodes = new int[n-1];
		boolean startContainsDups = false;
		HashSet<Integer> dupChecker = new HashSet<Integer>();
		for (int i=0; i<n - 1; i++){
			String[] inputs = console.nextLine().split(" ");
			startNodes[i] = Integer.parseInt(inputs[1]) - 1;
			endNodes[i] = Integer.parseInt(inputs[0]) - 1;
			if(dupChecker.contains(Integer.parseInt(inputs[1]) - 1)){
				startContainsDups = true;
			} else {
				dupChecker.add(Integer.parseInt(inputs[1]) - 1);
			}
		}
		
		if(startContainsDups){
			for(int i=0, l=startNodes.length; i<l; i++){
				treeNodeList[startNodes[i]].children.add(treeNodeList[endNodes[i]]);
			}
		} else {
			for(int i=0, l=startNodes.length; i<l; i++){
				treeNodeList[endNodes[i]].children.add(treeNodeList[startNodes[i]]);
			}
		}
		

		String[] initialValues = console.nextLine().split(" ");
		String[] targetValues = console.nextLine().split(" ");
		
		for (int i=0; i<n; i++){
			treeNodeList[i].value = Integer.parseInt(initialValues[i]);
			treeNodeList[i].targetValue = Integer.parseInt(targetValues[i]);
		}
		
		for (XorNode node : treeNodeList){
			for (XorNode childNode : node.children){
				for (XorNode skippedChildNode : childNode.children){
					node.realChildren.add(skippedChildNode);
				}
			}
		}
		
		Stack<XorNode> stack = new Stack<XorNode>();
		stack.push(treeNodeList[0]);
		
		for(int i=0; i<treeNodeList[0].children.size(); i++){
			stack.push(treeNodeList[0].children.get(i));
		}

		ArrayList<Integer> flips = new ArrayList<Integer>();
		
		while(!stack.empty()){
			XorNode node = stack.pop();
//			System.out.println("LOOKING AT " + node.idx + " with flips " + node.flipped + " and val " + node.value + " and target value " + node.targetValue);
			if((node.flipped % 2 == 0 && node.value != node.targetValue) || (node.flipped % 2 == 1 && node.value == node.targetValue)){
//				System.out.println("NEED TO FLIP " + node.idx);
				flips.add(node.idx);
				for(int i=0, l=node.realChildren.size(); i<l; i++){
					node.realChildren.get(i).flipped = node.flipped + 1;
					stack.push(node.realChildren.get(i));
				}
			} else {
				for(int i=0, l=node.realChildren.size(); i<l; i++){
					node.realChildren.get(i).flipped = node.flipped;
					stack.push(node.realChildren.get(i));
				}
			}
		}
		
		System.out.println(flips.size());
		for(int idx : flips){
			System.out.println(idx + 1);
		}
	}
	
	

}