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_{i}, 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_{i}, which can also be only 0 or 1. You need to reach the goal of the game by using minimum number of operations.
-----Input-----
The first line contains an integer n (1 ≤ n ≤ 10^5). Each of the next n - 1 lines contains two integers u_{i} and v_{i} (1 ≤ u_{i}, v_{i} ≤ n; u_{i} ≠ v_{i}) meaning there is an edge between nodes u_{i} and v_{i}. 
The next line contains n integer numbers, the i-th of them corresponds to init_{i} (init_{i} is either 0 or 1). The following line also contains n integer numbers, the i-th number corresponds to goal_{i} (goal_{i} is either 0 or 1).
-----Output-----
In the first line output an integer number cnt, representing the minimal number of operations you perform. Each of the next cnt lines should contain an integer x_{i}, representing that you pick a node x_{i}.
-----Examples-----
Input
10
2 1
3 1
4 2
5 1
6 2
7 5
8 6
9 8
10 5
1 0 1 1 0 1 0 1 0 1
1 0 1 0 0 1 1 1 0 1
Output
2
4
7
from collections import defaultdict, deque, Counter, OrderedDict
from bisect import insort, bisect_right, bisect_left
import threading, sys

def main():
    n = int(input())
    adj = [[] for i in range(n + 1)]
    for i in range(n - 1):
        a, b = map(int, input().split())
        a, b = a - 1, b - 1
        adj[a].append(b)
        adj[b].append(a)
    init = [int(i) for i in input().split()]
    goal = [int(i) for i in input().split()]
    visited = [0] * n
    par = [[] for i in range(n)]

    def dfs(s, p):
        if visited[s]: return
        visited[s] = 1
        par[p].append(s)
        for i in adj[s]:
            dfs(i, s)

    dfs(0, 0)
    par[0] = par[0][1:]
    ans = []

    def dfs2(s, l, fo, fe):
        if l % 2 == 0:
            if fe % 2 == 1:
                init[s] = 1 - init[s]
        else:
            if fo % 2 == 1:
                init[s] = 1 - init[s]
        if init[s] != goal[s]:
            ans.append(s + 1)
            if l % 2:
                fo += 1
            else:
                fe += 1
        for j in par[s]:
            dfs2(j, l + 1, fo, fe)

    dfs2(0, 0, 0, 0)

    print(len(ans))
    print("\n".join(map(str, ans)))

def __starting_point():
    sys.setrecursionlimit(400000)
    threading.stack_size(40960000)
    thread = threading.Thread(target=main)
    thread.start()
__starting_point()
from collections import defaultdict, deque, Counter, OrderedDict
from bisect import insort, bisect_right, bisect_left
import threading, sys

def main():
    n = int(input())
    adj = [[] for i in range(n + 1)]
    for i in range(n - 1):
        a, b = map(int, input().split())
        a, b = a - 1, b - 1
        adj[a].append(b)
        adj[b].append(a)
    init = [int(i) for i in input().split()]
    goal = [int(i) for i in input().split()]
    visited = [0] * n
    par = [[] for i in range(n)]

    def dfs(s, p):
        if visited[s]: return
        visited[s] = 1
        par[p].append(s)
        for i in adj[s]:
            dfs(i, s)

    dfs(0, 0)
    par[0] = par[0][1:]
    ans = []

    def dfs2(s, l, fo, fe):
        if l % 2 == 0:
            if fe % 2 == 1:
                init[s] = 1 - init[s]
        else:
            if fo % 2 == 1:
                init[s] = 1 - init[s]
        if init[s] != goal[s]:
            ans.append(s + 1)
            if l % 2:
                fo += 1
            else:
                fe += 1
        for j in par[s]:
            dfs2(j, l + 1, fo, fe)

    dfs2(0, 0, 0, 0)

    print(len(ans))
    print("\n".join(map(str, ans)))

def __starting_point():
    sys.setrecursionlimit(400000)
    threading.stack_size(40960000)
    thread = threading.Thread(target=main)
    thread.start()
__starting_point()