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 copy, collections
from queue import Queue
from sys import stdin, stdout

def read():
    return stdin.readline().rstrip()

def readints():
    return [int(x) for x in read().split()]

if __name__ == '__main__':

    n = readints()[0]
    edges = collections.defaultdict(list)
    for i in range(n - 1):
        a, b = readints()
        edges[a].append(b)
        edges[b].append(a)

    init = readints()
    goal = readints()

    solution = []

    queue = [(1, [0, 0])]
    seen = [False] * n

    while len(queue) > 0:

        node, history = queue.pop(0)
        seen[node-1] = True

        # print("At node", node, 'hostiry=', history)
        # print(init)
        # print(goal)
        # Apply history (slow)

        if history[1] % 2 == 1:
            #print("Applying grandparent flip")
            init[node-1] = ~init[node-1] & 1
            #print(init)
            #print(goal)


        didflip = False
        if goal[node-1] != init[node-1]:
            #print("Flipping node", node)
            init[node-1] = ~init[node-1] & 1
            solution.append(node)
            didflip = True
        else:
            pass


        gp = history[1]
        history[1] = history[0]
        if didflip:
            gp = gp + 1
        gp = gp % 2
        history[0] = gp

        for next in edges[node]:
            if not seen[next-1]:
                seen[next-1] = True
                queue.append([next, copy.deepcopy(history)])


    print(len(solution))
    for v in solution:
        print(v)
