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).
#include <bits/stdc++.h>
const int MAX = 1e5 + 5;
using namespace std;
vector<int> adj[MAX];
int init[MAX];
int goal[MAX];
vector<int> result;
using namespace std;
void dfs(int nums,int prev,int even_times,int odd_times,int level){
    int cur;
    if (level%2)
        cur=(init[nums]+odd_times)%2;
    else
        cur=(init[nums]+even_times)%2;
    if(cur!=goal[nums]){
        if (level%2){
            odd_times+=1;
        }
        else
            even_times+=1;
        result.push_back(nums);
    }
    for ( auto x: adj[nums]){
        if(x==prev)
            continue;
        dfs(x,nums,even_times,odd_times,level+1);
    }

}


int main()
{
    int n;
    cin>>n;
    for (int i=0;i<n-1;i++){
        int a,b;
        cin>>a>>b;
        adj[a].push_back(b);
        adj[b].push_back(a);
    }
    for (int i=1;i<=n;i++){
        int d;
        cin>>d;
        init[i]=d;
    }
    for (int i=1;i<=n;i++){
        int d;
        cin>>d;
        goal[i]=d;
    }
    dfs(1,-1,0,0,0);
    cout<<result.size()<<endl;
    for (auto x : result)
    {
        cout << x << "\n";
    }

    return 0;
}




