/*
 *   Copyright (c) 2024 Emon Thakur
 *   All rights reserved.
 */
#include<bits/stdc++.h>
using namespace std;
int a[200005],vulcnt[200005],depth[200005];
vector<int> g[200005];

void precal(int node,int par,int dep)
{
    if(a[node]) vulcnt[node]=1;
    depth[node] = dep;
    for(auto e:g[node])
    {
        if(e==par) continue;
        precal(e,node,dep+1);
    }
    for(auto e:g[node])
    {
        if(e==par) continue;
        vulcnt[node] += vulcnt[e];
    }
}

struct LCA{
    int dp[200005][20];
    void binarylifting(int node,int par)
    {
        dp[node][0] = par;
        for(int i=1;i<20;i++) dp[node][i] = dp[dp[node][i-1]][i-1]; 
        for(auto e:g[node])
        {
            if(e == par) continue;
            binarylifting(e,node);
        }
    }

    int kthparent(int node,int k)
    {
        for(int i=19;i>=0;i--)
        {
            if(k & (1<<i)) node = dp[node][i];
        }
        return node;
    }

    int lca(int u,int v)
    {
        if(depth[u] < depth[v]) swap(u,v);
        u = kthparent(u , depth[u]-depth[v]);
        if(u == v) return v;
        for(int i=19;i>=0;i--)
        {
            if(dp[u][i] == dp[v][i]) continue;
            u = dp[u][i];
            v = dp[v][i];
        }
        return dp[u][0];
    }
    int dist(int u,int v)
    {
        int lcaa = lca(u,v);
        return depth[u]-depth[lcaa] + depth[v]-depth[lcaa];
    }
    int nodeatdis(int u,int v,int d)
    {
        if(d <= depth[u]-depth[lca(u,v)]) return kthparent(u,d);
        return kthparent(v,dist(u,v)-d);
    }
}lca;

int main()
{
    int n; cin >> n;
    for(int i=1;i<=n;i++) cin >> a[i];
    for(int i=0;i<n-1;i++)
    {
        int u,v; cin >> u >> v;
        g[u].push_back(v);
        g[v].push_back(u);
    }
    precal(1,0,0);
    lca.binarylifting(1,0);
    int q; cin >> q;
    while(q--)
    {
        int c,p; cin >> c >> p;
        if(c==p) {cout<<"weee"<<endl; continue;}
        int dis = lca.dist(c,p);
        int x = lca.nodeatdis(c,p,(dis-1)/2);
        int y = lca.nodeatdis(c,p,((dis-1)/2)+1);
        if(depth[x]>depth[y])
        {
            if(vulcnt[x]) cout<<"oops"<<endl;
            else cout<<"weee"<<endl;
        }
        else 
        {
            if(vulcnt[1]-vulcnt[y]) cout<<"oops"<<endl;
            else cout<<"weee"<<endl;
        }
    }
}