spoj cot3

//misaka will carry me to master
#include <iostream>
#include <cstdio>
#include <cstring>
#include <cmath>
#include <utility>
#include <cassert>
#include <algorithm>
#include <vector>
#include <functional>
#include <numeric>
#include <set>
#include <map>

#define ll long long
#define lb long double
#define sz(vec) ((int)(vec.size()))
#define all(x) x.begin(), x.end()
#define pb push_back
#define mp make_pair

const lb eps = 1e-9;
const ll mod = 1e9 + 7, ll_max = 1e18;
//const ll mod = (1 << (23)) * 119 +1;
const int MX = 2e5 +10, int_max = 0x3f3f3f3f;

using namespace std;

//negative trust
//so i need a trie that does
//xor all and max
//easiest is a push/pull implicit segtree

const int NN = MX*20;

char flag[NN];
int lc[NN], rc[NN], tag[NN];
int root[MX];
int xum[MX], grundy[MX];
int color[MX];
vector<int> adj[MX];

int n;
const int LG = 20, s = (1 << LG);

#define lsb(x) (x&(-x))

void push(int k, int a){
    if(tag[k]){
        if(a&tag[k]) swap(lc[k], rc[k]);
        if(lc[k]) tag[lc[k]] ^= tag[k];
        if(rc[k]) tag[rc[k]] ^= tag[k];
    }
    tag[k] = 0;
}

void pull(int k){
    if(flag[lc[k]] && flag[rc[k]]){
        flag[k] = 1;
    }
}

void dup(int& k){
    static int ind = 0;
    if(!k)
        k = ++ind;
}

void U(int p, int &k, int L, int R){
    dup(k);
    if(L + 1 == R){
        assert(L == p);
        //cout << "wave\n";
        flag[k] = 1;
        return ;
    }

    int mid = (L + R)/2;
    push(k, lsb(mid));

    if(p < mid) U(p, lc[k], L, mid);
    else U(p, rc[k], mid, R);
    pull(k);
}

void merge(int& k1, int k2, int d){
    if(min(k1, k2) == 0){
        k1 ^= k2;
        return ;
    }
    if(d == 0){
        return ;
    }
    push(k1, (1 << (d-1))); push(k2, (1 << (d-1)));
    merge(lc[k1], lc[k2], d-1);
    merge(rc[k1], rc[k2], d-1);
    pull(k1);
}

int mex(int k, int L, int R){
    if(L + 1 == R) return L;
    int mid = (L + R)/2;
    push(k, lsb(mid));
    if(flag[lc[k]]) return mex(rc[k], mid, R);
    else return mex(lc[k], L, mid);
}



void dfs(int u, int p){
    for(int v : adj[u]){
        if(v == p) continue;
        dfs(v, u);
        xum[u] ^= grundy[v];
    }
    if(color[u] == 0){
        U(xum[u], root[u], 0, s);
    }else{
        dup(root[u]);
    }
    for(int v : adj[u]){
        if(v == p) continue;
        if(root[v]){
            tag[root[v]] ^= xum[u] ^ grundy[v];
            merge(root[u], root[v], LG); //i hope
            //cout << "new root " << root[u] << "\n";
        }
    }
    grundy[u] = mex(root[u], 0, s);
}

vector<int> ans;
void dfs2(int u, int p, int tot){
    tot ^= xum[u];
    if(tot == 0 && color[u] == 0){
        ans.pb(u);
    }
    for(int v : adj[u]){
        if(v != p){
            dfs2(v, u, tot^grundy[v]);
        }
    }
}

void solve(){
    cin >> n;
    for(int i = 1; i<=n; i++){
        cin >> color[i];
    }
    for(int i = 1; i<n; i++){
        int a, b;
        cin >> a >> b;
        adj[a].pb(b);
        b[adj].pb(a);
    }
    dfs(1, 0);
    //for(int i = 1; i<=n; i++){
        //cout << grundy[i] << " " ;
    //} cout << "\n";
    //for(int i = 1; i<=n; i++){
        //cout << xum[i] << " " ;
    //} cout << "\n";


    if(grundy[1] == 0){
        cout << "-1\n";
    }else{
        dfs2(1, 0, 0);
        sort(all(ans));
        for(int x : ans){
            cout << x << "\n";
        }
    }
}

int main(){
  cin.tie(0) -> sync_with_stdio(0);

  int T = 1;
  //cin >> T;
  while(T--){
        solve();
  }
  return 0;
}