#include<bits/stdc++.h>
using namespace std;
typedef long long ll;
typedef pair<int,int> pii;
const int MAXN = 2e5 + 5;
const int mod = 998244353;

inline void add_mod(int &a,int b){ a+=b; if(a>=mod) a-=mod;}

struct BIT
{
	int tree[MAXN], n;
	#define lowbit(x) ((x)&-(x))
	void init(int _n)
	{
		n = _n;
		fill(tree+1, tree+n+1, 0);
	}
	void update(int x,int k)
	{
		while(x<=n)
			add_mod(tree[x], k), x += lowbit(x);
	}
	void update(int l,int r,int k)
	{
		if(l>r) return;
		update(l,k); update(r+1, mod-k);
	}
	int query(int x)
	{
		int res = 0;
		while(x)
			add_mod(res, tree[x]), x ^= lowbit(x);
		return res;
	}
	int query(int l,int r)
	{
		if(l>r) return 0;
		return (query(r)-query(l-1)+mod) %mod;
	}
};

int n,m;
vector<int> g[MAXN];

int anc[MAXN], siz[MAXN], dep[MAXN], son[MAXN];
void dfs_tree(int u,int fa)
{
	siz[u] = 1; son[u] = 0;
	for(int v: g[u]) if(v != fa)
	{
		anc[v] = u; dep[v] = dep[u] + 1;
		dfs_tree(v,u);
		siz[u] += siz[v];
		if(siz[v] > siz[son[u]]) son[u] = v;
	}
}
int dfn[MAXN], seq[MAXN], curdfn = 0, top[MAXN];
void dfs_dfn(int u,int fa,int tp)
{
	top[u] = tp; dfn[u] = ++curdfn; seq[curdfn] = u;
	if(son[u]) dfs_dfn(son[u], u, tp);
	for(int v: g[u]) if(v != fa && v != son[u])
		dfs_dfn(v, u, v);
}
int lca(int u,int v)
{
	while(top[u] != top[v]) dep[top[u]] > dep[top[v]]? u = anc[top[u]]: v = anc[top[v]];
	return dep[u] < dep[v]? u: v;
}

int todep(int u,int k)
{
	while(dep[u] > k)
		u = dep[top[u]] > k? anc[top[u]]: seq[dfn[u] - (dep[u] - k)];
	return u;
}
int getnear(int u,int v) // u -> v
{
	assert(u != v);
	if(dfn[v] <= dfn[u] && dfn[u] <= dfn[v] + siz[v] - 1)
		return todep(u, dep[v] + 1);
	else
		return anc[v];
}
int get_rotate_siz(int u,int v)
{
	assert(u != v);
	v = getnear(v, u);
	if(v == anc[u])
		return siz[u];
	else
		return n - siz[v];
}
bool insub(int u,int v)
{
	return dfn[v] <= dfn[u] && dfn[u] <= dfn[v] + siz[v] - 1;
}

namespace P1
{
	vector<int> h[MAXN];
	
	void add_path(int u,int v)
	{
		h[u].emplace_back(v);
		h[v].emplace_back(u);
	}
	
	int val[MAXN];
	void dfs_val(int u,int fa)
	{
		for(int v: g[u]) if(v != fa)
			dfs_val(v, u);
		
		val[u] = n;
		int cur = n - siz[u];
		for(int v: g[u]) if(v != fa)
		{
			val[u] = (val[u] + (ll)cur * siz[v]) %mod;
			cur += siz[v];
		}
	}
	
	int tim[MAXN], curtim = 0;
	bool iskey[MAXN];
	vector<int> tr[MAXN];
	void new_Node(int u)
	{
		if(tim[u] != curtim)
		{
			tim[u] = curtim;
			iskey[u] = 0;
			tr[u].clear();
		}
	}
	void add_edge(int u,int v)
	{
		tr[u].emplace_back(v);
		tr[v].emplace_back(u);
	}
	
	void build_tr(vector<int> vec)
	{
		sort(vec.begin(), vec.end(), [&] (int x,int y){
			return dfn[x] < dfn[y];
		});
		
		static int sta[MAXN];
		int tp = 0;
		++curtim;
		new_Node(1); sta[++tp] = 1;
		for(int u: vec)
		{
			int v = lca(u, sta[tp]); --tp;
			new_Node(u); new_Node(v);
			while(dep[sta[tp]] >= dep[v]) add_edge(sta[tp], sta[tp+1]), --tp;
			if(sta[tp+1] != v) add_edge(sta[tp+1], v);
			sta[++tp] = v;
			if(u != v) sta[++tp] = u;
		}
		while(--tp) add_edge(sta[tp+1], sta[tp]);
		for(int u: vec)
			iskey[u] = 1;
	}
	
	int ans = 0;
	
	int f[MAXN], trsiz[MAXN], tranc[MAXN];
	void dfs(int u,int fa,int rt,int rtsonsiz)
	{
		tranc[u] = fa;
		f[u] = 0; trsiz[u] = get_rotate_siz(u, rt);
		for(int v: tr[u]) if(v != fa)
		{
			dfs(v,u,rt,rtsonsiz);
			ans = (ans + (ll)f[u] * f[v]) %mod;
			if(iskey[u])
			{
				int x = getnear(v, u);//, sizx = get_rotate_siz(x, u);
				if(x != v)
				{
					int y = getnear(v, x), sizy = get_rotate_siz(y, u);
					ans = (ans + (ll)f[v] * (rtsonsiz - sizy + mod)) %mod;
				}
				else
				{
					for(int w: tr[v]) if(w != u)
					{
						int y = getnear(w, x), sizy = get_rotate_siz(y, u);
						ans = (ans + (ll)f[w] * (rtsonsiz - sizy + mod)) %mod;
					}
					if(iskey[v])
					{
						ans = (ans + (ll)val[v] - (ll)trsiz[v] * (n - rtsonsiz)) %mod;
						ans = (ans + mod) %mod;
					}
				}
			}
			add_mod(f[u], f[v]);
		}
		if(iskey[u]) add_mod(f[u], trsiz[u]);
	}
	
