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;

int n, i, u, v;
vector<vector<int>> graph(100005);
int value[100005];
int goal[100005];
vector<int> fs;

void flip(int root, int ancestor, bool f) {
    if (f) value[root] = value[root] == 0 ? 1 : 0;

    for (int sibling: graph[root]) {
        if (sibling == ancestor) continue;
        flip(sibling, root, !f);
    }
}

void dfs(int root, int ancestor) {
    if (value[root] != goal[root]) {
        flip(root, ancestor, 1);
        fs.push_back(root);
    }

    for(int sibling: graph[root]) {
        if (sibling == ancestor) continue;
        dfs(sibling, root);
    }
}

void solve() {
    cin >> n;

    for (i = 0; i < n - 1; ++i) {
        cin >> u >> v;
        graph[u].push_back(v);
        graph[v].push_back(u);
    }

    for (i = 1; i <= n; ++i) cin >> value[i];
    for (i = 1; i <= n; ++i) cin >> goal[i];

    dfs(1, -1);

    cout << fs.size() << "\n";

    for (auto fls: fs) {
        cout << fls << "\n";
    }
}


int main() {
    ios_base::sync_with_stdio(false);
    cin.tie(0);
    
    solve();
    
    return 0;
};