// Words are flowing out like endless rain into a paper cup,
// They slither while they pass, they slip away across the universe
// Pools of sorrow, waves of joy are drifting through my opened mind,
// Possessing and caressing me.
// Jai guru de va om
// Nothing's gonna change my world,
// Nothing's gonna change my world,
//
// Nothing's gonna change my world,
// Nothing's gonna change my world,
//
// Images of broken light which dance before me like a million eyes,
// That call me on and on across the universe,
// Thoughts meander like a restless wind inside a letter box they
// Tumble blindly as they make their way
// Across the universe
// Jai guru de va om
// Nothing's gonna change my world,
// Nothing's gonna change my world,
//
// Nothing's gonna change my world,
// Nothing's gonna change my world,
//
// Sounds of laughter shades of earth are ringing
// Through my open views inciting and inviting me
// Limitless undying love which shines around me like a
// Million suns, it calls me on and on
// Across the universe
// Jai guru de va om
// Nothing's gonna change my world,
// Nothing's gonna change my world,
//
// Nothing's gonna change my world,
// Nothing's gonna change my world,
//
// Jai guru de va

#pragma GCC optimize(3)
#pragma GCC target("avx")
#pragma GCC target("avx,avx2")
#pragma GCC optimize("Ofast")
#pragma GCC optimize("inline")
#pragma GCC optimize("-fgcse")
#pragma GCC optimize("-fgcse-lm")
#pragma GCC optimize("-fipa-sra")
#pragma GCC optimize("-ftree-pre")
#pragma GCC optimize("-ftree-vrp")
#pragma GCC optimize("-fpeephole2")
#pragma GCC optimize("-ffast-math")
#pragma GCC optimize("-fsched-spec")
#pragma GCC optimize("unroll-loops")
#pragma GCC optimize("-falign-jumps")
#pragma GCC optimize("-falign-loops")
#pragma GCC optimize("-falign-labels")
#pragma GCC optimize("-fdevirtualize")
#pragma GCC optimize("-fcaller-saves")
#pragma GCC optimize("-fcrossjumping")
#pragma GCC optimize("-fthread-jumps")
#pragma GCC optimize("-funroll-loops")
#pragma GCC optimize("-fwhole-program")
#pragma GCC optimize("Ofast,fast-math")
#pragma GCC optimize("-freorder-blocks")
#pragma GCC optimize("-fschedule-insns")
#pragma GCC optimize("inline-functions")
#pragma GCC optimize("-ftree-tail-merge")
#pragma GCC optimize("-fschedule-insns2")
#pragma GCC optimize("-fstrict-aliasing")
#pragma GCC optimize("-fstrict-overflow")
#pragma GCC optimize("-falign-functions")
#pragma GCC optimize("-fcse-skip-blocks")
#pragma GCC optimize("-fcse-follow-jumps")
#pragma GCC optimize("-fsched-interblock")
#pragma GCC optimize("-fpartial-inlining")
#pragma GCC optimize("no-stack-protector")
#pragma GCC optimize("-freorder-functions")
#pragma GCC optimize("-findirect-inlining")
#pragma GCC optimize("-fhoist-adjacent-loads")
#pragma GCC optimize("-frerun-cse-after-loop")
#pragma GCC optimize("inline-small-functions")
#pragma GCC optimize("-finline-small-functions")
#pragma GCC optimize("-ftree-switch-conversion")
#pragma GCC optimize("-foptimize-sibling-calls")
#pragma GCC optimize("-fexpensive-optimizations")
#pragma GCC optimize("-funsafe-loop-optimizations")
#pragma GCC optimize("inline-functions-called-once")
#pragma GCC optimize("-fdelete-null-pointer-checks")
#pragma GCC optimize(2)
#include<bits/stdc++.h>
//#include<iostream>
//#include<string>
//#include<cmath>
//#include<cstdio>
//#include<cctype>
//#include<cstring>
//#include<iomanip>
//#include<cstdlib>
//#include<ctime>
//#include<set>
//#include<map>
//#include<utility>
//#include<queue>
//#include<vector>
//#include<stack>
//#include<sstream>
//#include<algorithm>
using namespace std;
/*=====================================================================*/
#define ll long long
#define int ll
#define pii pair<int,int>
#define vi vector<int>
#define vii vector<pii>
#define pdd pair<double,double>
#define ull unsigned long long
#define pb push_back
#define rep(i,n) for(int i=0;i<(int)(n);++i)
#define all(s) (s).begin(),(s).end()
#define repd(i,n) for(int i=(int)(n)-1;i>=0;--i)
#define forr(i,a,b,c) for(int i=(int)(a);i<=(int)(b);i+=(int)(c))
#define forn(i,p,n) for(int i=(int)(p);i<=(int)(n);++i)
#define ford(i,p,n) for(int i=(int)(n);i>=(int)(p);--i)
#define foreach(i,c) for(__typeof(c.begin())i=(c.begin());i!=(c).end();++i)
#define INF 0x3f3f3f3f
#define PI acos(-1)
#define Endl(x) cout<<x<<endl;
#define Blank(x) cout<<x<<" ";
#define modcg(x) if(x>=mod)x-=mod;
#define modcl(x) if(x<0)x+=mod;
#define lowbit(x) x&(-x)
/*=====================================================================*/
string int_to_string(ll n)
{
	string s="";
	while(n)
	{
		ll now=n%10;
		s+=now+'0';
		n/=10;
	}
	reverse(s.begin(),s.end());
	return s;
}
ll string_to_int(string s)
{
	ll n=0;
	rep(i,s.size())
	{
		n*=10;
		n+=s[i]-'0';
	}
	return n;
}
mt19937 GeN(chrono::system_clock::now().time_since_epoch().count());
int Rand(int l,int r)
{
	uniform_int_distribution<>RAND1(l,r);
	return RAND1(GeN);
}
struct Fastmod
{
	int mod,b;
	typedef __int128 lll;
	void init(int m)
	{
		mod=m;
		b=((lll)1<<64)/mod;
	}
	int operator()(ull a)
	{
		int q=((lll)a*b)>>64,r=a-q*mod;
		modcg(r);
		return r;
	}
}MOD;
int mul(int a,int b)
{
	return MOD(a*b);
}
/*======================================================================*/
const int dx[]={-1,0,1,0};
const int dy[]={0,-1,0,1};
const int month[2][12]={{31,28,31,30,31,30,31,31,30,31,30,31},{31,29,31,30,31,30,31,31,30,31,30,31}};
//think twice,code once
//think once,debug forever
const int MAXN=3e5+10,mod=998244353,inv2=499122177;
struct SegT
{
	struct node
	{
		int ls=0,rs=0;
		int val1=0,val2=0;
		int tag=1;
	}seg[MAXN<<5];
	int head;
	void push_up(int now)
	{
		seg[now].val1=seg[seg[now].ls].val1+seg[seg[now].rs].val1;modcg(seg[now].val1);
		seg[now].val2=seg[seg[now].ls].val2+seg[seg[now].rs].val2;modcg(seg[now].val2);
	}
	void update(int &now,int l,int r,int down,int val)
	{
		if(!now)
		{
			now=++head;
		}
		if(l==r)
		{
			seg[now].val1+=val;
			modcg(seg[now].val1);
//			cout<<val<<" "<<down<<endl;
			seg[now].val2+=mul(val,down);
			modcg(seg[now].val2);
//			cout<<seg[now].val2<<endl;
			return;
		}
		int mid=(l+r)>>1;
		if(down<=mid)
		{
			update(seg[now].ls,l,mid,down,val);
		}
		else
		{
			update(seg[now].rs,mid+1,r,down,val);
		}
		push_up(now);
	}
	int qurey(int now,int l,int r,int down)
	{
		if(l==r)
		{
			return seg[now].val1;
		}
		int mid=(l+r)>>1;
		if(down<=mid)
		{
			return qurey(seg[now].ls,l,mid,down);
		}
		else
		{
			return qurey(seg[now].rs,mid+1,r,down);
		}
	} 
	void add_tag(int now,int val)
	{
		seg[now].tag=mul(seg[now].tag,val);
		seg[now].val1=mul(seg[now].val1,val);
		seg[now].val2=mul(seg[now].val2,val);
	}
	void push_down(int now)
	{
		if(seg[now].tag!=1)
		{
			if(seg[now].ls)
			{
				add_tag(seg[now].ls,seg[now].tag);
			}
			if(seg[now].rs)
			{
				add_tag(seg[now].rs,seg[now].tag);
			}
			seg[now].tag=1;
		}
	}
	int sum1=0,sum2=1;
	int merge(int x,int y,int l,int r)
	{
//		cout<<sum1<<" "<<sum2<<endl;
		if(!y)
		{
			sum1+=seg[x].val1;modcg(sum1);
//			cout<<x<<" "<<sum1<<" "<<seg[x].val1<<endl;
			add_tag(x,sum2);
			return x;
		}
		if(!x)
		{
			sum2+=seg[y].val1;modcg(sum2);
//			cout<<sum1<<endl;
			add_tag(y,sum1);
			return y;
		}
		if(l==r)
		{
//			cout<<x<<" "<<y<<endl;
//			int p=seg[x].val1,q=seg[y].val1;
//			seg[x].val1=mul(p,sum2)+mul(q,sum1)+mul(p,q);modcg(seg[x].val1);modcg(seg[x].val1); 
//			seg[x].val2=mul(seg[x].val1,l);
//			sum1+=p,sum2+=q;modcg(sum1);modcg(sum2);
			sum1+=seg[x].val1,sum2+=seg[y].val1;modcg(sum1);modcg(sum2);
			seg[x].val1=mul(seg[x].val1,sum2)+mul(seg[y].val1,sum1)-mul(seg[x].val1,seg[y].val1);modcg(seg[x].val1);modcl(seg[x].val1);
			seg[x].val2=mul(seg[x].val1,l);
			return x;
		}
		push_down(x),push_down(y);
		int mid=(l+r)>>1;
		seg[x].rs=merge(seg[x].rs,seg[y].rs,mid+1,r);
		seg[x].ls=merge(seg[x].ls,seg[y].ls,l,mid);
		push_up(x);
		return x;
	}
}T;
int n;
int a[MAXN];
int root[MAXN];
vi v[MAXN];
int p2[MAXN];
int ans=0;
int sz[MAXN];
void dfs(int now,int fa)
{
	T.update(root[now],1,1e9,a[now],1);
//	cout<<" "<<T.seg[root[now]].val1<<T.seg[root[now]].val2<<endl;
	sz[now]=1;
	for(int u:v[now])
	{
		if(u==fa)
		{
			continue;
		}
		dfs(u,now);
		sz[now]+=sz[u];
		T.sum1=0,T.sum2=p2[sz[u]-1];
		root[now]=T.merge(root[now],root[u],1,1e9);
	}
//	forn(i,1,n)
//	{
//		cout<<T.qurey(root[now],1,1e9,a[i])<<" ";
//	}
//	cout<<endl;
//	forn(i,1,T.head)
//	{
//		cout<<T.seg[i].ls<<" "<<T.seg[i].rs<<" "<<T.seg[i].val1<<" "<<T.seg[i].val2<<endl;
//	}
//	cout<<now<<" "<<root[now]<<endl;
//	cout<<now<<" "<<T.seg[root[now]].val1<<" "<<T.seg[root[now]].val2<<endl;
	ans+=mul(T.seg[root[now]].val2,p2[max(n-sz[now]-1,0ll)]);modcg(ans);
}
void solve()
{
	MOD.init(mod);
	cin>>n;
	p2[0]=1;
	forn(i,1,n)
	{
		cin>>a[i];
		p2[i]=p2[i-1]+p2[i-1];modcg(p2[i]);
	}
	rep(i,n-1)
	{
		int x,y;
		cin>>x>>y;
		v[x].pb(y);
		v[y].pb(x);
	}
	dfs(1,0);
	cout<<ans<<endl;
}
/*======================================================================*/
signed main()
{
    cin.tie(0);
    cout.tie(0);
	std::ios::sync_with_stdio(false);
//#define Hank2007
#ifdef Hank2007
	freopen("input.txt","r",stdin);
	freopen("output1.txt","w",stdout);
#endif
  	/*====================================================================*/
  	int TEST_CASE=1;
//	cin>>TEST_CASE;
  	while(TEST_CASE--)
  	{
  		solve();
  	}
  	return 0;
}