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 math
from os import startfile
import random 
from queue import Queue
import time 
import heapq
import sys 
n=int(input())
adj={}
for i in range(n-1):
  a,b=list(map(int,input().split()))
  if a not in adj:
    adj[a]=[] 
  if b not in adj:
    adj[b]=[] 
  adj[a].append(b),adj[b].append(a)
val=[0]+list(map(int,input().split()))
f=[0]*(n+1)
ans=[0]+list(map(int,input().split()))
p=[0]*(n+1)
seen=set([])
q=[]
def dfs(v,adj,seen):
  
  a=0
  g=p[p[v]] 
  seen.add(v)
  if f[g]:
    val[v]^=1
    f[v]^=1
  if val[v]!=ans[v]:
    val[v]^=1
    f[v]^=1
    a+=1
    q.append(v)
  
  for u in adj[v]:
    
    if u not in seen:
      p[u]=v

      a+=dfs(u,adj,seen)
  return a 
print(dfs(1,adj,seen))
for e in q:
  print(e)
  
    


  


