#include <bits/stdc++.h>

using namespace std;

using u32=unsigned int;
using i64=long long;
using u64=unsigned long long;
using db=double;
using vi=vector<int>;
using pii=pair<int,int>;

template<typename T>
T read(){
    T x=0,f=0;char ch=getchar();
    while(!isdigit(ch)) f|=(ch=='-'),ch=getchar();
    while(isdigit(ch)) x=x*10+(ch-'0'),ch=getchar();
    return f?-x:x;
}

#define rdi read<int>
#define rdi64 read<i64>
#define fi first
#define se second
#define pb push_back

const int N=3e5+10,MOD=998244353;

#define lson (t[nw].ls)
#define rson (t[nw].rs)
#define mid ((l+r)>>1)
struct SGT{
    struct Node{
        int ls,rs;
        i64 sp,sv,s,mu;
    }t[N*60];
    int tot;
    int new_n(){
        t[++tot]={0,0,0,0,0,1};
        return tot;
    }
    void apply(int &nw,i64 v){
        if(!nw) nw=new_n();
        t[nw].sp=t[nw].sp*v%MOD;
        t[nw].s=t[nw].s*v%MOD;
        t[nw].mu=t[nw].mu*v%MOD;
    }
    void pushdown(int nw){
        if(t[nw].mu!=1){
            if(lson) apply(lson,t[nw].mu);
            if(rson) apply(rson,t[nw].mu);
            t[nw].mu=1;
        }
    }
    void pushup(int nw){
        t[nw].sp=(t[lson].sp+t[rson].sp)%MOD;
        t[nw].sv=(t[lson].sv+t[rson].sv)%MOD;
        t[nw].s=(t[lson].s+t[rson].s)%MOD;
    }
    void merge(int &nw,int nw1,int l,int r,i64 &s1,i64 &s2){
        if(!nw&&!nw1) return;
        if(!nw){
            nw=nw1,s2=(s2+t[nw].sp)%MOD;
            apply(nw,s1);
            return;
        }
        if(!nw1){
            s1=(s1+t[nw].sp)%MOD;
            apply(nw,1+s2);
            return;
        }
        if(l==r){
            i64 p=(t[nw].sp+(s1+t[nw].sp)*(s2+t[nw1].sp)-s1*s2)%MOD;
            s1=(s1+t[nw].sp)%MOD,s2=(s2+t[nw1].sp)%MOD;
            t[nw].sp=p,t[nw].s=p*t[nw].sv%MOD;
            return;
        }
        pushdown(nw),pushdown(nw1);
        merge(rson,t[nw1].rs,mid+1,r,s1,s2);
        merge(lson,t[nw1].ls,l,mid,s1,s2);
        pushup(nw);
    }
    void set(int &nw,int l,int r,int x,i64 v){
        if(!nw) nw=new_n();
        if(l==r){
            t[nw].sp=1,t[nw].sv=t[nw].s=v;
            return;
        }
        pushdown(nw);
        if(x<=mid) set(lson,l,mid,x,v);
        else set(rson,mid+1,r,x,v);
        pushup(nw);
    }
}t;
#undef lson
#undef rson
#undef mid

int n;
int a[N];
vi e[N];

int raw[N],tot;
void discrete(){
    for(int i=1;i<=n;i++)
        raw[++tot]=a[i];
    sort(raw+1,raw+tot+1),tot=unique(raw+1,raw+tot+1)-raw-1;
    for(int i=1;i<=n;i++)
        a[i]=lower_bound(raw+1,raw+n+1,a[i])-raw;
}

const int i2=(MOD+1)/2;

int rt[N];
i64 pw,ans;
void dfs(int x,int fa){
    t.set(rt[x],1,tot,a[x],raw[a[x]]);
    for(auto y:e[x]){
        if(y==fa) continue;
        dfs(y,x);
        i64 s1=0,s2=0;
        t.merge(rt[x],rt[y],1,tot,s1,s2);
        t.apply(rt[x],i2);
    }
    ans+=t.t[rt[x]].s*(fa?i2:1)%MOD*pw%MOD;
}

int main(){
    n=rdi();
    for(int i=1;i<=n;i++)
        a[i]=rdi();
    for(int i=1;i<n;i++){
        int x=rdi(),y=rdi();
        e[x].pb(y),e[y].pb(x);
    }
    pw=1;
    for(int i=1;i<n;i++)
        pw=pw*2%MOD;
    discrete();
    dfs(1,0);
    ans=(ans%MOD+MOD)%MOD;
    cout<<ans<<endl;
    return 0;
}