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>
using namespace std;

typedef long long ll;
typedef long double ld;
typedef pair<int,int> pii;
typedef vector<int> vi;
typedef vector<vi> vvi;
typedef vector<pii> vpii;
typedef pair<ll,ll> pll;
typedef vector<ll> vll;
typedef vector<vll> vvl;
typedef vector<pll> vpll; 
 
#define endl '\n' 
#define fast std::ios_base::sync_with_stdio(false);cin.tie(NULL);
#define pb push_back
#define mp make_pair

void setIO(string s) {
   freopen((s+".in").c_str(),"r",stdin);
   freopen((s+".out").c_str(),"w",stdout);
}
void solve(){
    int n;
    cin >> n;
    
    vector<vector<int>> g(n+1);
    for(int i =1;i<n;i++){
      int a,b;
      cin >> a >> b;
      g[a].pb(b);
      g[b].pb(a);
    }
    vector<int> initial(n+1);
    vector<int> final(n+1);
    for(int i=1;i<=n;i++)cin >> initial[i];
    for(int i =1;i<=n;i++) cin >> final[i];
   
    vector<int> vis(n+1,0);
    queue<vector<int>> q;
    q.push({1,0,0,0});
    vis[1]=1;
    int ans = 0;
    vector<int> nodes;
    while(q.size()){
      vector<int> u = q.front();
      q.pop();
      int nn = u[0];
      int val = initial[nn];
      int level = u[1];
      
      int ind = (level%2)+2;
      if(u[ind]==1)val = 1-initial[nn];
      if(val!=final[nn]){
         ans++;
         u[ind] = 1-u[ind];
         nodes.pb(nn);
      }
      for(auto neigh:g[nn]){
         if(!vis[neigh]){
            q.push({neigh,level+1,u[2],u[3]});
            vis[neigh]=1;
         }
      }
    }
    cout << ans << endl;
    for(auto u:nodes)cout << u << endl;
}
int main(){
   fast;
   //clock_t begin = clock();
   //setIO();
   ll tc=1;
   //cin>>tc;
   for(ll i=1;i<=tc;i++){
       //cout<<"Case #"<<i<<": ";
       solve();
   }
}