	void getres(int rt)
	{
		if(!h[rt].size()) return;
		vector<int> vec = h[rt]; vec.emplace_back(rt);
		build_tr(vec);
		
		for(int v: tr[rt])
			dfs(v, rt, rt, n - get_rotate_siz(rt, v));
	}
	
	int solve(void)
	{
		dfs_val(1,0);
		for(int i=1; i<=n; ++i)
			getres(i);
		return ans;
	}
}

namespace P2
{
	vector<pii> h[MAXN];
	
	void add_path(int u,int v)
	{
		int uv = lca(u,v);
		h[uv].emplace_back(u,v);
	}
	
	int ans = 0;
	BIT tree1, tree2, tree3, tree4;
	
	int f[MAXN];
	
	void dfs(int u,int fa)
	{
		vector<int> ch;
		for(int v: g[u]) if(v != fa)
			dfs(v, u), ch.emplace_back(v);
		
		vector<int> A;
		vector<pii> B;
		for(auto t: h[u])
		{
			int x = t.first, y = t.second;
			if(y == u) swap(x, y);
			if(x == u) A.emplace_back(y);
			else
			{
				if(dfn[x] > dfn[y]) swap(x, y);
				B.emplace_back(x, y);
			}
		}
		sort(B.begin(), B.end(), [&] (const pii &x,const pii &y){
			return dfn[x.second] < dfn[y.second];
		});
		
		for(int v: ch)
		{
			ans = (ans + (ll)f[u] * f[v]) %mod;
			add_mod(f[u], f[v]);
		}
		for(int x: A)
		{
			add_mod(f[u], siz[x]);
		}
		
		auto query = [&] (int x) -> ll
		{
			return (
				(ll)siz[x] * (tree1.query(dfn[anc[x]]) - tree1.query(dfn[u]) + mod)
				+ tree2.query(dfn[x], dfn[x] + siz[x] - 1)
			) %mod;
		};
		auto update = [&] (int x)
		{
			tree1.update(dfn[x], dfn[x] + siz[x] - 1, 1);
			tree2.update(dfn[x], siz[x]);
		};
		
		auto query34 = [&] (int x) -> ll
		{
			return (
				(ll)siz[x] * (tree3.query(dfn[anc[x]]) - tree3.query(dfn[u]) + mod)
				+ tree4.query(dfn[x], dfn[x] + siz[x] - 1)
			) %mod;
		};
		auto update34 = [&] (int x,int k)
		{
			tree3.update(dfn[x], dfn[x] + siz[x] - 1, k);
			tree4.update(dfn[x], (ll)siz[x] * k %mod);
		};
		
		for(int x: A)
		{
			int v = getnear(x, u);
			ans = (ans + (ll)query(x) * (n - siz[v])) %mod;
			ans = (ans + (ll)siz[x] * (tree2.query(dfn[u], dfn[u] + siz[u] - 1)
				- tree2.query(dfn[v], dfn[v] + siz[v] - 1) + mod)) %mod;
			update(x);
		}
		
		for(auto it: B)
		{
			int x = it.first, y = it.second;
			ans = (ans + (ll)query(x) * siz[y]) %mod;
			ans = (ans + (ll)query(y) * siz[x]) %mod;
		}
		
		static pii sta[MAXN];
		int tp = 0;
		for(auto it: B)
		{
			int x = it.second, y = it.first;
			while(tp && !insub(x, sta[tp].first))
			{
				update34(sta[tp].second, mod-1);
				--tp;
			}
			ans = (ans + (ll)siz[x] * query34(y)) %mod;
			sta[++tp] = {x, y};
			update34(y, 1);
		}
		while(tp)
		{
			update34(sta[tp].second, mod-1);
			--tp;
		}
	}
	
	int solve(void)
	{
		tree1.init(n);
		tree2.init(n);
		tree3.init(n);
		tree4.init(n);
		dfs(1,0);
		return ans;
	}
}

int main(void)
{
	int testid;
	scanf("%d%d%d",&testid,&n,&m);
	for(int i=1; i<n; ++i)
	{
		int u,v;
		scanf("%d%d",&u,&v);
		g[u].emplace_back(v);
		g[v].emplace_back(u);
	}
	
	dep[0] = -1;
	dfs_tree(1,0);
	dfs_dfn(1,0,1);
	
	for(int i=1; i<=m; ++i)
	{
		int u,v;
		scanf("%d%d",&u,&v);
		P1 :: add_path(u,v);
		P2 :: add_path(u,v);
	}
	
	int ans = 0;
	add_mod(ans, P1 :: solve());
	add_mod(ans, P2 :: solve());
	
	ans = ans * 2ll %mod;
	ans = (ans + (ll)n * (n+1) / 2 %mod * m) %mod;
	printf("%d\n",ans);
	return 0;
}